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

중첩 클래스(nested class)

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

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

클래스의 멤버로서 선언되는 중첩 클래스를 멤버 클래스라고 하고, 생성자 또는 메소드 내부에서 선언되는 중첩 클래스를 로컬 클래스라고 하며, 멤버 클래스는 클래스나 객체가 사용중이라면 언제든지 재사용이 가능하지만, 로컬 클래스는 메소드를 실행할 때만 사용되고 메소드가 종료되면 없어짐.

중첩 클래스도 하나의 클래스이기 때문에 컴파일하면 바이트 코드 파일(.class)이 별도로 생성됨.

---

인스턴스 멤버 클래스

static 키워드 없이 중첩 선언된 클래스를 말하며, 인스턴스 멤버 클래스는 인스턴스 필드와 메소드만 선언이 가능하고 정적 필드와 메소드는 선언할 수 없음.

 

정적 멤버 클래스

static 키워드로 선언된 클래스를 말하며, 정적 멤버 클래스는 모든 종류의 필드와 메소드를 선언할 수 있다.

 

로컬 클래스

중첩 클래스는 메소드 내에서도 선언할 수 있는데, 이것을 로컬(local)클래스라고 하며 접근제한자(public, private) 및 static을 붙일 수 없으며 로컬 클래스는 메소드 내부에서만 사용되므로 접근을 제한할 필요가 없음.

로컬 클래스 내부에는 인스턴스 필드와 메소드만 선언할 수 있고 정적 필드와 메소드는 선언할 수 없음.

---

// 중첩 클래스

package sec01.exam01;

	// 바깥 클래스
	class A {
      A() { System.out.println("A 객체가 생성됨"); }
      
	// 인스턴스 멤버 클래스
    class B {
      B() { System.out.println("B 객체가 생성됨"); }
      int field1;
      // static int field2;
      void method1() { }
      // static void method2() { }
   }
   
    // 정적 멤버 클래스
    static class C {
      C() { System.out.println("C 객체가 생성됨"); }
      int field1;
      static int field2;
      void method() { }
	  static void method2() { }
   }
   
   void method() {
     // 로컬 클래스
     class D {
       D() { System.out.println("D 객체가 생성됨"); }
       int field1;
       // static int field2;
       void method1() { }
       // static void method2() {}
    }
    D d = new D();
    d.field1 = 3;
    d.method();
  }
}

// 중첩 클래스 객체 생성

package sec01.exam01;

public class Main {
	public static void main(String[] args) {
    	A a = new A();
        
        // 인스턴스 멤버 클래스 객체 생성
        A.B b = a.new B();
        b.field1 = 3;
        b.method1();
        
        // 정적 멤버 클래스 객체 생성
        A.C c = new A.C();
        c.field1 = 3;
        c.method1();
        A.C.field2 = 3;
        A.C.method2();
        
        // 로컬 클래스 객체 생성을 위한 메소드 호출
        a.method();
    }
}

// 실행 결과
// A 객체가 생성됨
// B 객체가 생성됨
// C 객체가 생성됨
// D 객체가 생성됨

---

중첩 클래스의 접근 제한

 

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

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

package sec01.exam02;

public class A {

  // 인스턴스 필드
    B field1 = new B();
    C field2 = new C();
    
  // 인스턴스 메소드
    void method1() {
    	B var1 = new B();
        C var2 = new C();
    }
    
    // 정적 필드 초기화
    // static B field3 = new B();
    static C field4 = new C();
    
    // 정적 메소드 
    static void method2() {
    	// B var1 = new B();	<--- 불가
        C var2 = new C();
   }
   
   // 인스턴스 멤버 클래스
   class B {}
   
   // 정적 멤버 클래스
   static class C {}
 }

 

멤버 클래스에서 사용 제한

// 멤버 클래스에서 사용 제한

package sec01.exam03;

public class A {
	int field1;
    void method1() { }
    
    static int field2;
    static void method2() { }
    
    class B {
    	void method() {
        
        field1 = 10;		// 모든 필드와 메소드에 접근할 수 있음.
        method1();
        
        field2 = 10;
        method2();
    }
  }
  
  static class C {
  	void method() {
    	// field1 = 10;
        // method1();
        
        field2 = 10;		// 인스턴스 필드와 메소드는 접근할 수 없음.
        method2();
    }
  }
}

 

로컬 클래스에서 사용 제한

// 로컬 클래스에서 사용 제한

package seco1.exam04;

public class Outter {
	// 자바 8 이후
	public void method2(int arg) {		// 자바 7이전은 final int arg
    int localVariable = 1;
    // arg = 100;		        <---- X
    // localVariable = 100;		<---- X
    class Inner {
    	public void method() {
        	int result = arg + localVariable;
        }
     }
   }
}

* 자바 7까지는 반드시 final 키워드를 붙여야 되지만, 자바 8부터는 final 키워드를 붙이지 않아도 final 특성을 가지고 있음.

---

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

클래스 내부에서 this는 객체 자신의 참조인데, 중첩 클래스에서 this 키워드를 사용하면 바깥 클래스의 객체 참조가 아니라, 중첩 클래스의 객체 참조가 됨. 따라서 중첩 클래스 내부에서 'this.필드, this.메소드()'로 호출하면 중첩 클래스의 필드와 메소드가 사용됨.

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

 

// 중첩 클래스에서 바깥 클래스 참조 얻기
package sec01.exam05;

public class Outter {
	String field = "Outter-field";
    void method() {
    	System.out.println("Outter-method");
   }
   
   class Nested {
   	String field = "Nested-field";
    void method() {
    	System.out.println("Nested-method");
    }
    void print() {
    	System.out.println(this.field);		// 중첩 객체 참조
        this.method();
        System.out.println(Outter.this.field);	// 바깥 객체 참조
        Outter.this.method();
    }
  }
}

// 실행 클래스

package sec01.exam05;

public class OutterExample {
	public static void main(String[] args) {
    	Outter outter = new Outter();
        Outter.Nested nested = outter.new Nested();
        nested.print();
     }
  }
  
// 실행 결과
// Nested-field
// Nested-method
// Outter-field
// Outter-method

---

중첩 인터페이스(nested interface)

인터페이스도 클래스 내부에 선언할 수 있는데, 이런 인터페이스를 중첩 인터페이스라고 하며, 인터페이스를 클래스 내부에 선언하는 이유는 해당 클래스와 긴밀한 관계를 맺는 구현 클래스를 만들기 위해서임.

중첩 인터페이스는 인스턴스 멤버 인스턴스와 정적 멤버 인터페이스 모두 가능하며, 인스턴스 멤버 인터페이스는 바깥 클래스의 객체가 있어야 사용이 가능하고, 정적 멤버 인터페이스는 바깥 클래스의 객체 없이 바깥 클래스만으로 바로 접근할 수 있음. 

주로 정적 멤버 인터페이스를 많이 사용하는데 UI프로그래밍에서 이벤트를 처리할 목적으로 많이 활용 됨.

// 중첩 인터페이스

package sec01.exam06;

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

// 구현 클래스
package sec01.exam06;

public class CallListener implements Button.OnClickListener {
	@Override
    public void onClick() {
    	System.out.println("전화를 겁니다.");
    }
}

// 구현 클래스

package sec01.exam06;

public class MessageListener implements Button.OnClickListener {
	@Override
    public void onClick() {
    	System.out.println("메세지를 보냅니다.");
    }
 }

// 버튼 이벤트 처리

package sec01.exam06;

public class ButtonExample {
	public static void main(String[] args) {
    	Button btn = new Button();
        
        btn.setOnClickListener( new CallListener() );
        btn.touch();
        
        btn.setOnClickListener( new MessageListener() );
        btn.touch();
     }
}

// 실행 결과
// 전화를 겁니다.
// 메세지를 보냅니다.

 

---

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

 

🔘 멤버 클래스: 클래스의 멤버로서 선언되는 중첩 클래스를 말하며, 멤버 클래스는 바깥 객체의 필요 여부에 따라 인스턴스 멤버 클래스와 정적(static) 멤버 클래스로 구분됨.

 

🔘 로컬 클래스: 생성자 또는 메소드 블록 내부에 선언된 중첩 클래스를 말함.

 

🔘 중첩 인터페이스: 클래스의 멤버로 선언된 인터페이스를 말하며, 중첩 인터페이스는 인스턴스 멤버 인스턴스와 정적(static)멤버 인터페이스 모두 가능함. 주로 정적 멤버 인터페이스를 많이 사용하는데 UI프로그래밍에서 이벤트를 처리할 목적으로 많이 활용 됨.