09-1 중첩 클래스와 중첩 인터페이스 소개

객체 지향 프로그래밍에서 클래스들은 서로 긴밀한 관계를 가지며 상호작용을 한다.

어떤 클래스는 여러 클래스들과 관계를 갖기도 하고, 어떤 클래스는 특정 클래스만 관계를 갖기도 한다.

첫번째의 경우에는 독립적으로 선언하는 것이 좋으나, 두번째의 경우는 클래스 내부에 선언하는 것이 좋다.

이번 포스팅은 두번째의 경우 클래스 내부에 선언하는 중첩 클래스와 중첩 인터페이스에 대한 내용이다.

 

먼저, 중첩 클래스(nested class)란 클래스 내부에 선언한 클래스를 말한다.

중첩 클래스를 사용하면 두 클래스의 멤버들을 서로 쉽게 접근이 가능하며, 외부에는 클래스 관계를 감춤으로써 코드의 복잡성을 줄일 수 있다. 

중첩 클래스의 코드 형태는 다음과 같다.

//클래스
class ClassName{
  //중첩 클래스
  class NestedClassName {
  }
}

또한 인터페이스도 클래스 내부에 선언할 수 있는데, 이런 인터페이스를 중첩 인터페이스(nested interface)라고 한다.

인터페이스를 클래스 내부에 선언하는 이유는 해당 클래스와 긴밀한 관계를 맺는 구현 클래스를 만들기 위해서이다.

중첩 인터페이스의 코드 형태는 다음과 같다.

//클래스
class ClassName{
  //중첩 인터페이스
  interface NestedinterfaceName {
  }
}

 

<중첩 클래스>

중첩 클래스는 클래스 내부에 선언되는 위치에 따라서 두 가지로 분류된다.

클래스의 멤버로 선언된다면 멤버 클래스라고 하며, 생성자 또는 메소드 내부에서 선언된다면 로컬 클래스라고 한다.

멤버 클래스는 클래스나 객체가 사용 중이라면 언제든지 재사용이 가능하지만, 로컬 클래스는 메소드를 실행할 때만 사용되고 메소드가 종료되면 없어진다는 차이점이 있다.

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

멤버 클래스일 경우 바이트 코드 파일의 이름은 [바깥 클래스]$[멤버 클래스].class 로 결정되고,

로컬 클래스일 경우 [바깥 클래스]$1[로컬 클래스].class로 결정된다. 

즉, 위의 표와 같이 선언되었을 경우, 멤버 클래스의 이름은 A$B.class로 결정되며, 

로컬 클래스의 이름은 A$1B.class가 된다.

 

▶ 인스턴스 멤버 클래스

인스턴스 멤버 클래스는 static 키워드 없이 중첩 선언된 클래스를 말한다.

인스턴스 멤버 클래스는 필드와 메소드만 선언이 가능하며, 정적 필드와 정적 메소드는 선언할 수 없다.

다음은 인스턴스 멤버 클래스의 예시이다.

class A{
  //인스턴스 멤버 클래스
  class B {
    B() {}  //생성자
    int field1;  //인스턴스 필드
    //static int field2;  //정적 필드 불가능
    void method1() {}  //인스턴스 메소드
    //static void method2() {}  //정적 메소드 불가능
  }
}
    

A 클래스 외부에서 B 객체를 생성하려면 먼저 A 객체를 생성한 후 B 객체를 생성해야 한다.

반대로 A 클래스 내부에서는 일반 클래스처럼 B 객체를 생성할 수 있다.

//A 클래스 외부 예시
A a = new A();
A.B b = a.new B();
b.field1 = 3;
b.method1();

//A 클래스 내부 예시
class A{
  class B{...}
  
  void methodA(){
    B b = new B();
    b.field = 3;
    b.method1();
  }
}

하지만 일반적으로 A 클래스 외부에서 B 객체를 생성하는 일은 거의 없으며 대부분 A 클래스 내부에서 B 객체를 생성해서 사용한다.

 

▶ 정적 멤버 클래스

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

다음은 정적 멤버 클래스의 예시이다.

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

A클래스 외부에서 정적 멤버 클래스 C의 객체를 생성하기 위해서는 A 객체를 생성할 필요가 없으며 C 객체를 생성하면 된다.

A.C c = a.new C();
c.field1 = 3;  //인스턴스 필드 사용
c.method1();   //인스턴스 메소드 사용
A.C.field2 = 3;  //정적 필드 사용
A.C.method2();   //정적 메소드 사용

 

▶ 로컬 클래스

로컬 클래스는 메소드 내부에서만 사용므로 접근 제한자(public, private) 및 static을 붙일 수 없다.

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

class A{
  //로컬 클래스
  class D {
    D() {}  //생성자
    int field1;  //인스턴스 필드
    //static int field2;  //정적 필드 불가능
    void method1() {}  //인스턴스 메소드
    //static void method2() {}  //정적 메소드 불가능
  }
  D d = new D();
  d.field1 = 3;
  d.method1();
}

로컬 클래스는 메소드가 실행될 때 메소드 내에서 객체를 생성하고 사용해야 한다.

때문에 주로 비동기 처리를 위해 스레드 객체를 만들 때 사용한다.

 

다음은 중첩 클래스의 전체적인 이해를 위한 예시이다.

1. 중첩 클래스

/**바깥 클래스**/
class A {
	A() { System.out.println("A 객체가 생성됨"); }
	
	/**인스턴스 멤버 클래스**/
	public 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 method1() { }
		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.method1();
	}
}

2. 중첩 클래스 객체 생성

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();
	}
}

결과 : 

 

<중첩 클래스의 접근 제한>

각 파트 별 코드를 참고하여 이해하자.

 

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

바깥 클래스에서 인스턴스 멤버 클래스를 사용할 때 제한이 따른다.

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 {}	
}

인스턴스 멤버 클래스(B)는 바깥 클래스의 인스턴스 필드(field1)의 초기값이나 인스턴스 메소드(method1())에서 객체를 생성할 수 있지만 정적 필드(field3)의 초기값이나 정적 메소드(method2())에서는 객체를 생성할 수 없다.

반면에 정적 클래스(C)는 모든 필드의 초기값이나 모든 메소드에서 객체를 생성할 수 있다.

 

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

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

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();
		}
	}	
}

인스턴스 멤버 클래스(B)안에서는 바깥 클래스의 모든 필드와 모든 메소드에 접근할 수 있지만,

정적 멤버 클래스(C) 안에서는 바깥 클래스의 정적 필드(field2)와 메소드(method2())에만 접근할 수 있고

인스턴스 필드(field1)와 메소드(method1())에는 접근이 불가능하다.

 

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

메소드의 매개 변수나 로컬 변수를 로컬 클래스에서 사용할 때 제한이 따른다.

로컬 클래스의 객체는 메소드 실행이 종료될 때 없어지는 것이 일반적이지만, 메소드가 종료되어도 계속 실행 상태로 존재할 수 있다. (ex : 로컬 스레드 객체를 사용할 때)

이런 문제를 해결하기 위해 컴파일 시 로컬 클래스에서 사용하는 매개 변수나 로컬 변수의 값을 로컬 클래스 내부에 복사한 후 사용한다. 그리고 매개 변수가 로컬 변수가 수정되어 값이 변경되면 로컬 클래스에 복사해둔 값과 달라지기 때문에 매개 변수나 로컬 변수를 final로 선언할 것을 요구한다.

(자바 7 이전까지는 final 선언이 없으면 컴파일 에러가 발생했지만, 자바 8 이후로 final특성을 자동으로 부여함.)

다음 예제는 매개 변수와 로컬 변수가 final 특성을 갖고 있음을 보여준다.

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

 

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

클래스 내부에서 this는 객체 자신의 참조이지만 중첩 클래스에서 this 키워드를 사용하면 중첩 클래스의 객체 참조이다.

따라서 중첩 클래스 내부에서 'this.필드, this.메소드()'로 호출하면 중첩 클래스의 필드와 메소드가 사용된다.

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

다음은 중첩 클래스에서 바깥 클래스 참조 얻는 예제이다.

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();
		}
	}
}

public class OutterExample {
	public static void main(String[] args) {
		Outter outter = new Outter();
		Outter.Nested nested = outter.new Nested();
		nested.print();
	}
}

결과 :

 

<중첩 인터페이스>

중첩 인터페이스는 인스턴스 멤버 인터페이스와 정적 멤버 인터페이스 모두 가능하다.

인스턴스 멤버 인터페이스는 바깥 클래스의 객체가 있어야 사용이 가능하며, 정적 멤버 인터페이스는 바깥 클래스의 객체 없이 바로 접근이 가능하다.

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

한 가지 예로, Button을 클릭했을 때 이벤트를 처리하는 객체를 받는 것을 들 수 있다.

이 때, 아무 객체나 받으면 안 되고, Button 내부에 선언된 중첩 인터페이스를 구현한 객체만 받아야 한다면 다음과 같이 Button 클래스를 선언하면 된다.

1. 중첩 인터페이스

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

중첩 인터페이스 타입으로 필드를 선언하고, Setter 메소드로 구현 객체를 받아 필드에 대입한다.

버튼 이벤트가 발생했을 때 인터페이스를 통해 구현 객체의 메소드를 호출한다.

 

2.  구현 클래스 1

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

3. 구현 클래스 2

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

2와 3은 버튼을 클릭했을 때 이벤트를 처리하는 방법들이다.

어떤 구현 객체를 생성해서 Button 객체의 setOnClickListener() 메소드로 세팅하느냐에 따라 Button의 touch()메소드의 실행결과가 달라진다.

 

4. 버튼 이벤트 처리

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();
	}
}

결과 :