9-1. 자바 중첩 클래스와 중첩 인터페이스 : 로컬 클래스

중첩 클래스

중첩 클래스를 사용하면 코드의 복잡성을 줄일 수 있다!

중첩 클래스는 클래스 내부에 선언되는 위치에 따라서 두 가지로 분류된다. 클래스의 멤버로서 선언되는 중첩 클래스를 멤버 클래스라고 하고, 메소드 내부에서 선언되는 중첩 클래스를 로컬 클래스라고 한다. 멤버 클래스는 객체가 사용 중일때는 언제든지 재사용이 가능하지만, 로컬 클래스는 메소드 실행 시에만 사용되고, 메소드가 실행 종료되면 없어진다.

public class A {
	class B {...} // 인스턴스 멤버 클래스
	
	static class C {...} // 정적 멤버 클래스
	
	void method() { class D {...} } // 로컬 클래스
}

멤버 클래스도 하나의 클래스이기 때문에 컴파일하면 바이트 코드 파일(.class)이 별도로 생성된다. 바이트 코드 파일의 이름은 다음과 같이 결정된다.

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

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

A $1 B .class

 

인스턴스 멤버 클래스

인스턴스 멤버 클래스는 static 없이 선언된 클래스로, 정적 필드와 정적 메소드는 선언할 수 없다.

A 클래스 외부에서 인스턴스 멤버 클래스 B의 객체를 생성하려면 먼저 A 객체를 생성하고 B 객체를 생성해야 한다.

A a = new A();
A.B b = a.new B();
b.field1 = 3;
b.method1();

 

정적 멤버 클래스

정적 멤버 클래스는 static 키워드로 선언되어 모든 종류의 필드와 메소드를 선언할 수 있다!

A.C c = new A.C();
C.field1 = 3;
c.method1();
A.C.field2 = 3;
A.C.method2();

 

로컬 클래스

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

void method()
{
    class D 
    {
        D() {}
        int field;
        void method1();
    }
}

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

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

 

중첩 클래스의 접근 제한

멤버 클래스가 인스턴스 또는 정적으로 선언됨에 따라 바깥 클래스의 필드와 메소드에 사용 제한이 생긴다. 인스턴스 멤버 클래스는 바깥 클래스의 인스턴스 필드의 초기값이나 인스턴스 메소드에서 객체를 생성할 수 있으나, 정적 필드의 초기값이나 정적 메소드에서는 객체를 생성할 수 없다. 반면 정적 멤버 클래스는 모든 필드의 초기값이나 모든 메소드에서 객체를 생성할 수 있다.

 

멤버 클래스에서 사용 제한

멤버 클래스가 인스턴스 또는 정적으로 선언됨에 따라 멤버 클래스 내부에서 바깥 클래스의 필드와 메소드를 접근할 때에도 제한이 따른다. 인스턴스 멤버 클래스 안에서는 바깥 클래스의 모든 필드와 모든 메소드에 접근할 수 있지만, 정적 멤버 클래스 안에서는 바깥 클래스의 정적 필드와 메소드에만 접근할 수 있고, 인스턴스 필드와 메소드는 접근할 수 없다.

class A_1
{
	int field1;
	
	void method1() { ... }
	
	static int field2;
	static void method2() { ... }
	
	static class C
	{
		void method()
		{
			field1 = 10; // error
			method1(); // error
			
			field2 = 10;
			method2();
		}
	}
}

 

로컬 클래스에서 사용 제한

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

자바는 이 문제를 해결하기 위해 컴파일 시 로컬 클래스에서 사용하는 매개 변수나 로컬 변수의 기억 장소를 로컬 클래스 내부에 복사해 두고 사용한다. 그리고 매개 변수나 로컬 변수가 수정되어 기억 장소가 변경되면 로컬 클래스에 복사해 둔 기억 장소와 달라지는 문제를 해결하기 위해 매개 변수나 로컬 변수를 final로 선언해서 수정을 막는다. 결론적으로 말해서 로컬 클래스에서 사용 가능한 것은 final로 선언된 매개 변수와 로컬 변수뿐이라는 것이다. 자바 8부터는 final이 아닌 매개 변수와 로컬 변수를 허용하는 것은 아니지만, final 선언을 하지 않아도 여전히 값을 수정할 수 없는 final의 특성을 갖는다. final 키워드 존재 여부의 차이점은 로컬 클래스의 복사 위치이다. final 키워드가 있다면 로컬 클래스의 메소드 내부에 지역 변수로 복사되지만, final 키워드가 없다면 로컬 클래스의 필드로 복사된다.

	static void outMethod(final int arg1, int arg2)
	{
		final int var1 = 1;
		int var2 = 2;
		class LocalClass
		{
			void method()
			{
				int result = arg1 + arg2 + var1 + var2;
			}
		}
	}

위의 코드에서 각 변수는 각각 다음과 같이 저장된다.

	// 실제 :
	class LocalClass
	{
		int arg2 = 매개값; // 필드로 복사
		int var2 = 2; // 필드로 복사
		
		void method()
		{
			int arg1 = 매개값; // 로컬 변수로 복사 (final)
			int var1 = 1; // 로컬 변수로 복사 (final)
			int result = arg1 + arg2 + var1 + var2;
		}
	}

우리는 로컬 클래스의 내부 복사 위치에 신경 쓸 필요 없이 로컬 클래스에서 사용된 매개 변수와 로컬 변수는 모두 final 특성을 갖는다는 것만 알면 된다. 

 

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

클래스 내부에서 this는 객체 자신의 참조이다. 중첩 클래스에서 this 키워드를 사용하면 바깥 클래스의 객체 참조가 아니라, 중첩 클래스의 객체 참조가 된다. 따라서 중첩 클래스 내부에서 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 프로그래밍에서 이벤트를 처리할 목적으로 많이 활용된다.

public class A {

	interface I
	{
		void method();
	}
	
}

예를 들어 Button을 클릭했을 때 이벤트를 처리하는 객체를 받고 싶다고 가정해보자. 그렇다고 아무 객체나 받으면 안 되고, Button 내부에 선언된 중첩 인터페이스를 구현한 객체만 받아야 한다면 다음과 같이 Button 클래스를 선언하면 된다.

public class Button {
	
	OnClickListener listener;
	
	// 매개 변수의 다형성
	void setOnClickListener(OnClickListener listener)
	{
		this.listener = listener;
	}
	
	// 구현 객체의 onClock() 메소드 호출
	void touch()
	{
		listener.onClick();
	}
	
	// Nested interface
	interface OnClickListener
	{
		void onClick();
	}
	
}

public class CallListener implements Button.OnClickListener {

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

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

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

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

---

해당 포스팅은 이것이 자바다 (신용권 저) 를 참고하였습니다