[Java] 내부클래스

class A {		// 외부 클래스 (outer class)
  class B {		// 내부 클래스 (inner class)
    
  }
}

class Outer {
  class InstanceInner {}		// 인스턴스 클래스
  static class StaticInner {}	// 스태틱 클래스
  
  void myMethod() {
    class LocalInner {}			// 지역 클래스
  }
}

class Outer {
  class InstanceInner {
    int iv = 100;
    //static int cv = 100; 			// static변수를 선언할 수 없다.
    final static int CONST = 100;	// final static은 상수이므로 허용한다.
  }
  
  static class StaticInner {
    int iv = 200;
    static int cv = 200;			// static클래스만 static멤버를 정의할 수 있다.
  }
  
  void myMethod() {
    class LocalInner {
      int iv = 300;
      //static int cv = 300;		// static변수를 선언할 수 없다.
      final static int CONST = 300;	// final static은 상수이므로 허용한다.
    }
  }
}

class Outer {
  class InstanceInner {}
  static class Static Inner {}
  
  static void staticMethod() {
  	// static메서드는 인스턴스멤버에 직접 접근할 수 없다.
    //InstanceInner ii = new InstanceInner();
    StaticInner si = new StaticInner();
    
    // 굳이 접근하려면 객체를 생성해야한다.
    // 인스턴스클래스는 외부 클래스를 먼저 생성해야만 생성할 수 있다.
    Outer outer = new Outer();
    InstanceInner ii = outer.new InstanceInner();
  }
  
  void instanceMethod() {
  	// 인스턴스메서드에서는 인스턴스멤버와 static멤버 모두 접근 가능하다.
    InstanceInner ii = new InstanceInner();
    StaticInner si = new StaticInner();
    
    // 메서드 내에 지역적으로 선언된 내부 클래스는 외부에서 접근할 수 없다.
    //LocalInner li = new LocalInner();
  }
  
  void myMethod() {
    class LocalInner{}
    
    LocalInner li = new LocalInner();
  }
}

class Outer {
  private int outerIv = 0;
  static int outerCv = 0;
  
  class InstanceInner {
    int iiv = outerIv;
    int iiv = outerCv;
  }
  
  static class StaticInner {
    //int siv = outerIv;
    static int scv = outerCv;
  }
  
  void myMethod() {
    int lv = 0;
    final int LV = 0;	// JDK1.8부터 final 생략가능
    
    class LocalInner {
      int liv = outerIv;
      int liv2 = outerCv;
      
      //int liv3 = lv;
      int liv4 = LV;
    }
  }
}

class Outer {
  class InstanceInner {
    int iv = 100;
  }
  static class StaticInner {
    int iv = 200;
    static int cv = 300;
  }
  
  void myMethod() {
    class LocalInner {
      int iv = 400;
    }
  }
}

class Other {
  // 인스턴스 클래스의 인스턴스를 생성하려면
  // 외부 클래스의 인스턴스를 먼저 생성해야 한다.
  Outer oc = new Outer();
  Outer.InstanceInner ii = oc.new InstanceInner();
  
  // 스태틱 클래스는 외부 클래스를 먼저 생성하지 않아도 된다.
  Outer.StaticInner si = new Outer.StaticInner();
  
  System.out.println("ii.iv : " + ii.iv);
  System.out.println("Outer.StaticInner.cv : " + Outer.StaticInner.cv);
  System.out.println("si.iv" + si.iv);
}

// 컴파일 시 생성되는 파일명
// Other.class
// Outer.class
// Outer$InstanceInner.class
// Outer$StaticInner.class
// Outer$LocalInner.class

class Outer {
  int value = 10;	// Outer.this.value
  
  class Inner {
    int value = 20;	// this.value
    
    void myMethod() {
      int value = 30;
      System.out.println("value : " + value);						// 30
      System.out.println("this.value : " + this.value);				// 20
      System.out.println("Outer.this.value : " + Outer.this.value);	// 10
    }
  }
}

new 조상클래스이름() {}
또는
new 구현인터페이스이름() {}

class Outer {
  Object iv = new Object() { void method(){} };			// 익명 클래스
  static Object cv = new Object() { void method(){} };	// 익명 클래스
  
  void myMethod() {
    Object lv = new Object() { void method(){} };		// 익명 클래스
  }
}