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

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

class ClassName{
 class NestedclassName {
  }
 }

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

class ClassName {
interface NestedInterfaceName{
 }
}

중첩 클래스

중첩 클래스는 클래스 내부에 선언되는 위치에 따라서  두 가지로 분류됩니다. 클래스의 멤버로서 선언되는 중첩 클래스를 멤버 클래스라고 하고, 생성자 메소드 내부에서 선언되는 중첩 클래스를 로컬 클래스라고 합니다. 멤버 클래스는 클래스나 객체가 사용 중이라면 언제든지 재사용이 가능하만, 로컬 클래스는 메소드를 실행할 때만 사용되고, 종료시 사라집니다.

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

멤버 클래스일 경우 바이트 코드 파일의 이름은 다음과 같이 결정됩니다.

A $ B .class

로컬 클래스일 경우에는 다음과 같이 $1이 포함된 바이트 코드 파일이 생성됩니다.

A $1 B .class

인스턴트 멤버 클래스

인스턴트 멤버 클래스는 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 클래스 외부

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.field1 = 3;
 b.method1();
 }
}

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

정적 멤버 클래스

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

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

A 클래스 외부에서 정적 멤버 클래스 C의 객체를 생성하기 위해서는 A 객체를 생성할 필요가 없고, 다음과 같이 C객체를 생성하면 됩니다.

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

로컬 클래스

중첩 클래스는 메소드 내에서도 선언할 수 있는데, 이것을 로컬 클래스라고 합니다. 로컬 클래스는 접근 제한자(public,private) 및 static을 붙일 수 없습니다. 로컬 클래스는 메소드 내부에서만 사용되므로 접근을 제한할 필요가 없기 때문입니다. 로컬 클래스 내부에는 인스턴스 필드만 선언할 수 있고 정적 필드와 메소드는 선언할 수 없습니다.

void method() {
 /**로컬클래스**/
 class D {
  D() {}
  int field1;
  //static int field2;
  void method1() {}
  //static void method2() {}
 }
 D d = new D();
 d.field1 = 3;
 d.method1();
}

로컬 클래스는 메소드가 실행될 때 메소드 내에서 객체를 생성하고 사용해야 합니다. 주로 다음과 같이 비동기 처리를 위해 스레드 객체를 만들 때 사용합니다.

void method() {
 class DownloadThread extends Thread { ... }
 DownloadThread thread = new DownloadThread();
 thread.start();
}

중첩 클래스 

package ch09;

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

중첩 클래스 객체 생성

package ch09;

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

중첩 클래스의 접근 제한

멤버 클래스 내부에서 바깥 클래스의 필드와 메소드에 접근할 때는 제한이 따릅니다. 또한 메소드의 매개 변수나 로컬 변수를 로컬 클래스에서 사용할 때도 제한이 따릅니다.

 

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

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

package ch09;

public class A2 {
	//인스턴스 필드
	B field1 = new B();
	C firld2 = new C();
	
	//인스턴스 메소드
	void method() {
	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();  //(x)
		C var2 = new C();   //(o)
}
	
	//인스턴스 멤버 클래스
	class B {}
	
	//정적 멤버 클래스
	static class C{}
}

멤버 클래스에서 사용 제한

멤버 클래스가 인스턴스 또는 정적으로 선언됨에 따라 멤버 클래스 내부에서 바깥 클래스의 필드와 메소드에 접근할 때에도 제한이 따릅니다. 인스턴스 멤버 클래스(B) 안에서는 바깥 클래스의 모든 필드와 모든 메소드에 접근할 수 있지만, 정적 멤버 클래스(C) 안에서는 바깥 클래스의 정적 필드(field2)와 메소드 (method2())에만 접근할 수 있고 인스턴스 필드(field1)와 메소드(method1())에는 접근할 수 없습니다.

 

전부 접근가능

class A {
int field1;
void method1() {...}

static int field2;
static void method2() {...}

class B {
 void method() {
   field1 = 10;
   method();
   
   field2 = 10;
   method2();
   }
  }
 }

바깥 클래스의 필드와 메서드에 접근불가능

class A {
int field1;
void method1() {...}

static int field2;
static void method2() {...}

static class C {
 void method() {
   field1 = 10;
   method();
   
   field2 = 10;
   method2();
   }
  }
 }

멤버 클래스에서 사용 제한

package ch09;

public class A3 {
	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();
			//인스턴스 필드와 메소드는 접근할 수 없음
		}
	}
}

로컬 클래스에서 사용 제한

메소드의 매개 변수나 로컬 변수를 로컬 클래스에서 사용할 때 제한이 있습니다. 로컬 클래스의 객체는 메소드 실행이 종료되면 없어지는 것이 일반적이지만, 메소드가 종료되어도 계속 실행 상태로 존재할 수 있습니다.

 

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

복사해두고 사용합니다. 그리고 매개 변수나 로컬 변수가 수정되어 값이 변경되면 로컬 클래스에 복사해둔 값과 달라지므로 문제를 해결하기 위해 매개 변수나 로컬 변수를 final로 선언할 것을 요구합니다.

 

다음 예제는 매개변수와 로컬 변수를 로컬 클래스 내부에서 사용할 때 매개 변수와 로컬변수가 final특성을 갖고 있음을 보여줍니다.

로컬 클래스에서 사용 제한

package ch09;

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

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

중첩 클래스 내부에서 바깥 클래스의 객체 참조를 얻으려면 바깥 클래스의 이름을 this 앞에 붙여주면 됩니다. 다음은 중첩 클래스 내부에서 바깥 클래스의 필드와 메소드에 접근하기 위해 '바깥클래스.this'를 사용한 예입니다.

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

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

package ch09;

public class Outter2 {
	String field = "Outter2-field";
	void method() {
		System.out.println("Outter2-method");
	}
	
	class Nested {
		String field = "Nested-field";
		void method() {
			System.out.println("Nested-field");
		}
		void print() {
			System.out.println(this.field);
			this.method();
			System.out.println(Outter2.this.field);
			Outter2.this.method();
		}
	}
}

실행 클래스

package ch09;

public class Outter2Example {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Outter2 outter2 = new Outter2();
		Outter2.Nested nested = outter2.new Nested();
		nested.print();
	}

}

중첩 인터페이스

중첩 인터페이스는 클래스의 멤버로 선언된 인터페이스를 말합니다. 인터페이스를 클래스 내부에 선언하는 이유는 해당 클래스와 긴밀한 관계를 맺는 구현 클래스를 만들기 위해서입니다.

class A {
[static] interface I {           // 중첩 인터페이스
 void method();
 }
}

중첩 인터페이스는 인스턴스 멤버 인터페이스와 정적 멤버 인터페이스 모두 가능합니다. 인스턴스 멤버 인터페이스는 바깥 클래스의 객체가 있어야 사용 가능하며, 정적 멤버 인터페이스는 바깥 클래스의 객체 없이 바깥 클래스만으로 바로 접근할 수 있습니다. 주로 정적 멤버 인터페이스를 많이 사용하는데 UI 프로그래밍에서 이벤트를 처리할 목적으로 많이 활용됩니다.

 

예를 들어 Button을 클릭했을 때 이벤트를 처리하는 객체를 받고 싶다고 가정하고 아무 객체나 받지 않으며 Button 내부에 선언된 중첩 인터페이스를 구현한 객체만 받아야 합니다.

중첩 인터페이스

Button 클래스 내용을 보면 중첩 인터페이스타입(OnClickListener)으로 필드(listener)를 선언하고, Setter 메소드(setOnClickListener)로 구현 객체를 받아 필드에 대입합니다. 버튼 이벤트가 발생했을 때(touch()메소드가 실행되었을 때) 인터페이스를 통해 구현 객체의 메소드를호출(listenet.OnClick())합니다.

package ch09;

public class Button {
	OnClickListener listener; //인터페이스 타입필드

	void setOnClicklistener(OnClickListener listener) {   // 매개변수의 다형성
	this.listener = listener;            
	}
	void touch() {
		listener.onClick();                            //구현 객체의 onClick()메소드 호출
	}

	static interface OnClickListener {
		void onClick();                   // 중첩 인터페이스
	}
}

 

Button의 중첩 인터페이스인 OnClickListener를 구현한 2개의 클래스를 보여줍니다.

구현 클래스

package ch09;

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

구현 클래스

package ch09;

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

 

다음은  버튼을 클릭했을 때 두 가지 방법으로 이벤트를 처리하는 방법입니다. 어떤 구현 객체를 생성해서 Button 객체의 setOnClickListener()메소드를 세팅하느냐에 따라 Button의 touch()메소드의 실행 결과가 달라집니다.

 

버튼 이벤트 처리

package ch09;

public class ButtonExample {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Button btn = new Button();
		
		btn.setOnClicklistener(new CallListener());
		btn.touch();
		
		
		btn.setOnClicklistener(new MessageListener());
		btn.touch();
	
	}
}