====== Ch.10 내부클래스 ======

===== 내부클래스 =====

**내부(중첩)클래스의 구조**

  class 클래스명 {
       class 내부 클래스명 {
       ...
       }
   }

**멤버 클래스의 파일명**

  바깥클래스명$내부클래스명.class
  
**로컬 클래스 파일명**

  바깥클래스명$1내부클래스명.class

:wr:<color #ff7f27>**멤버클래스**</color>  

  public class Outer {
       // Outer 클래스의 내용
       ...
       public static class Inner {
       // Inner 클래스의 내용
       }
   }


다른 곳에서 Inner클래스 객체를 생성하기 위해 Inner클래스에 접근할 시

  Outer.inner inn = new Outer.Inner();
  
:wr: <color #ff7f27>**인스턴스 내부 클래스**</color>

  public class Outer {
       // Outer 클래스의 내용
       ...
       public class Inner {
       // Inner 클래스의 내용
       }
   }

다른 곳에서 안쪽 클래스의 객체를 생성할 시 - 바깥 클래스의 객체를 먼저 생성하고, 그 객체변수를 이용해서 내부 클래스의 객체를 생성한다.

  Outer outer = new Outer();
  Outer.Inner inn = outer.new Inner();

<color #ff7f27>**로컬 클래스**</color>

<code java>
package chapter10;

public class LocalInnerEx { // 바깥클래스
	int i=10;

	void outerMethod(){
		class Inner { // 로컬 클래스
			int x=20; // 메서드 지연변수
			int i=30; // 메서드 지역변수
			void innerMethod() {
				System.out.println(x);
				System.out.println(i); // 안쪽 클래스의 i변수
				System.out.println(this.i); // 안쪽 클래스의 i변수
				System.out.println(LocalInnerEx.this.i); // 바깥 클래스의 i변수
			}
		}
		
		Inner inn = new Inner();
		inn.innerMethod();
	}
	
	public static void main(String[] args) {
		LocalInnerEx lic = new LocalInnerEx();
		lic.outerMethod();
	}
	
}

</code>

**A.java**

<code java>
package chapter10;

class A { // 바깥 클래스
	A() { // 바깥 클래스의 생성자
		System.out.println("A 객체 생성");
	}
	
	static class B { // static 내부 클래스
		B() { // static 내부 클래스의 생성자
			System.out.println("C 객체 생성");
		}

		int var1;
		static int var2;

		void method1() {
			System.out.println("static 내부 클래스의 method1()");
		}

		static void method2() {
			System.out.println("static 내부 클래스의 static method2()");
		}
	}

	public class C { // 인스턴스 내부 클래스
		C() { // 인스턴스 내부 클래스의 생성자
			System.out.println("B 객체 생성");
		}

		int var1;

		void method1() {
			System.out.println("인스턴스 내부 클래스의 method1()");
		}
	}


	void method() { // 바깥 클래스의 메서드
		
		class D { // 로컬 내부 클래스
			D() {
				System.out.println("D 객체 생성");
			}

			int var1;

			void method1() {
				System.out.println("로컬 내부 클래스의 method1()");
			}
		}
		D d = new D();
		d.var1 = 3;
		d.method1();
	}
}
</code>

**Amain.java**

<code java>
package chapter10;

public class Amain {

	public static void main(String[] args) {
		A a = new A();
		
		//static 멤버 클래스 객체 생성
		A.B b = new A.B();
		b.var1 = 3;
		b.method1();
		A.B.var2 = 3;
		A.B.method2();
		
		//인스턴스 내부 클래스 객체 생성
		A.C c = a.new C();
		c.var1 = 3;
		c.method1();
		
		//로컬 클래스 객체 생성을 위한 메소드 호출
		a.method();
	}
}
</code>

===== 내부 인터페이스 =====

**내부 인터페이스 구조**
  
  class 클래스명 {
       interface 인터페이스명 {
           void method(); // 추상 메서드
       }
    }

<code java>
package chapter10.interfacePkg;

public class Outer {

	interface InterfaceEx {
		void method();
	}
	
	InterfaceEx ie;
	
	void setInterfaceEx(InterfaceEx ie) {
		this.ie = ie;
	}
	
	void outerMethod() {
		ie.method();
	}
	
}
</code>   

<code java>
package chapter10.interfacePkg;

public class InterfaceExImple implements Outer.InterfaceEx{

	@Override
	public void method() {
		
		System.out.println("InterfaceExImple method()");
		
	}

}

</code>   

<code java>
package chapter10.interfacePkg;

public class InterfaceExImple2 implements Outer.InterfaceEx{

	@Override
	public void method() {
		
		System.out.println("InterfaceExImple2 method()");
		
	}

}

</code>   
  
<code java>
package chapter10.interfacePkg;

public class OuterMain {

	public static void main(String[] args) {
		
		Outer out = new Outer();
		
		out.setInterfaceEx(new InterfaceExImple());
		out.outerMethod();
		out.setInterfaceEx(new InterfaceExImple2());
		out.outerMethod();

	}

}

</code>