자바 튜토리얼은 말한다 :

용어 : 중첩 클래스는 정적 및 비 정적의 두 가지 범주로 나뉩니다. static으로 선언 된 중첩 클래스를 정적 ​​중첩 클래스라고합니다. 정적이 아닌 중첩 클래스를 내부 클래스라고합니다.

일반적으로 “nested”와 “inner”라는 용어는 대부분의 프로그래머가 상호 교환 적으로 사용하지만 내부 및 정적을 모두 포함하는 올바른 “nested class”라는 용어를 사용합니다.

클래스는 무한 으로 중첩 될 수 있습니다 . 예를 들어, 클래스 A는 클래스 D를 포함하는 클래스 C를 포함하는 클래스 B를 포함 할 수 있습니다. 그러나 일반적으로 설계가 좋지 않기 때문에 둘 이상의 클래스 중첩 수준은 거의 없습니다.

중첩 클래스를 생성 할 수있는 세 가지 이유가 있습니다.

• 조직 : 때로는 클래스를 다른 클래스의 네임 스페이스로 정렬하는 것이 가장 합리적입니다. 특히 다른 컨텍스트에서 사용되지 않을 때
• 액세스 : 중첩 클래스는 포함 클래스의 변수 / 필드에 특수하게 액세스 할 수 있습니다 (정확하게 내부 또는 정적 여부에 관계없이 중첩 클래스의 종류에 따라 변수 / 필드가 달라짐).
• 편의성 : 모든 새 유형에 대해 새 파일을 작성해야하는 것은 번거 롭습니다. 특히 유형이 한 컨텍스트에서만 사용되는 경우에는 더욱 그렇습니다.

Java 에는 네 가지 종류의 중첩 클래스가 있습니다. 간단히 말해 다음과 같습니다.

• static class : 다른 클래스의 정적 멤버로 선언
• 내부 클래스 : 다른 클래스의 인스턴스 멤버로 선언
• 로컬 내부 클래스 : 다른 클래스의 인스턴스 메소드 내에서 선언
• 익명의 내부 클래스 : 로컬 내부 클래스와 비슷하지만 일회성 객체를 반환하는 표현식으로 작성

좀 더 자세하게 설명하겠습니다.

정적 클래스

정적 클래스는 포함하는 클래스의 인스턴스와 관련이 없으므로 이해하기 가장 쉬운 종류입니다.

정적 클래스는 다른 클래스의 정적 멤버로 선언 된 클래스입니다. 그냥 다른 정적 멤버처럼, 이러한 클래스는 네임 스페이스로 포함하는 클래스 그 용도에 불과 걸이 정말 예 : 클래스 염소는 클래스의 정적 멤버로 선언 코뿔소 패키지에 피자 이름으로 알려져있다 pizza.Rhino.Goat은 .

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

솔직히 정적 클래스는 클래스가 이미 패키지에 의해 네임 스페이스로 나뉘어져 있기 때문에 가치가없는 기능입니다. 정적 클래스를 만드는 유일한 이유는 그러한 클래스가 포함하는 클래스의 전용 정적 멤버에 액세스 할 수 있기 때문이지만 정적 클래스 기능이 존재하는 데는 이것이 절름발이입니다.

내부 클래스

내부 클래스는 다른 클래스의 비 정적 멤버로 선언 된 클래스입니다.

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

    private void jerry() {
        Goat g = new Goat();
    }
}

정적 클래스와 마찬가지로 내부 클래스는 포함하는 클래스 이름 pizza.Rhino.Goat 로 규정 된 것으로 알려져 있지만 포함 클래스 내부에서는 간단한 이름으로 알 수 있습니다. 그러나, 내부 클래스의 모든 인스턴스가 포함 된 클래스의 특정 인스턴스에 묶여 : 위의 염소 에서 만든 제리 , 암시 적으로 연결되어 코뿔소의 경우 이 에 제리 . 그렇지 않으면, 염소 를 인스턴스화 할 때 관련 Rhino 인스턴스를 명시 적으로 만듭니다 .

Rhino rhino = new Rhino();
Rhino.Goat goat = rhino.new Goat();

( 이상한 새 구문 에서 내부 유형을 염소 로 참조한다는 점에 유의 하십시오. Java는 코뿔소 부분 에서 포함 유형을 유추합니다 . 예, 새로운 rhino.Goat () 도 나에게 더 의미가 있습니다.)

이것이 우리에게 무엇을 가져 옵니까? 내부 클래스 인스턴스는 포함하는 클래스 인스턴스의 인스턴스 멤버에 액세스 할 수 있습니다. 이러한 둘러싸 인스턴스 멤버는 내부 클래스 내에 칭한다 통해 , 그들의 간단한 이름하지 통해 이 ( 이 내부 클래스는 내부 클래스 인스턴스가 아닌 연관된 함유 클래스 인스턴스를 참조) :

public class Rhino {

    private String barry;

    public class Goat {
        public void colin() {
            System.out.println(barry);
        }
    }
}

내부 클래스 에서 포함 클래스 의이 클래스를 Rhino.this 로 참조 할 수 있으며 이를 사용 하여 멤버를 참조 할 수 있습니다 ( 예 : Rhino.this.barry) .

현지 이너 클래스

로컬 내부 클래스는 메서드 본문에 선언 된 클래스입니다. 이러한 클래스는 포함 메소드 내에서만 알려져 있으므로 인스턴스화 할 수 있으며 포함 메소드 내에서 멤버에 액세스 할 수 있습니다. 장점은 로컬 내부 클래스 인스턴스가 포함 된 메서드의 최종 로컬 변수에 연결되어 액세스 할 수 있다는 것입니다. 인스턴스가 포함하는 메소드의 최종 로컬을 사용하는 경우 변수가 범위를 벗어난 경우에도 변수는 인스턴스 작성시 보유한 값을 유지합니다 (이는 사실상 Java의 조잡하고 제한된 클로저 버전입니다).

로컬 내부 클래스는 클래스 또는 패키지의 멤버가 아니므로 액세스 수준으로 선언되지 않습니다. (단, 자체 클래스의 멤버는 일반 클래스와 같은 액세스 레벨을 갖습니다.)

로컬 내부 클래스는 인스턴스 메서드에 선언되어있는 경우, 내부 클래스의 인스턴스를 포함하는 방법의 보유 인스턴스에 연결되어 이 인스턴스의 생성시에, 그래서 포함하는 클래스의 인스턴스 멤버는 인스턴스처럼 액세스 할 수 있습니다 내부 클래스. 로컬 내부 클래스는 이름을 통해 간단하게 인스턴스화 됩니다 . 예를 들어 로컬 내부 클래스 Cat 은 예상대로 new this.Cat ()가 아닌 new Cat () 로 인스턴스화됩니다 .

익명의 내부 클래스

익명의 내부 클래스는 구문 적으로 편리한 로컬 내부 클래스를 작성하는 방법입니다. 가장 일반적으로, 로컬 내부 클래스는 포함 메소드가 실행될 때마다 최대 한 번만 인스턴스화됩니다. 로컬 내부 클래스 정의와 단일 인스턴스화를 하나의 편리한 구문 형식으로 결합 할 수 있다면 좋을 것입니다. 클래스의 이름을 생각할 필요가 없다면 도움이 될 것입니다. 코드에 포함 된 이름이 더 좋습니다). 익명의 내부 클래스는 다음 두 가지를 모두 허용합니다.

new *ParentClassName*(*constructorArgs*) {*members*}

이것은 ParentClassName 을 확장하는 명명되지 않은 클래스의 새 인스턴스를 반환하는 표현식 입니다. 자신 만의 생성자를 제공 할 수 없습니다. 오히려, 단순히 수퍼 생성자를 호출하는 암시 적으로 제공되므로 제공된 인수는 수퍼 생성자에 맞아야합니다. (부모가 여러 생성자를 포함하는 경우, “가장 간단한”것을 “가장 단순”이라고하며, 자세히 배우고 싶지 않은 다소 복잡한 규칙 집합에 의해 결정됩니다. NetBeans 또는 Eclipse가 말하는 것에주의하십시오.)

또는 구현할 인터페이스를 지정할 수 있습니다.

new *InterfaceName*() {*members*}

이러한 선언은 Object를 확장하고 InterfaceName을 구현하는 명명되지 않은 클래스의 새 인스턴스를 만듭니다 . 다시, 당신은 당신 자신의 생성자를 제공 할 수 없습니다; 이 경우 Java는 암묵적으로 수행 할 작업을 생성하지 않습니다 (이 경우 생성자 인수는 절대 존재하지 않습니다).

익명의 내부 클래스에 생성자를 제공 할 수는 없지만 초기화 블록 (메서드 외부에 배치 된 {} 블록)을 사용하여 원하는 설정을 계속 수행 할 수 있습니다.

익명의 내부 클래스는 하나의 인스턴스로 로컬 내부 클래스를 만드는 덜 유연한 방법이라는 점을 명심하십시오. 다중 인터페이스를 구현 하거나 Object 이외의 클래스를 확장하는 동안 인터페이스를 구현 하거나 자체 생성자를 지정 하는 로컬 내부 클래스를 원한다면 일반 명명 된 로컬 내부 클래스를 작성해야합니다.

답변

public class Container {
    public class Item{
        Object data;
        public Container getContainer(){
            return Container.this;
        }
        public Item(Object data) {
            super();
            this.data = data;
        }

    }

    public static Item create(Object data){
        // does not compile since no instance of Container is available
        return new Item(data);
    }
    public Item createSubItem(Object data){
        // compiles, since 'this' Container is available
        return new Item(data);
    }
}

// class version 49.0 (49)
// access flags 33
public class Container$Item {

  // compiled from: Container.java
  // access flags 1
  public INNERCLASS Container$Item Container Item

  // access flags 0
  Object data

  // access flags 4112
  final Container this$0

  // access flags 1
  public getContainer() : Container
   L0
    LINENUMBER 7 L0
    ALOAD 0: this
    GETFIELD Container$Item.this$0 : Container
    ARETURN
   L1
    LOCALVARIABLE this Container$Item L0 L1 0
    MAXSTACK = 1
    MAXLOCALS = 1

  // access flags 1
  public <init>(Container,Object) : void
   L0
    LINENUMBER 12 L0
    ALOAD 0: this
    ALOAD 1
    PUTFIELD Container$Item.this$0 : Container
   L1
    LINENUMBER 10 L1
    ALOAD 0: this
    INVOKESPECIAL Object.<init>() : void
   L2
    LINENUMBER 11 L2
    ALOAD 0: this
    ALOAD 2: data
    PUTFIELD Container$Item.data : Object
    RETURN
   L3
    LOCALVARIABLE this Container$Item L0 L3 0
    LOCALVARIABLE data Object L0 L3 2
    MAXSTACK = 2
    MAXLOCALS = 3
}

OuterClass.InnerClass innerObject = outerObject.new InnerClass();

new InnerClass(outerObject)

public class OuterClass {
    public static class Inner1 {
    }
    public class Inner2 {
    }
}

OuterClass outer = new OuterClass();
OuterClass.Inner2 inner = outer.new Inner2();

OuterClass.Inner2 inner = new OuterClass().new Inner2();

OuterClass.Inner1 nestedObject = new OuterClass.Inner1();