[39] 230222 Java Ch. 9 중첩 클래스와 중첩 인터페이스: 1. 중첩 클래스와 중첩 인터페이스 소개, 2. 익명 객체 [K-디지털 트레이닝 39일]

230222 Wed 39th class

Ch. 9 중첩 클래스와 중첩 인터페이스
Ch. 10 예외 처리 (주제별로 묶기 위해 윗글로 글 내용 옮김.) 
진도: p. 406 ~ (교재: 혼자 공부하는 자바, 저자: 신용권)
한빛미디어_혼공자_용어집.pdf
용어 참고

혼자 공부하는 자바 | 신용권 - 교보문고

오늘 배운 것 중 기억할 것을 정리했다. 

---

지난 수업 때 배운 것 중 다시 기억할 것

class A{}
class B extends A{}

main(){
          // 상속관계의 자동 타입 변환
          // 부모클래스 타입(A) <- 자식클래스(B)
          A a = new B();

          // 상속관계의 강제 타입 변환
          // 자식클래스 타입(B) <- 부모클래스(A)
         B() = (B) a;
}
======================================
interface A{} // 인터페이스

class B implements A{} // 구현객체

main(){
          // 인터페이스와 구현 객체 관계의 자동 타입 변환
          // 인터페이스 타입(A) <- 자식 클래스 (B)
          A a = new B();

         // 인터페이스와 구현 객체 관계의 강제 타입 변환
         // 구현객체 타입(B) <- 인터페이스(A)
          B b = (B) a;
}

(개념적으로는 차이가 있지만 문법적 차이는 X)

참고: http://alecture.blogspot.com/2011/05/abstract-class-interface.html

---

2023.01.30 - [1. Revision 2023/Java] - [21] 230127 Ch. 1 자바 시작하기: 1. 프로그래밍 언어와 자바, 2. 이클립스 개발 환경 구축, 3. 자바 프로그램 개발 과정

소스 파일: 프로그래밍 언어로 작성된 파일
소스(source): 고급 언어로 작성된 내용

컴파일: 소스 파일을 기계어로 번역하는 것이다. (이 역할 담당하는 소프트웨어 = 컴파일러)
컴퓨터가 이해할 수 있도록 0과 1로 이루어진 기계어로 변환하는 과정 

---

2023.02.13 - [1. Revision 2023/Java] - [32] 230213 Ch. 6 자바 클래스(3): 5. 인스턴스 멤버와 정적 멤버

인스턴스(instance) 멤버: 객체(인스턴스)를 생성한 후 사용할 수 있는 필드와 메서드를 말하는데, 이들은 각각 인스턴스 필드, 인스턴스 메서드라고 부른다.

인스턴스 필드와 메서드는 객체에 소속된 멤버이기 때문에 객체 없이는 사용할 수 없다.

---

정적 멤버: 클래스에 고정된 멤버로서 객체를 생성하지 않고 사용할 수 있는 필드와 메서드를 말한다. 
각각 정적 필드, 정적 메서드라고 부른다.
정적멤버는 객체가 아닌 클래스에 소속된 멤버이기 때문에 클래스 멤버라고도 한다. 

정적 멤버 선언: 정적 필드와 정적 메서드를 선언하려면 필드와 메서드 선언 시 static 키워드를 추가적으로 붙이면 된다.

---

클래스 class [1장 37쪽] 객체를 생성하기 위한 필드와 메서드가 정의된 것. 객체의 설계도에 해당한다

필드 field [6장 212쪽] 객체의 데이터(멤버 변수)가 저장되는 곳. 생성자와 메서드 전체에서 사용되며 객체가 소멸되지 않는 한 객체와 함께 존재한다.

생성자 constructor [6장 221쪽] new 연산자로 호출되는 특별한 중괄호 블록. 객체 생성 시 객체를 초기화하는 역할을 한다. 메서드와 비슷하게 생겼지만, 클래스 이름으로 되어 있고 반환형이 없다.
객체 초기화란 필드를 초기화하거나, 메서드를 호출해서 객체를 사용할 준비를 하는 것을 말한다.

메서드 method [1장 37쪽] 어떤 일을 처리하는 실행문들을 모아 놓은 블록
• 메서드 호출: 메소드를 코드 내에서 사용하는 것

---

2023.02.17 - [1. Revision 2023/Java] - [36] 230217 Ch. 7 자바 상속(3): 3. 추상 클래스

추상 클래스: 실체 클래스가 공통적으로 가져야 할 필드, 메서드를 정의해놓은 추상적인 클래스.
실체 클래스의 멤버(필드, 메서드)를 통일하는 목적이 있다.
모든 실체들이 가지고 있는 메서드의 실행 내용이 동일하다면 추상 클래스에 메서드를 작성하는 것이 좋다.

추상 메서드는 abstract 키워드와 함께 메서드의 선언부만 있고 메서드 실행 내용인 중괄호 {}가 없는 메서드를 말한다.

[public | protected ] abstract 리턴타입 메서드이름(매개변수, ...);

추상 메서드 오버라이딩 overriding [7장 317쪽] 부모에게서 상속받은 메소드의 내용이 자식 클래스에 맞지 않을 경우, 자식 클래스 에서 동일한 메소드를 재정의하는 것을 말한다. 참고 용어 오버라이딩 [7장 362쪽] 하위 클래스가 반드시 오버라이딩하도록 하고 싶은 경우 사용하는 메서드. 메서드의 선언부만 있고 메서드 실행 내용인 중괄호가 없다. 추상 메서드는 추상 클래스 안에서만 선언 가능함

오버라이딩 overriding [7장 317쪽] 부모에게서 상속받은 메서드의 내용이 자식 클래스에 맞지 않을 경우, 자식 클래스에서 동일한 메서드를 재정의하는 것을 말한다.

---

Ch. 9 중첩 클래스와 중첩 인터페이스

책의 목차
09-1 중첩 클래스와 중첩 인터페이스 소개
09-2 익명 객체

9.1 중첩 클래스와 중첩 인터페이스 소개 

클래스가 여러 클래스와 관계를 맺는 경우에는 독립적으로 선언하는 것이 좋으나,
특정 클래스와 관계를 맺을 경우에는 클래스 내부에 선언하는 것이 좋다. 

중첩 클래스(nested class)란 클래스 내부에 선언한 클래스이다.

class A{
          //인스턴스 멤버
          int a; //인스턴스 필드(접근 제한자: default)
          void add1(){}          //인스턴스 메서드(접근 제한자: default)

          //정적 멤버 
          public static int c; //정적 필드(접근 제한자: public)
          static void add2(){} //정적 메서드(접근 제한자: default)

}

합쳐서
인스턴스 필드 + 인스턴스 메서드 = 인스턴스 멤버(인스턴스 그룹) 
정적 필드 + 정적 메서드 = 정적 멤버 

인스턴스, 정적 대신에 클래스 대입 가능하다. ex) 인스턴스 클래스 필드 

---

9.1 중첩 클래스 (nested class)

• 멤버 클래스: 클래스의 멤버로서 선언되는 중첩 클래스이다. 멤버 클래스는 바깥 객체의 필요 여부에 따라 인스턴스 멤버 클래스와 정적(static) 멤버 클래스로 구분된다.

• 로컬 클래스: 메소드 내부에서 선언되는 중첩 클래스

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

---

1) 인스턴스 멤버 클래스

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

class A{
          class B{//인스턴스 클래스 (인스턴스 멤버 클래스)
          //인스턴스 멤버 
          int a;               //인스턴스 필드(접근 제한자: default)
          void add1(){}  //인스턴스 메서드(접근 제한자: default)
          }
} //A 클래스 끝

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

---

2) 정적 멤버 클래스

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

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

{
          static class B{//정적 클래스(정적 멤버 클래스)
          //인스턴스 멤버
          int a;           
}

 

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

A.C c = new A.C();
c.field1 = 3; //인스턴스 필드 사용
c.method1(); //인스턴스 메서드 사용

A.C.field2 = 3; //정적 필드 사용
A.C.method2(); //정적 메서드 사용

---

3) 로컬(local) 클래스

로컬 클래스: 생성자 또는 메서드 블록 내부에 선언된 중첩 클래스이다.

중첩 클래스는 메서드 내에서도 선언할 수 있는데, 이것을 로컬(local) 클래스라고 한다.

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

class A{
          static class B{//정적 클래스 (정적 멤버 클래스)
          //인스턴스 멤버 
          int a;               //인스턴스 필드(접근 제한자: default)
          void add1(){}  //인스턴스 메서드(접근 제한자: default)

          int a = 10; //지역 변수(로컬 변수)
          class D{ //로컬 클래스
                    //필드
                    //생성자
                    //메서드
                    }
          }          //정적 메서드(접근 제한자: default)
     }
} //A 클래스 끝

 

예제 1) 중첩 클래스 

package ch9;

//**바깥 클래스**
public class A { //외부 클래스
	//생성자
	A(){System.out.println("A 객체가 생성됨");} // 외부 클래스의 기본 생성자(매개 변수가 없는 생성자)
	
	//필드
	//**인스턴스 멤버 클래스**
	class B{// 내부 클래스(인스턴스 멤버 클래스)
		//생성자
		B(){System.out.println("B 객체가 생성됨");} //내부 클래스의 기본 생성자(매개 변수가 없는 생성자)
		//필드
		int field1;
		//메서드
		void method1(){}
	}
	//**정적 멤버 클래스**
	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;
			void method1() {}
		}
		D d = new D();
		d.field1 = 3;
		d.method1();
		}
	}

예제 2) 중첩 클래스 객체 생성

package ch9;

public class Main {

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

결과)

A 객체가 생성됨
B 객체가 생성됨
C 객체가 생성됨
D 객체가 생성됨

---

9.2 중첩 클래스의 접근 제한 p. 411

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

---

1) 바깥 필드와 메서드에서 사용 제한 (9.2 중첩 클래스의 접근 제한)

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

인스턴스 멤버 클래스(B)는 정적 필드(field3)의 초기값이나 정적 메서드(method2())에서는 객체를 생성할 수 없다. 
반면 정적 멤버 클래스(C)는 모든 필드의 초기값이나 모든 메서드에서 객체를 생성할 수 있다. 

public class A { //바깥 클래스
	//필드
	//인스턴스 필드
	B field1 = new B();
	C field2 = new C();
	
	//정적 필드 초기화
	//static B field3 = new B(); //(X)
	static C field4 = new C();
	
	//메서드
	//인스턴스 메서드
	void method1() {
		B var1 = new B();
		C var2 = new C();
	}
	
	//정적 메서드
	static void method2() {
		//B var1 = new B();(X)
		C var2 = new C();
	}
	
	//인스턴스 멤버 클래스
	class B{}
	
	//정적 멤버 클래스
	static class C{}
}

---

2) 멤버 클래스에서 사용 제한 (9.2 중첩 클래스의 접근 제한)

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

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

정적 멤버 클래스(C) 안에서는 바깥 클래스의 정적 필드(field2)와 메서드(method2())에만 접근할 수 있다.
인스턴스 필드(field1)와 메서드(method1())에는 접근할 수 없다. 

예시)

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();
		}
	}//바깥 클래스 끝
}

---

3) 로컬 클래스에서 사용 제한 p. 414 (9.2 중첩 클래스의 접근 제한)

메서드의 매개 변수나 로컬 변수를 로컬 클래스에서 사용할 때 제한이 있다.
로컬 클래스의 객체는 메서드 실행이 종료되면 없어지는 것이 일반적이지만, 메서드가 종료되어도 계속 실행 상태로 존재할 수 있다. 
ex) 로컬 스레드 객체를 사용할 때 메서드를 실행하는 스레드와 다르므로 메서드가 종료된 후에도 로컬 스레드 객체는 실행 상태로 존재할 수 있다. (Ch. 12 '스레드'에서 다룬다.) 

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

자바 7 이전과 달리 자바 8부터는 final 키워드 없이 선언된 매개 변수와 로컬 변수를 사용해도 컴파일 에러가 발생하지 않는다. final 선언을 하지 않아도 값이 수정될 수 없도록 final의 특성을 부여한다. 

예제) 로컬 클래스에서 사용 제한

public class Outter {
	//자바 7 이전
	public static 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 static method2(int arg) { //바깥 클래스 인스턴스 메서드
		int localVariable = 1; // 변경할 수 없는 변수(로컬 변수)
		//arg = 100; (X)
		//localVariable = 100; (X)
		
		class Inner{ //내부 클래스
			public void method(){
				int result = arg + localVariable;
			}
		}
	}
}

---

4) 중첩 클래스에서 바깥 클래스 참조 얻기 p. 416 (9.2 중첩 클래스의 접근 제한)

예제 1) 중첩 클래스에서 바깥 클래스 참조 얻기

public class Outter {//바깥 클래스
	//필드 
	String field = "Outter-field";
	//생성자
	//Outter(){}
	//메서드
	void method() {
		System.out.println("Outter-field");
	}
	
	class Nested{//내부 클래스(인스턴스 멤버 클래스)
		//필드
		//this.field는 가장 가까이 있는 field를 가르킨다. 
		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을 붙여서 바깥쪽 field에 접근 
			Outter.this.method();
		}	
	}
}

예제 2) 실행 클래스

public class OutterExample {
	public static void main(String[] args) {
		//바깥 클래스 객체 생성
		Outter outter = new Outter();
		//내부 클래스 객체 생성
		//바깥클래스.내부클래스 참조변수명 = 바깥 클래스 참조변수.new 참조변수명
		Outter.Nested nested = outter.new Nested();
		nested.print();
	}
}

---

9.3 중첩 인터페이스 p. 417

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

중첩 인터페이스는 인스턴스 멤버 인터페이스와 정적(static) 멤버 인터페이스 모두 가능하다. 주로 정적 멤버 인터페이스를 많이 사용하는데 UI 프로그래밍에서 이벤트를 처리할 목적으로 많이 활용된다.

예제 1) 중첩 인터페이스

package ch9_2_4;
//[1]
public class Button {//바깥 클래스
	//타입
	//타입			필드명
	OnClickListener listener; //인터페이스 타입 필드
	
	//매개 변수의 다형성
	void setOnClickListener(OnClickListener listener) {
		this.listener = listener;
	}
	
	//메서드
	//구현 객체의 onClick() 메서드 호출
	void touch() {
		listener.onClick();
	}
	
	//중첩 인터페이스
	static interface OnClickListener{//내부 인터페이스(정적)
		//public static (생략됨)
		void onClick();//"추상메서드 선언"만 선언 가능
	}
}

예제 2) 구현 클래스

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

예제 3) 구현 클래스

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

예제 4) 버튼 이벤트 처리

package ch9_2_4;
//[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();
	}
}

결과)

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

---

Q3) Car 클래스 내부에 Tire와 Engine이 멤버 클래스로 선언되어 있다.
바깥 클래스(NestedClassExample)에서 멤버 클래스의 객체를 생성하는 코드를 작성하라. 
예제 1)

public class Car {//외부 클래스
	class Tire{} //내부 클래스(인스턴스 멤버 클래스)
	static class Engine{} //내부 클래스(정적 멤버 클래스)
}

예제 2)

public class NestedClassExample {
	public static void main(String[] args) {
		Car myCar = new Car();
		
		Car.Tire tire = myCar.new Tire();
				
		Car.Engine engine = new Car.Engine();
	}
}

 

---

마무리
4가지 키워드로 끝내는 핵심 포인트 p. 420

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

2) 멤버 클래스: 클래스의 멤버로서 선언되는 중첩 클래스이다. 멤버 클래스는 바깥 객체의 필요 여부에 따라 인스턴스 멤버 클래스와 정적(static) 멤버 클래스로 구분된다.

3) 로컬 클래스: 생성자 또는 메서드 블록 내부에 선언된 중첩 클래스이다.

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

---

확인 문제
Q1) 
1. 인스턴스 멤버 클래스는 바깥 클래스의 객체가 있어야 사용할 수 있다. (O)
2. 정적 멤버 클래스는 바깥 클래스의 객체가 없어도 사용될 수 있다. (O)

class A{
		int a; //인스턴스 필드
        static int b; //정적 필드
}

class ATest{
public static void main(String[] args){
	//인스턴스 멤버 클래스
    //바깥 클래스 객체 생성
	A a = new A();
    //바깥 클래스를 참조하여 인스턴스 멤버 클래스 객체 생성
    A.B b = a.new B();
    
    //정적 멤버 클래스 객체 생성
    A.B b = new A.B();
	}
}

3. 인스턴스 멤버 클래스 내부에는 바깥 클래스의 필드와 메서드를 사용할 수 있다. (O) (class B)
4. 정적 멤버 클래스 내부에는 바깥 클래스의 인스턴스 필드를 사용할 수 있다. (X) (static class C)

Q2) 
1. 로컬 클래스는 생성자 또는 메서드 내부에 선언된 클래스를 말한다. (O)
2. 로컬 클래스도 필드와 생성자를 가질 수 있다. (O)
3. 로컬 클래스는 static 키워드를 이용해서 정적 클래스로 만들 수 있다. (X) 안 된다. 
4. final 특성을 가진 매개 변수나 로컬 변수만 로컬 클래스 내부에서 사용할 수 있다. (O) p. 414 참고 

class A{	//외부 클래스
		int x; //인스턴스 필드
        static int y; //정적 필드
        
        class B{ //내부 클래스(인스턴스 멤버 클래스)
        }
        
        static class C{ //내부 클래스(정적 멤버 클래스)
		}
        
        void add(){		//리턴이 없는 메서드
				int z; //add 메서드 안에 선언했으므로 z변수는 지역변수(로컬변수)
                class E{ //add 메서드 안에 선언했으므로 E클래스는 지역클래스(로컬클래스)
                		//필드
                        //생성자
                        //메서드
                }
}

class D{
	public static void main(String[] args){
			//A클래스를 인스턴스화해서 객체 생성
            A a = new A();
            //인스턴스 필드 x에 접근할 때는 참조변수 a를 통해서 접근한다.
            a.x = 10;
			//인스턴스 멤버 클래스 B에 접근할 때는 바깥 클래스 A를 통해서 접근한다.
            A.B b = a.new B();
			//정적 멤버 클래스 C에 접근할 때는 바깥클래스 A없이 접근한다.
            A.C c = new A.C();
	}
}

Q4) p. 415 참고
nickName은 final 특성을 갖기 때문에 String nickName = chatID;를 넣는다.

public class Chatting {//외부 클래스 
	
	void startChat(String chatID) {//외부클래스의 메서드
//		String nickName = null;
//		nickName = chatId;
		
		class Chat{//로컬 클래스
			public void start() {
				while(true) {
					String nickName = chatID;
					String inputData = "안녕하세요";
					String message = "[" + nickName + "]" + inputData;
					sendMessage(message);
				}
			}
			
			void sendMessage(String message) {
			}
		}//Chat 끝남 
		
		Chat chat = new Chat();
		chat.start();
	}//starChat 끝남 
}//Chatting 끝남

Q5) 
예제 1)

public class CheckBox {
	OnSelectListener listener;
	
	void setOnSelectListener(OnSelectListener listener) {
		this.listener = listener;
	}
	
	void select() {
		listener.onSelect();
	}
	
	static interface OnSelectListener{
		//public static void onSelect();
		void onSelect();//추상 메서드
	}
}

예제 2)

public class CheckBoxExample {
	public static void main(String[] args) {
		CheckBox checkBox = new CheckBox();
		checkBox.setOnSelectListener(new BackgroundChangeListener());
		checkBox.select();
	}
}

예제 3)

public class BackgroundChangeListener implements CheckBox.OnSelectListener{
	public void onSelect() {
		System.out.println("배경을 변경합니다.");
	}
}

 

---

Ch 9.2 익명 객체

2가지 키워드로 끝내는 핵심 포인트 p. 437

1) 익명 자식 객체: 자식 클래스가 재사용되지 않고 오로지 특정 위치에서 사용할 경우라면 자식 클래스를 명시적으로 선언하는 것은 귀찮은 작업이 된다. 이 경우에는 익명 자식 객체를 사용하는 것이 좋다.
익명 자식 객체를 생성하는 방법

부모클래스 [필드|변수] = new 부모클래스(매개값, ...){
	//필드
    //메서드
};

2) 익명 구현 객체: 구현 클래스가 재사용되지 않고 오로지 특정 위치에서 사용할 경우라면 구현 클래스를 명시적으로 선언하는 것은 귀찮은 작업이다. 이 경우 익명 구현 객체를 생성해서 사용하는 것이 좋다. 
익명 구현 객체를 생성하는 방법

인터페이스 [필드|변수] = new 인터페이스(){
	//인터페이스에 선언된 추상 메서드의 실체 메서드 선언
    //필드
    //메서드
};

---