중첩 클래스(Nested class)란 클래스 내부에 선언한 클래스를 말한다.

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

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

클래스 내부에 선언한 인터페이스 또한 중첩 인터페이스(Nested interface)라고 한다.

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

class Classname{ 
	interface NestedInterfaceName{ //중첩 인터페이스
    }
}

중첩 클래스

중첩 클래스는 클래스 내부에 선언되는 위치에 따라 멤버 클래스(클래스의 멤버로서 선언되는 중첩 클래스)와 로컬 클래스(생성자 또는 메소드 내부에서 선언되는 중첩 클래스)로 분류된다.

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

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

멤버 클래스의 경우에는 A $ B . class (A 바깥 클래스 B 멤버 클래스), 로컬 클래스의 경우에는 A $1 B . class (A 바깥 클래스 B 로컬 클래스)로 바이트 코드 파일이 생성된다.

인스턴스 멤버 클래스

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

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

A 클래스 외부에서 B 객체를 생성하려면 먼저 A 객체를 생성하고 B 객체를 생성해야 한다.(일반적으로 A 클래스 외부에서 B 객체를 생성하는 일은 거의 X, 대부분 A 클래스 내부에서 B 객체를 생성해서 사용)

A 클래스 내부의 생성자 및 인스턴스 메소드에서는 일반 클래스처럼 B 객체를 생성할 수 있다.

정적 멤버 클래스

정적 멤버 클래스란 static 키워드로 선언된 클래스를 말한다.

정적 멤버 클래스는 모든 종류(인스턴스, 정적)의 필드와 메소드를 선언할 수 있다.

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

로컬 클래스

로컬 클래스란 메소드 내에서 선언한 중첩 클래스이다.

로컬 클래스는 접근 제한자(public, private) 및 static을 붙일 수 없다. 왜냐하면 로컬 클래스는 메소드 내부에서만 사용되기 때문에 접근을 제한할 필요가 없기 때문이다.

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

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

package sec03.exam02;

class A {
	
    //바깥 클래스
	A(){
		System.out.println("A 객체가 생성됨");
	}
	
    //인스턴스 멤버 클래스
	class B{
		
		B(){
			System.out.println("B 객체가 생성됨");
		}
		
		int field1;
		//static int field2;
		void method1() {}
		//static void method(){}
	}
	
    //정적 멤버 클래스
	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 sec03.exam02;

public class Main {

	public static void main(String[] args) {
		// TODO 자동 생성된 메소드 스텁
		
		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 sec03.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(); (X)
	static C field4 = new C();
	
	//정적 메소드
	static void method2() {
		//B var1 = new B(); (X)
		C var2 = new C();
	}
	
	
	//인스턴스 멤버 클래스
	class B{}
	
	//정적 멤버 클래스
	static class C{}
	
}

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

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

멤버 클래스에서 사용 제한

package sec03.exam02;

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; (X) , 정적 클래스에선 인스턴스 필드와 메소드에 접근X
			//method1(); (X) , 정적 클래스에선 인스턴스 필드와 메소드에 접근X
			
			field2=10;
			method2();
		}
	}

}

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

인스턴스 멤버 클래스(B) 안에서는 바깥 클래스의 모든 필드와 메소드에 접근할 수 있지만, 정적 멤버 클래스(C) 안에서는 바깥 클래스의 정적 필드(field2)와 메소드(method2())에만 접근할 수 있고 인스턴스 멤버에는 접근할 수 없다.

로컬 클래스에서 사용 제한

package sec03.exam02;

public class Outter {
	public void method2(int arg) {
		int localVariable = 1;
		//arg =100; (X)
		//localVariable = 100; (X)
		//자바 8 이후로 final 키워드를 붙이지 않아도 매개변수와 로컬변수에 final 특성을 가지고 있음
		class Inner{
			public void method() {
				int result = arg + localVariable;
			}
		}
	}
}

메소드의 매개 변수나 로컬 변수를 로컬 클래스에서 사용할 때는 제한이 있는데, 자바는 컴파일 시 로컬 클래스에서 사용하는 매개 변수나 로컬 변수의 값을 로컬 클래스 내부에 복사해두고 사용한다.

매개/로컬 변수의 값이 변경되면 로컬 클래스에 복사해둔 값과 달라지므로 매개/로컬 변수에 final의 특성을 부여한다.(final 키워드를 붙이지 않아도 됨)

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

클래스 내부에서 this는 객체 자신의 참조이다. 중첩 클래스에서 this 키워드를 사용하면 바깥 클래스의 객체 참조가 아닌 중첩 클래스의 객체 참조가 된다.

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

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

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

package sec03.exam02;

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 sec03.exam02;

public class OutterExample {

	public static void main(String[] args) {
		// TODO 자동 생성된 메소드 스텁
		
		Outter outter = new Outter();
		Outter.Nested nested = outter.new Nested();
		nested.print();
	}
}

Nested-field
Nested-method
Outter-field
Outter-method

중첩 인터페이스

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

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

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

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

package sec03.exam02;

public class Button {

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

package sec03.exam02;

public class CallListener implements Button.OnClickListener{

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

package sec03.exam02;

public class MessageListener implements Button.OnClickListener{

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

package sec03.exam02;

public class ButtonExample {

	public static void main(String[] args) {
		// TODO 자동 생성된 메소드 스텁
		Button btn = new Button();
		
		btn.setOnClickListener(new CallListener());
		btn.touch();
		
		btn.setOnClickListener(new MessageListener());
		btn.touch();

	}

}

전화를 겁니다.
메시지를 보냅니다.

위 내용은 버튼을 클릭했을 때 두 가지 방법으로 이벤트를 처리하는 방법이다.

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

.
.
.

< 이번 파트 문제를 풀면서 고칠 점 or 아쉬웠던 점 >

인터페이스의 모든 메소드는 무조껀 public 키워드를 붙여주자.
중첩 인터페이스를 구현할 때는 인터페이스 이름 앞에 바깥클래스. 를 붙여주자.

Author And Source

이 문제에 관하여([Java] 9-1 중첩 클래스/인터페이스 소개), 우리는 이곳에서 더 많은 자료를 발견하고 링크를 클릭하여 보았다 https://velog.io/@woo_hyun_1/Java-9-1-중첩-클래스인터페이스-소개

우수한 개발자 콘텐츠 발견에 전념 (Collection and Share based on the CC Protocol.)

[Java] 9-1 중첩 클래스/인터페이스 소개