java 기본 13: 중첩 클래스(중첩(인스턴스)클래스, 정적 중첩 클래스, 로컬 클래스, 익명 클래스

중첩 클래스

- 클래스 또는 메소드 안에 정의된 클래스

- 특징

    * 외부에 공개할 필요 없는 클래스를 감출 수 있음

    * 클래스 안에 클래스를 정의하면 두 클래스 간의 접근이 서로 수월함

- 종류

    * 중첩 클래스(인스턴스 클래스)

    * 정적 중첩 클래스(정적 클래스)

    * 로컬 클래스

    * 익명 클래스

 

중첩 클래스(인스턴스 클래스) 선언

  - nested class, 인스턴스 클래스

  - 인스턴스 멤버로 선언되는 중첩 클래스

  - static 키워드 없이 선언

  - 인스턴스 필드, 메소드만 선언할 수 있음

public class Outer{
	class Inner{
    	Inner() {} // 생성자
        int a; //인스턴스 필드
        void methodA() {}//인스턴스 메소드
    }
}

중첩클래스 객체 생성

//클래스 내부에서 접근
Inner inner = new Inner(); //기존 객체 생성 방식 그대로 처리

//클래스 외부에서 접근
Outer outer = new Outer();  //Outer 객체를 생성한 뒤 중첩클래스에 접근할 수 있음
Outer.Inner inner = outer.new Inner();

//inner 인스턴스의 필드, 메소드 호출
inner.a = 15;
inner.methodA()

 

정적 중첩 클래스

  - static nested class, 정적 클래스

  - 정적 멤버로 선언되는 중첩 클래스

  - static 키워드로 선언

  - 모든 필드, 메소드를 선언할 수 있음

public class Outer{
	//정적 중첩클래스
    //모든 생성자, 인스턴스멤버, 정적멤버(필드, 메소드)를 선언할 수 있음.
	static class Inner{
    	Inner(){}
        int a;
        static int b;
        void methodA() {}
        static void methodB();
    }
}

정적 중첩 클래스의 객체 생성

// Outer 클래스 인스턴스를 생성하지 않고도 
// Outer 클래스명으로 바로 중첩 클래스(Inner)에 접근 가능
Outer.Inner inner = new Outer.Inner();
inner.a = 15;
inner.methodA();
Outer.Inner.b = 20;
Outer.Inner.methodB();

 

로컬 클래스 선언

  - local class, 지역클래스

  - 메소드 안에 선언된 클래스

  - 접근 제한자, static을 붙일 수 없음

  - 메소드 내부에서만 사용됨

  - 인스턴스 필드와 메소드만 선언할 수 있음

//메소드 선언
void outerMethod(){
	//메소드 안에 클래스 선언(로컬클래스)
	class Inner{
    	Inner(){}; // 생성자
        int a; //인스턴스 필드
        void methodA() {}  // 인스턴스 메소드
    }
    
    //메소드 내부에서만 접근 가능
    Inner inner = new Inner();
    inner.a = 15;
    inner.methodA();
}

 

익명 클래스

  - 익명클래스: 이름이 없는 클래스

  - 클래스 선언과 동시에 객체를 생성

  - 단발성으로 사용하는 경우에 익명클래스를 이용

  - 상속, 인터페이스 구현을 해야만 익명클래스로 만들 수 있음

//기존: 자식클래스 A 선언
public class A extends B{
	int a;
    void methodA() {}
    
    @Override
    void methodB() {}
}
B childClass = new A();

//익명클래스: 상속받을 자식클래스를 익명클래스로 바로 선언, 자식객체 생성
B anonymousClass = new B(){
	int a;
    void methodA() {}
    
    @Override
    void methodB() {}
}

 

인터페이스 구현 객체를 익명클래스로 선언하기

인터페이스는 public class LivingRoom implements Light{...} 와 같이 클래스를 생성하고, 그 클래스에서 implements하여 상속받은 후 클래스의 인스턴스를 생성하여 메소드를 호출하는 방식으로 동작
 >> 인터페이스 Light를 상속받는 클래스를 익명 클래스로 구현하여 이를 간소화할 수 있음

interface Light{
	void switchOn();
}

interface MyString{
	String myString();
}


//main
// 인터페이스명에 생성자 new를 붙여 익명클래스를 생성하고, 구현을 바로 정의한다.
new Light(){
    @Override
    public void switchOn(){
        System.out.println("불켜!");
    }
}.switchOn(); //불켜!


// 인스턴스를 생성
Light livingRoomLight = new Light(){
    @Override
    void switchOn(){
    	System.out.println("거실 불을 켭니다");
    }
}
livingRoomLight.switchOn(); //거실 불을 켭니다

// 익명클래스의 중첩
//"거실 불을 켭니다"를 또 다른 익명클래스로 받는 경우
Light light = new Light(){
    @Override
    public void switchOn{
    	MyString m_str = new MyString(){
        	@Override
            String myString(){
            	return "거실 불을 켭니다";
            }
        }
        System.out.println(m_str.myString());
    }
}
light.switchOn(); //거실 불을 켭니다