[ 🤞 중첩 클래스(inner), 중첩 인터페이스 ]

중첩 클래스(inner), 중첩 인터페이스, 익명 내부 클래스, 람다

=> 기본

=> 컴포지션 <===> 중첩 클래스

😁 컴포지션이란?

class A{

 static class C { }

 static void method() {

  C c = new C();

 }

}

상속은 확장 개념이지만 안정성이 떨어진다. 컴포지션 (내부클래스) 를 사용하는 이유는 어떤 특정한 클래스와 특정한 관계를 맺기 위해서 사용한다.

클래스들 간에 관계를 맺을 경우에는 요즘에는 클래스 내부에 선언하는 것이 좋다.

중첩 클래스 -> 로컬 클래스(지역클래스), 멤버 클래스
멤버 = 필드 + 메서드

중첩 클래스 => 클래스 내부에 선언한 클래스를 이야기한다.

=> 두 클래스의 멤버들을 서로 쉽게 접근할 수 있고, 외부에서 불필요한 관계 클래스를 감춤으로써 코드의 복잡성을 줄인다.

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

}

// 중첩 인터페이스
class ClassName{
	interface ClassName1{
    
    }
}

파이썬 => 람다

접근 제어 지시자 정리

// 동일 패키지라는 가정하에

public class C1{
	public int x;
    protected int y;
    int z;
    private int u;
    
    protected void m() {  }
}

public class C2{
	C1 o = new C1();
    can access o.x;
    can access o.y;
    can access o.z;
    cannot access o.u;
    
    can access o.m();
}

public class C3 extends C1{
    can access x;
    can access y;
    can access z;
    cannot access u;
    
    can invoke m();
}

// 다른 패키지
public class C4{
	C1 o = new C1();
    can access o.x;
    cannot access o.y;
    cannot access o.z;
    cannot access o.u;
    
    cannot access o.m();
}

public class C5 extends C1{
    can access x;
    can access y;
    cannot access z;
    cannot access u;
    
    can invoke m();
}
// invoke 는 호출하다라는 뜻이다.

중첩 클래스(선언 위치에 따라 분류된다.)

멤버 클래스

인스턴스 맴버 클래스

class A {
	class B {  }
}

A객체를 생성해야만 B클래스를 사용할 수 있다.
정적 맴버 클래스

class A {
	static class B {  }
}

A 클래스로 바로 접근 할 수 B 클래스

로컬 클래스

// 중첩 클래스
class A {
	void method() {
    	class B{  }
    }
}

method가 실행될 때만 사용할 수 있는 B클래스
중첩 클래스를 컴파일 하면 : 멤버 클래스인 경우에는 A $ B.class ($ 표시는 중첩 클래스를 의미)
: 로컬 클래스인 경우에는 A $1 B.class

ClassName cs;
cs = new ClassName();
변수 == 인스턴스

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

class A {
	class B {
    B() { }
    int field;
    static int field2;
    void method() { }
    static void method2() {  }
    }
}

A 클래스 외부에서 B클래스의 객체를 생성하려면 먼저 A클래스의 객체를 생성하고 B객체를 생성
A a = new A();
A.B b = a.new B();
b.field = 5;
b.method();

// 이걸 많이 사용한다!!!
class A {
	class B {  }
  void method() { //A class의 메서드
   B b = new B();
   b.field = 5;
   b.method();
  }
}

정적 멤버 클래스 (static 키워드로 선언된 클래스)

class A {
	static class C {
    	C();
        int field;
        static int field2;
        void method();
        static void method2() {  }
      }
}

A클래스 외부에서 정적 멤버 클래스 C의 객체를 생성할려고 하면
(A클래스 객체를 생성할 필요가 없고, 바로 C 클래스의 객체를 생성하면 된다.)

A.C c = new A.C();
c.field = 5; // 인스턴스 필드
c.method(); // 인스턴스 메서드 호출
c.field2 = 5; // 정적 필드 사용
c.method2(); // 정적 메서드 호출
A.C.field2 = 5;
A.C.method2();

로컬 클래스

메서드 내에서 선언된 클래스를 로컬 클래스라고 한다.
접근 제어 지시자 및 static을 붙여서 사용할 수 없다.
(로컬 클래스는 메서드 내부에서만 사용되므로 접근을 제한할 필요가 없다)

void method(){
	class D {
    D();
    int field;
    static int field1; // 시용 못함
    void method() {  }
    static void method1() {   } // 시용 못함
    }
    
    D d = new D();
    d.field = 5;
    d.method();
}

비동기 처리를 위해서 스레드 객체 만들떄 로컬 클래스를 사용한다.

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 = 5;
		d.method1();
	}
}
	
	public class Main {
		public static void main(String[] args) {
		A a = new A();
		A.B = a.new B();
		b.field1 = 5;
		b.method1();

		A.C c = new A.C();
		c.field1 = 5;
		c.method1();
		A.C.field1 = 5;			
		A.C.method1();
		a.method();
	}
}
}



// errorCode가 없다
public class A {
	B field1 = new B();
	C field2 = new C();

 void method() {
	B var1 = new B();
	C var2 = new C();
}

 static B field3 = new B();
 static C field4 = new C();

static void method() {
	B var1 = new B();
	C var2 = new C();
}

	class B {    }
	static class C {    }
}

// errorCode가 있다
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() {
	field2 = 10;
	method2();
		}
	}
}	

⭐⭐⭐⭐⭐

// => 두개의 코드 결과는 Test Code이다
pubic class Parcel2 {
	class Contents {
	private int i = 10;
	public int value() {
		return i;
		}
	}
	class Destination {
		private String label;
		Destination(String where To) [
		label = where To;
		}	
		String readLabel(){
		return label;	
		}
	}
       public Destion to(String s) {
    	return new Destination(s);
    }
    public Contents contents() {
    	return new Contents();
    }
	public void ship(String dest){
		Contents c = new Contents();
        Destination ds = to(dext);
		Destination d = new Destination(dest);
		System.out.println(d.readLabel());
	}
	public static void main(String[] args) {
		Parcle2 P = new PArcel2();
		p.ship("Test Code");
        Parcel2 q = new Parcel2();
        Parcel2.Contents c = q.contents();
        Parcel2.Destination d = q.to("Testing Code");
        
	}
}

외곽 클래스 멤버 메서드에서 내부 클래스의 객체를 바로 참조 할 수 있는지? 혹은 객체를 생성할 수 있는지요??

✅ 결론 요약
인스턴스 내부 클래스(Non-static inner class):
외부 클래스의 인스턴스 메서드에서는 객체 생성 가능합니다. 다만 new 키워드로 생성할 때 외부 클래스의 참조를 기준으로 생성해야 합니다.

정적 내부 클래스(Static nested class):
외부 클래스의 메서드에서 정적이므로 바로 객체 생성 가능합니다.