class InnerEx1 {
  class InstanceInnter {
    int iv = 100;
    //static int cv = 100; => 에러
    final static int CONST = 100; // => 허용
  }
  
  class StaticInner {
    int iv = 200;
    static int cv = 200;
  }
  
  void myMethod() {
    class LocalInner {
      int iv = 300;
      //static int cv = 300; => 에러
      final static int CONST = 300; // => 허용
    }
  }
  
	public static void main(String[] args) {
    System.out.println(InstanceInner.CONST); //100
    System.out.println(StaticInner.cv); // 200
  }
}

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

class InnerEx3 {
  private int outerIv = 0;
  static int outerCv = 0;
  
  class InstanceInner {
    int iiv = outerIv; // 외부 클래스의 private 멤버에도 접근 가능
    int iiv2 = outerCv;
  }
  
  static class StaticInner {
    // 스태틱 클래스는 외부 클래스의 인스턴스 멤버에 접근할 수 없다.
    int siv = outerIv;
    static int scv = outerCv;
  }
  
  void myMethod() {
    int lv = 0;
    final int LV = 0;
    int lv2 = 0;
    lv2 = 1;
    
    class LocalInner {
      int liv = outerIv;
      int liv2 = outerCv;?
      int liv3 = lv;
      int liv4 = LV;
      // 값을 여러번 할당한 경우에는 접근할 수 없다.
      //int liv5 = lv2; => 에러!
    }
  }
}

// 인스턴스 메서드에 정의된 local class : 로컬 클래스가 로컬 변수를 조회용으로만 사용하는 이유?
package com.eomcs.oop.ex11.d;

public class Exam0340 {


  public static void main(final String[] args) {
    final Exam0340 obj = new Exam0340();
    final Runner r = obj.createRunner("홍길동");
    // createRunner()의 리턴 값은
    // 이 메서드에 선언된 로컬 클래스인 A의 객체이다.
    // A 객체는 Runner 규칙에 따라 만들었기 때문에
    // Runner 레퍼런스에 저장할 수 있다.
    // 이 레퍼런스를 사용하여 A 객체의 run() 메서드를 호출해 보자!
    r.run();

    // 로컬 클래스의 객체가 로컬 변수의 값을 조회용으로만 사용하는 이유?
    // => 위의 코드에서 createRunner() 호출이 끝나면 이 메서드가 실행되는 동안
    // 생성되었던 모든 로컬 변수는 스택 메모리에서 제거된다.
    // 즉 createRunner()의 name 파라미터가 제거된다는 것이다.
  }

  Runner createRunner(final String name) {
    // Exam0340 객체 주소를 받는 내장 변수 this 가 있다.
    //
    class A implements Runner {
      // 컴파일러는 바깥 클래스의 객체 주소를 받을 필드는 추가한다.
      // 또한 바깥 클래스의 객체 주소를 받는 생성자를 추가한다.
      /*
       * Exam0340 outer; // 바깥 클래스의 주소를 받을 필드
       *
       * String paramName; // run() 메서드에서 사용할 로컬 변수을 값을 받을 필드
       *
       * public A(Exam0365 obj, String str) { outer = obj; paramName = str;}
       *
       */

      @Override
      public void run() {
        // 바깥 메서드의 로컬 변수는 메서드 호출이 완료되는 순간
        // 스택 메모리에서 제거되기 때문에
        // 로컬 클래스의 객체에서 사용할 수 없는 상황이 발생할 것이다.
        // 그래서 컴파일러는 바깥 메서드의 로컬 변수 값을 저장할
        // 필드를 클래스에 추가한다.
        // 또한 로컬 변수의 값을 받는 생성자를 만든다.
        // 따라서 run() 메서드를 호출하는 시점에는
        // A 로컬 객체에 name 변수의 값이 들어 있기 때문에
        // 그래도 사용할 수 있는 것이다.
        // => 다음 코드의 name은 createRunner() 메서드의 파라미터가 아니다.
        // => A 인스턴스가 생성될 때 값을 따로 복제한 필드를 가리키는 것이다.
        //
        System.out.printf("%s님이 달립니다!", name);

        // 위 문장은 다음과 같이
        // 컴파일러가 로컬 클래스의 필드(예: paramName)를 사용하는 문장으로 바꾼다.
        // 그래서 createRunner() 메서드 호출이 끝나더라도
        // name 값을 사용할 수 있는 것이다.
        //
        // System.out.printf("%s님이 달립니다!", this.paramName);

      }
    }
    return new A();
    // 컴파일러는 로컬 클래스의 객체를 생성할 때
    // 바깥 클래스의 객체 주소와 로컬 객체가 사용하는
    // 메서드의 로컬 변수 값을 전달하기 위해
    // 다음과 같이 컴파일러가 만든 생성자를 호출한다.
    //
    // return new A(this, name);
  }
}


interface Runner {
  void run();
}

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

class InnerEx5 {
  public static void main(String[] args) {
    Outer outer = new Outer();
    Outer.Inner inner = outer.new Inner();
    inner.method();
  }
}
// 결과
// value: 30
// this.value: 20
// Outer.this.value: 10

new 조상클래스이름() { /*멤버선언*/ }
new 구현인터페이스이름() { /*멤버선언*/ }