[JAVA] 중첩 클래스와 중첩 인터페이스

 

중첩 클래스와 중첩 인터페이스란?

중첩 클래스(Nested Class)란 클래스 내부에 선언한 클래스를 말하는데, 중첩 클래스를 사용하면 두 클래스의 멤버들을 서로 쉽게 접근할 수 있다는 장점과 외부에는 불필요한 관계 클래스를 감춤으로써 코드의 복잡성을 줄일 수 있다.

 

중첩 클래스
public class Name {
  class NestedClass {
 }
}

 

중첩 인터페이스
public class Name{
   interface NestedInterface {
  }
}

 

---

중첩 클래스

• 멤버 클래스: 클래스 멤버로서 선언되는 중첩 클래스
• 로컬 클래스: 메소드 내부에서 선언되는 중첩 클래스

 

선언 위치에 따른 분류		선언위치		설명
멤버 클래스	인스턴스 멤버 클래스	class A{ class B {...} }		A 객체를 생성해야만 사용할 수 있는 B 중첩 클래스
	정적 멤버 클래스	class A{ static class B{...} }		A 클래스로 바로 접근할 수 있는 B 중첩 클래스
로컬클래스		class A{ void method(){ class B{...} } }		method()가 실행할 때만 사용할 수 있는 B 중첩 클래스

 

멤버 클래스도 클래스이기에, 컴파일 하면 바이트 코드 파일(.class)가 생성된다.

바이트 코드 파일 이름

멤버클래스

A $ B .class
//
A = 바깥 클래스
B = 멤버 클래스

 

A $1 B .class
//
A = 바깥 클래스
B = 로컬 클래스

 

인스턴스 멤버 클래스

• static 키워드 없이 선언된 클래스다.
• 인스턴스 필드/메소드만 선언이 가능하다.
• 정적 필드/메소드는 선언할 수 없다.

class A{
	class B{
    	B() {}    // 생성자
        int field1;   // 인스턴스 필드
        //static int field2; 		정적 필드 X
        void method1(){}   // 인스턴스 메소드
        //static void method2()		정적 메소드 X
    }
}

 

--------------

A클래스 외부에서 인스턴스 멤버 클래스 B의 객체를 생성하려면

먼저 A 객체를 생성하고 B객체를 생성해야한다.

//A클래스 외부에서 인스턴스 멤버 클래스 B를 호출하려면,
//A 객체를 먼저 생성하고 B 객체를 생성한다.
A a= new A();
A.B b = a.new B();
b.field1 = 3;
b.method1();

 

 

정적 멤버 클래스

• static 키워드로 선언된 클래스를 말한다
• 모든 종류의 필드/메소드 선언 가능

class A{
	static class C{
    	C() {}  // 생성자
        int field1; //인스턴스 필드
        static int field2; 		// 정적 필드
        void method1(){}  //인스턴스 메소드
        static void method2()	// 정적 메소드	
    }
}

 

---

A 클래스 외부에서 정적 멤버 클래스 C의 객체를 생성하기 위해서는 A객체를 생성할 필요가 없고,

다음과 같이 C객체를 생성하면 된다.

//A클래스 외부에서 정적 멤버 클래스 C를 바로 호출한다.
A.C c = new A.C();
c.field1 = 3; // 인스턴스 필드 사용
c.method1(); //인스턴스 메소드 호출
A.C.field2 = 3; // 정적 필드 사용
A.C.method2(); // 정적 메소드 호출

 

로컬 클래스

중첩 클래스는 메소드 내에서도 선언할 수 있다. 이것을 로컬 클래스라고 한다.

접근 제한자(public, private), static 이용이 불가능하다.

(메소드 내부에서만 사용되기에) 로컬 클래스 내부에는 인스턴스 필드와 메소드만 선언 가능하다

정적 필드, 정적 메소드 선언할 수 없다.

void method() {
  class D{
    D() {} // 생성자
    int field1; // 인스턴스 필드
    //static int field2; // 정적필드(X)
      void method1() {} // 인스턴스 메소드
    //static  void method() {} // 정적 메소드(X)
   }
  D d =new D();
  d.field1 = 3;
  d.method1();
}

 

중첩 클래스의 접근 제한

바깥 필드와 메소드에서 사용 제한

인스턴스 멤버 클래스는 바깥 클래스에서 객체를 생성할 수 있으나, 정적 필드나 정적 메소드에서는 객체를 생성할 수 없다.

public class A {              // 바깥 클래스 A
    class B {                   // 내부 클래스 B
   }               
   B field1 = new B ( );    // B클래스의 바깥에서 B객체 생성 가능
   void method1( ) {       // B클래스의 바깥에서 메소드로 B객체 생성 가능
    B var1 = new B( );
  }
  static field2 = new B ( );  // 정적 필드에서는 B객체 생성 불가능
  static void method2( ) {   // 정적 메소드에서는 B객체 생성 불가능
    B var2 = new B( );
  }
}

 

멤버 클래스에서 사용 제한

멤버 클래스가 인스턴스 또는 정적으로 선엄됨에 따라, 멤버 클래스 내부에서 바깥 클래스의 필드와 메소드를 접근할 때에도 제한이 따른다.

 

 

로컬 클래스에서 사용 제한

자바는 이 문제를 해결하기 위해 컴파일 시 로컬 클래스에서 사용하는 매개 변수, 로컬 변수의 값을 로컬 클래스 내부에 복사해 두고 사용한다.

그리고 매개 변수, 로컬 변수가 수정된다면, 로컬 클래스에 복사해둔 값과 달라지는 문제를 해결하기위해 매개 변수, 로컬 변수를 final로 선언해서 수정을 막는다.

결론적으로 로컬 클래스에서 사용 가능한 것은 final로 선언된 매개 변수, 로컬 변수뿐이다.

 

 

중첩 클래스에서 바깥 클래스 참조 얻기

클래스 내부에서 this는 객체 자신의 참조이다.

중첩 클래스에서 this는 중첩 클래스의 객체 참조이다.

중첩 클래스 내부에서 바깥 클래스의 객체 참조를 얻으려면 바깥 클래스의 이름을 this앞에 붙여야한다.

 

바깥클래스.this.필드

바깥클래스.this.메소드();

 

중첩 인터페이스

중첩 인터페이스는 클래스의 멤버로 선언된 인터페이스를 말한다.

 

public class Button{
	OnClickListener listener;			//인터페이스 타입 필드
    
    void setOnClickListener(OnClickListener listener){ //다형성
    	this.listener = listener;
    }
    
    void touch(){				//구현 객체의 onClick() 호출
    	listener.onClick();
    }
    
    interface OnClickListener{ //중첩 인터페이스
    	void onClick();
    }
}

 

익명 객체

• 익명 객체는 이름이 없는 객체다.
• 생성할 수 없다.
• 클래스를 상속하거나, 인터페이스를 구현해야만 생성가능하다.
• 필드의 초기값, 로컬 변수의 초기값, 매개변수의 매개값으로 주로 대입된다.
• UI 이벤트 처리, 스레드 객체를 간편하게 생성할 목적으로 활용된다.

 

익명 자식 객체

부모클래스 [필드|변수] = new 부모클래스(매개값, ...){
	//필드
    //메소드
};

 

class Child extends Parent { } // 자식 클래스 선언
class A
{
    Parent field = new Child(); // 필드에 자식 객체를 대입
    void method()
    {
    	Parent localVar = new Child(); // 로컬 변수에 자식 객체를 대입
    }
}

 

익명 구현 객체 생성

class Child extends Parent { } // 자식 클래스 선언
class A
{
    Parent field = new Child(); // 필드에 자식 객체를 대입
    void method()
    {
    	Parent localVar = new Child(); // 로컬 변수에 자식 객체를 대입
    }

}

 

인터페이스 [필드|변수] = new 인터페이스(){
   // 인터페이스에 선언된 추상 메소드의 실체 메소드 선언
   // 필드
   // 메소드
};

 

익명 객체의 로컬 변수 사용

익명 객체 내부에서는 바깥 클래스의 필드나 메소드는 제한 없이 사용할 수 있다. 문제는 메소드의 매개 변수나 로컬 변수를 익명 개체에서 사용할 때이다. 메소드 내에서 생성된 익명 객체는 메소드 실행이 끝나도 힙 메모리에 존재해서 계속 사용할 수 있다. 매개 변수나 로컬 변수는 메소드 실행이 끝나면 스택 메모리에서 사라지기 때문에 익명 객체에서 사용할 수 없게 되므로 문제가 발생한다.