Java 내부 클래스 및 정적 중첩 클래스

질문자 :Omnipotent

Java에서 내부 클래스와 정적 중첩 클래스의 주요 차이점은 무엇입니까? 디자인/구현이 이들 중 하나를 선택하는 역할을 합니까?

자바 튜토리얼에서 :

중첩 클래스는 정적 및 비정적의 두 가지 범주로 나뉩니다. 정적으로 선언된 중첩 클래스를 단순히 정적 중첩 클래스라고 합니다. 비정적 중첩 클래스를 내부 클래스라고 합니다.

정적 중첩 클래스는 둘러싸는 클래스 이름을 사용하여 액세스합니다.

 OuterClass.StaticNestedClass

예를 들어 정적 중첩 클래스에 대한 개체를 만들려면 다음 구문을 사용합니다.

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

내부 클래스의 인스턴스인 객체는 외부 클래스의 인스턴스 내에 존재합니다. 다음 클래스를 고려하십시오.

 class OuterClass { ... class InnerClass { ... } }

InnerClass의 인스턴스는 OuterClass의 인스턴스 내에서만 존재할 수 있으며 둘러싸는 인스턴스의 메서드와 필드에 직접 액세스할 수 있습니다.

내부 클래스를 인스턴스화하려면 먼저 외부 클래스를 인스턴스화해야 합니다. 그런 다음 다음 구문을 사용하여 외부 객체 내에 내부 객체를 생성합니다.

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

참조: Java 자습서 - 중첩 클래스

완전성을 위해 둘러싸는 인스턴스가 없는 내부 클래스 와 같은 것도 있음에 유의하십시오.

 class A { int t() { return 1; } static A a = new A() { int t() { return 2; } }; }

여기서 new A() { ... } 는 정적 컨텍스트에 정의된 내부 클래스 이며 둘러싸는 인스턴스가 없습니다.

Martin

Java 튜토리얼은 다음과 같이 말합니다.

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

일반적으로 "중첩된"과 "내부"라는 용어는 대부분의 프로그래머에서 같은 의미로 사용되지만 내부 및 정적을 모두 포함하는 올바른 용어 "중첩 클래스"를 사용하겠습니다.

클래스는 무한히 중첩될 수 있습니다. 예를 들어 클래스 A는 클래스 D를 포함하는 클래스 C를 포함하는 클래스 B를 포함할 수 있습니다. 그러나 일반적으로 나쁜 디자인이므로 둘 이상의 클래스 중첩 수준은 드뭅니다.

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

• 조직: 때로는 클래스를 다른 클래스의 네임스페이스로 정렬하는 것이 가장 합리적으로 보입니다. 특히 다른 컨텍스트에서 사용되지 않을 때
• 접근: 중첩된 클래스는 포함하는 클래스의 변수/필드에 특별한 접근 권한을 가집니다(정확히 어떤 변수/필드는 내부 또는 정적 여부에 관계없이 중첩된 클래스의 종류에 따라 다릅니다).
• 편리성: 모든 새로운 유형에 대해 새 파일을 생성해야 하는 것은 성가신 일입니다. 특히 유형이 하나의 컨텍스트에서만 사용되는 경우에는 더욱 그렇습니다.

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

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

더 자세히 설명하겠습니다.

정적 클래스

정적 클래스는 포함하는 클래스의 인스턴스와 아무 관련이 없기 때문에 이해하기 가장 쉬운 종류입니다.

정적 클래스는 다른 클래스의 정적 멤버로 선언된 클래스입니다. 다른 정적 멤버와 마찬가지로 이러한 클래스는 실제로 포함하는 클래스를 네임스페이스로 사용하는 행거에 불과합니다. 예를 들어 , Pizza 패키지에서 Rhino 클래스의 정적 멤버로 선언된 Goat 클래스는 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의 인스턴스에이 연결되어 있습니다. 그렇지 않으면 Goat 를 인스턴스화할 때 연결된 Rhino 인스턴스를 명시적으로 만듭니다.

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

(기묘한 새 구문에서 내부 유형을 그냥 Goat 으로 참조한다는 점에 유의하세요. Java는 rhino 부분에서 포함 유형을 유추합니다. 예, new rhino.Goat() 저도 더 이해가 갔을 것입니다.)

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

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

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

지역 이너 클래스

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

로컬 내부 클래스는 클래스나 패키지의 멤버가 아니므로 액세스 수준으로 선언되지 않습니다. (그러나 자신의 멤버는 일반 클래스와 같은 액세스 수준을 가집니다.)

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

익명의 내부 클래스

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

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

이것은 ParentClassName 을 확장하는 이름 없는 클래스의 새 인스턴스를 반환하는 표현식입니다. 자신의 생성자를 제공할 수 없습니다. 오히려 상위 생성자를 호출하는 하나가 암시적으로 제공되므로 제공된 인수는 상위 생성자에 맞아야 합니다. (부모가 여러 생성자를 포함하는 경우 "가장 단순한" 생성자를 호출하고, 자세히 배울 가치가 없는 다소 복잡한 규칙 세트에 의해 결정된 "가장 단순한"이라고 합니다. NetBeans 또는 Eclipse가 알려 주는 내용에 주의를 기울이십시오.)

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

 new *InterfaceName*() {*members*}

이러한 선언은 Object를 확장하고 InterfaceName을 구현하는 이름 없는 클래스의 새 인스턴스를 만듭니다. 다시 말하지만, 자신의 생성자를 제공할 수 없습니다. 이 경우 Java는 암시적으로 인수가 없고 아무것도 하지 않는 생성자를 제공합니다(따라서 이 경우 생성자 인수가 없을 것입니다).

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

익명의 내부 클래스는 하나의 인스턴스로 로컬 내부 클래스를 만드는 덜 유연한 방법이라는 점을 분명히 하십시오. 여러 인터페이스를 구현하거나 Object 이외의 일부 클래스를 확장하는 동안 인터페이스를 구현하거나 자체 생성자를 지정하는 로컬 내부 클래스를 원하는 경우 일반 명명된 로컬 내부 클래스를 만드는 데 문제가 있습니다.

Jegschemesch

위의 답변에서 실제 차이점이 명확 해지지 않았다고 생각합니다.

먼저 조건을 올바르게 이해하려면 다음을 수행하십시오.

• 중첩 클래스는 소스 코드 수준에서 다른 클래스에 포함된 클래스입니다.
• static 한정자로 선언하면 정적입니다.
• 정적이 아닌 중첩 클래스를 내부 클래스라고 합니다. (나는 비 정적 중첩 클래스를 유지합니다.)

Martin의 대답은 지금까지 맞습니다. 그러나 실제 질문은 다음과 같습니다. 중첩 클래스를 정적으로 선언하거나 선언하지 않는 목적은 무엇입니까?

클래스가 주제적으로 함께 속해 있거나 중첩 클래스가 둘러싸는 클래스에서 독점적으로 사용되는 경우 클래스를 함께 유지하려는 경우 정적 중첩 클래스를 사용합니다. 정적 중첩 클래스와 다른 모든 클래스 사이에는 의미론적 차이가 없습니다.

비정적 중첩 클래스 는 다른 유형입니다. 익명 내부 클래스와 유사하게 이러한 중첩 클래스는 실제로 클로저입니다. 즉, 주변 범위와 둘러싸는 인스턴스를 캡처하여 액세스할 수 있도록 합니다. 아마도 한 예가 그것을 명확히 할 것입니다. 이 컨테이너 스텁을 참조하십시오.

 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); } }

이 경우 하위 항목에서 상위 컨테이너로의 참조를 원합니다. 비정적 중첩 클래스를 사용하면 약간의 작업 없이 작동합니다. 당신은 구문을 사용하여 컨테이너의 둘러싸는 인스턴스에 액세스 할 수 Container.this .

더 많은 하드코어 설명은 다음과 같습니다.

컴파일러가 (비정적) 중첩 클래스에 대해 생성하는 Java 바이트코드를 보면 훨씬 더 명확해질 수 있습니다.

 // 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 }

보시다시피 컴파일러는 숨겨진 필드 Container this$0 생성합니다. 이것은 둘러싸는 인스턴스를 지정하기 위해 Container 유형의 추가 매개변수가 있는 생성자에서 설정됩니다. 소스에서 이 매개변수를 볼 수 없지만 컴파일러는 중첩 클래스에 대해 이를 암시적으로 생성합니다.

마틴의 예

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

(바이트 코드에서)와 같은 호출로 컴파일됩니다.

 new InnerClass(outerObject)

완전성을 위해:

익명 클래스 는 연결된 이름이 없고 나중에 참조할 수 없는 비정적 중첩 클래스의 완벽한 예입니다.

jrudolph

위의 답변 중 어느 것도 응용 프로그램 디자인 측면에서 중첩 클래스와 정적 중첩 클래스의 실제 차이점을 설명하지 못한다고 생각합니다.

개요

중첩 클래스 는 비정적이거나 정적일 수 있으며 각 경우 에 다른 클래스 내에 정의된 클래스 입니다. 내포 클래스는 엔클로징 클래스를 제공하기 위해서만 존재해야 하며 , 내포 클래스가 엔클로징뿐만 아니라 다른 클래스에서도 유용하다면 최상위 클래스로 선언해야 합니다.

차이점

비정적 중첩 클래스 : 포함하는 클래스의 바깥쪽 인스턴스와 암시적으로 연결됩니다. 즉, 바깥쪽 인스턴스의 메서드를 호출하고 변수에 액세스할 수 있습니다. 비정적 중첩 클래스의 일반적인 용도 중 하나는 어댑터 클래스를 정의하는 것입니다.

정적 중첩 클래스 : 둘러싸는 클래스 인스턴스에 액세스하고 메서드를 호출할 수 없으므로 내포 클래스가 둘러싸는 클래스의 인스턴스에 액세스할 필요가 없을 때 사용해야 합니다. 정적 중첩 클래스의 일반적인 용도는 외부 개체의 구성 요소를 구현하는 것입니다.

결론

따라서 디자인 관점에서 둘 사이의 주요 차이점은 정적이 아닌 중첩 클래스는 컨테이너 클래스의 인스턴스에 액세스할 수 있지만 정적은 액세스할 수 없다는 것 입니다.

aleroot

간단히 말해서 Java가 클로저를 제공하지 않기 때문에 주로 중첩 클래스가 필요합니다.

중첩 클래스는 둘러싸는 다른 클래스의 본문 내부에 정의된 클래스입니다. 정적 및 비 정적의 두 가지 유형이 있습니다.

그것들은 둘러싸는 클래스의 멤버로 취급되므로 4가지 액세스 지정자( private, package, protected, public 중 하나를 지정할 수 있습니다. public 또는 package-private로만 선언할 수 있는 최상위 클래스에는 이러한 사치가 없습니다.

내부 클래스(비 스택 클래스)는 상위 클래스의 다른 멤버에 액세스할 수 있습니다. 정적 중첩 클래스는 상위 클래스의 다른 멤버에 액세스할 수 없는 반면 private로 선언된 경우에도 마찬가지입니다.

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

Inner1 은 정적 내부 클래스이고 Inner2 는 정적이 아닌 내부 클래스입니다. 그들 사이의 주요 차이점은 Inner1 개체를 독립적으로 만들 수 있으므로 Outer 없이 Inner2

언제 Inner 클래스를 사용하시겠습니까?

Class A 와 Class B 가 관련되어 있고 Class B Class A 멤버에 액세스해야 Class B Class A 에만 관련되는 상황을 생각해 보십시오. 내부 수업이 그림으로 나타납니다.

내부 클래스의 인스턴스를 생성하려면 외부 클래스의 인스턴스를 생성해야 합니다.

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

또는

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

정적 내부 클래스는 언제 사용합니까?

둘러싸는 클래스/상위 클래스의 인스턴스와 아무런 관계가 없다는 것을 알고 있을 때 정적 내부 클래스를 정의합니다. 내부 클래스가 외부 클래스의 메소드나 필드를 사용하지 않는다면 공간 낭비일 뿐이므로 정적으로 만드십시오.

예를 들어 정적 중첩 클래스에 대한 개체를 만들려면 다음 구문을 사용합니다.

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

정적 중첩 클래스의 장점은 작동하기 위해 포함하는 클래스/상위 클래스의 개체가 필요하지 않다는 것입니다. 이것은 애플리케이션이 런타임에 생성하는 객체의 수를 줄이는 데 도움이 될 수 있습니다.

Thalaivar

다음은 Java 내부 클래스와 정적 중첩 클래스 간의 주요 차이점과 유사점입니다.

도움이 되기를 바랍니다!

이너 클래스

• 인스턴스 및 정적 메서드 및 필드 모두 외부 클래스에 액세스할 수 있습니다.

• 둘러싸는 클래스의 인스턴스와 연결되어 인스턴스화하려면 먼저 외부 클래스의 인스턴스가 필요합니다( new 키워드 place 참고).

   Outerclass.InnerClass innerObject = outerObject.new Innerclass();

• 정적 멤버 자체를 정의 할 수 없습니다.

• 클래스 또는 인터페이스 선언을 가질 수 없습니다.

정적 중첩 클래스

• 외부 클래스 인스턴스 메서드 또는 필드에 액세스할 수 없습니다.

• 둘러싸는 클래스의 인스턴스와 연결되지 않음 따라서 인스턴스화하려면 다음을 수행합니다.

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

유사점

• 두 내부 클래스 모두 외부 클래스 의 private 필드와 메서드 에도 액세스할 수 있습니다.
• 또한 외부 클래스 는 내부 클래스 의 개인 필드 및 메서드 에 액세스할 수 있습니다.
• 두 클래스 모두 private, protected 또는 public 액세스 수정자를 가질 수 있습니다.

중첩 클래스를 사용하는 이유

Oracle 문서에 따르면 몇 가지 이유가 있습니다( 전체 문서 ).

• 한 곳에서만 사용되는 클래스를 논리적으로 그룹화하는 방법입니다 . 클래스가 다른 하나의 클래스에만 유용하면 해당 클래스에 포함하고 둘을 함께 유지하는 것이 논리적입니다. 이러한 "도우미 클래스"를 중첩하면 패키지가 더 간소화됩니다.

• 캡슐화를 증가시킵니다. 두 개의 최상위 클래스 A와 B를 고려하십시오. 여기서 B는 그렇지 않으면 private로 선언될 A의 멤버에 액세스해야 합니다. 클래스 A 내에 클래스 B를 숨김으로써 A의 멤버를 private로 선언하고 B가 액세스할 수 있습니다. 또한 B 자체는 외부 세계에서 숨길 수 있습니다.

• 더 읽기 쉽고 유지 관리하기 쉬운 코드로 이어질 수 있습니다. 최상위 클래스 내에 작은 클래스를 중첩하면 코드가 사용되는 위치에 더 가깝게 배치됩니다.

Behzad Bahmanyar

일반적으로 따르는 규칙은 다음과 같습니다.

• 최상위 클래스 내의 정적 클래스 는 중첩 클래스입니다.
• 최상위 클래스 내의 비정적 클래스 는 내부 클래스 이며 두 가지 형식이 더 있습니다.
  • 로컬 클래스 - 메서드 또는 생성자 본문과 같은 블록 내부에 선언된 명명된 클래스
  • 익명 클래스 - 표현식 및 명령문에서 인스턴스가 생성되는 명명되지 않은 클래스

그러나 기억해야 할 몇 가지 사항은 다음과 같습니다.

• 최상위 클래스와 정적 중첩 클래스는 정적 중첩 클래스의 경우 외부 [부모] 클래스의 개인 정적 필드/메서드에 대한 정적 참조를 만들 수 있고 그 반대의 경우도 마찬가지라는 점을 제외하고는 의미상 동일합니다.

• 내부 클래스는 외부 [부모] 클래스의 인클로징 인스턴스의 인스턴스 변수에 액세스할 수 있습니다. 그러나 모든 내부 클래스에 인클로징 인스턴스가 있는 것은 아닙니다. 예를 들어 정적 이니셜라이저 블록에서 사용되는 익명 클래스와 같은 정적 컨텍스트의 내부 클래스에는 인클로징 인스턴스가 없습니다.

• Anonymous 클래스는 기본적으로 부모 클래스를 확장하거나 부모 인터페이스를 구현하며 다른 클래스를 확장하거나 더 이상 인터페이스를 구현하는 추가 절이 없습니다. 그래서,

  • new YourClass(){}; class [Anonymous] extends YourClass {} 함을 의미합니다.
  • new YourInterface(){}; class [Anonymous] implements YourInterface {} 함을 의미합니다.

---

나는 어떤 것을 언제 사용할 것인지에 대한 더 큰 질문이 열려 있다고 생각합니다. 글쎄, 그것은 주로 어떤 시나리오를 다루고 있는지에 달려 있지만 @jrudolph가 제공한 답변을 읽으면 결정을 내리는 데 도움이 될 수 있습니다.

sactiw

중첩 클래스: 클래스 안의 클래스

유형:

1. 정적 중첩 클래스
2. 비정적 중첩 클래스 [내부 클래스]

차이점:

비정적 중첩 클래스 [내부 클래스]

비정적 중첩 클래스에서 내부 클래스의 객체는 외부 클래스의 객체 내에 존재합니다. 따라서 외부 클래스의 데이터 멤버는 내부 클래스에 액세스할 수 있습니다. 따라서 내부 클래스의 객체를 생성하려면 먼저 외부 클래스의 객체를 생성해야 합니다.

 outerclass outerobject=new outerobject(); outerclass.innerclass innerobjcet=outerobject.new innerclass();

정적 중첩 클래스

정적 중첩 클래스에서 내부 클래스의 객체는 외부 클래스의 객체가 필요하지 않습니다. "정적"이라는 단어는 객체를 생성할 필요가 없음을 나타내기 때문입니다.

 class outerclass A { static class nestedclass B { static int x = 10; } }

x에 액세스하려면 다음 내부 메소드를 작성하십시오.

 outerclass.nestedclass.x; ie System.out.prinltn( outerclass.nestedclass.x);

tejas

내부 클래스의 인스턴스는 외부 클래스의 인스턴스가 생성될 때 생성됩니다. 따라서 내부 클래스의 멤버 및 메소드는 외부 클래스의 인스턴스(객체)의 멤버 및 메소드에 액세스할 수 있습니다. 외부 클래스의 인스턴스가 범위를 벗어나면 내부 클래스 인스턴스도 더 이상 존재하지 않습니다.

정적 중첩 클래스에는 구체적인 인스턴스가 없습니다. 처음 사용할 때 로드됩니다(정적 메서드와 마찬가지로). 메서드와 변수가 외부 클래스의 인스턴스에 액세스할 수 없는 완전히 독립적인 엔터티입니다.

정적 중첩 클래스는 외부 객체와 결합되지 않고 더 빠르며 이러한 클래스의 인스턴스를 생성할 필요가 없기 때문에 힙/스택 메모리를 사용하지 않습니다. 따라서 경험상 가능한 한 제한된 범위(private >= class >= protected >= public)로 정적 중첩 클래스를 정의한 다음 내부 클래스로 변환하고("정적" 식별자를 제거하여) 느슨하게 합니다. 범위, 정말 필요한 경우.

rmaruszewski

특정 상황에서 유용할 수 있는 중첩된 정적 클래스의 사용에 대한 미묘함이 있습니다.

정적 속성은 클래스가 생성자를 통해 인스턴스화되기 전에 인스턴스화되는 반면, 중첩된 정적 클래스 내부의 정적 속성은 클래스의 생성자가 호출될 때까지 또는 적어도 속성이 처음 참조된 후까지는 인스턴스화되지 않는 것 같습니다. 그들은 '최종'으로 표시됩니다.

다음 예를 고려하십시오.

 public class C0 { static C0 instance = null; // Uncomment the following line and a null pointer exception will be // generated before anything gets printed. //public static final String outerItem = instance.makeString(98.6); public C0() { instance = this; } public String makeString(int i) { return ((new Integer(i)).toString()); } public String makeString(double d) { return ((new Double(d)).toString()); } public static final class nested { public static final String innerItem = instance.makeString(42); } static public void main(String[] argv) { System.out.println("start"); // Comment out this line and a null pointer exception will be // generated after "start" prints and before the following // try/catch block even gets entered. new C0(); try { System.out.println("retrieve item: " + nested.innerItem); } catch (Exception e) { System.out.println("failed to retrieve item: " + e.toString()); } System.out.println("finish"); } }

'nested'와 'innerItem'이 모두 'static final'로 선언되었지만. nested.innerItem의 설정은 클래스가 인스턴스화될 때까지(또는 적어도 중첩된 정적 항목이 처음 참조될 때까지) 발생하지 않습니다. 위에. 'outerItem'에 대해서도 마찬가지입니다.

적어도 이것은 내가 Java 6.0에서 보고 있는 것입니다.

HippoMan

용어는 서로 바꿔서 사용됩니다. 당신이 정말 현학적되고 싶은 경우에, 당신은 정적 내부 클래스, 더 둘러싸는 인스턴스가없는 하나를 참조하는 "중첩 된 클래스"를 정의 할 수 있습니다. 코드에는 다음과 같은 내용이 있을 수 있습니다.

 public class Outer { public class Inner {} public static class Nested {} }

그것은 실제로 널리 받아 들여지는 정의가 아닙니다.

Daniel Spiewak

인스턴스를 생성하는 경우 비정적 내부 클래스의 인스턴스는 자신이 정의된 외부 클래스의 객체를 참조하여 생성한다. 이것은 포함하는 인스턴스가 있음을 의미합니다. 그러나 정적 내부 클래스의 인스턴스는 외부 클래스의 객체 참조가 아니라 외부 클래스의 참조로 생성됩니다. 이것은 인스턴스를 포함하지 않았음을 의미합니다.

예를 들어:

 class A { class B { // static int x; not allowed here….. } static class C { static int x; // allowed here } } class Test { public static void main(String… str) { A o=new A(); AB obj1 =o.new B();//need of inclosing instance AC obj2 =new AC(); // not need of reference of object of outer class…. } }

Ankit Jain

여기에 추가할 내용이 많지 않다고 생각합니다. 대부분의 답변은 정적 중첩 클래스와 내부 클래스의 차이점을 완벽하게 설명합니다. 그러나 중첩 클래스와 내부 클래스를 사용할 때는 다음 문제를 고려하십시오. 답변의 몇에서 언급 된 바와 같이 내부 클래스는없이 인스턴스화 할 수없는 수단 및 그 둘러싸는 클래스의 인스턴스 그들은 사실 때문에 GC의에 메모리 오버 플로우 또는 스택 오버 플로우 예외로 이어질 수있는 그들의 둘러싸는 클래스의 인스턴스에 대한 포인터를 것을 더 이상 사용되지 않더라도 둘러싸는 클래스를 가비지 수집할 수 없습니다. 이를 명확히 하려면 다음 코드를 확인하십시오.

 public class Outer { public class Inner { } public Inner inner(){ return new Inner(); } @Override protected void finalize() throws Throwable { // as you know finalize is called by the garbage collector due to destroying an object instance System.out.println("I am destroyed !"); } } public static void main(String arg[]) { Outer outer = new Outer(); Outer.Inner inner = outer.new Inner(); // out instance is no more used and should be garbage collected !!! // However this will not happen as inner instance is still alive ie used, not null ! // and outer will be kept in memory until inner is destroyed outer = null; // // inner = null; //kick out garbage collector System.gc(); }

// inner = null; 에 대한 주석을 제거하면 프로그램은 " 나는 파괴되었습니다!
그 이유는 흰색 내부 인스턴스가 여전히 참조되어 GC가 수집할 수 없고 외부 인스턴스를 참조(포인터가 있음)하기 때문에 수집되지 않기 때문입니다. 프로젝트에 이러한 개체가 충분하고 메모리가 부족할 수 있습니다.
인스턴스 관련이 아니라 클래스 관련이기 때문에 내부 클래스 인스턴스에 대한 포인트를 보유하지 않는 정적 내부 클래스와 비교합니다. 위의 프로그램은 "나는 파괴하고있다!"인쇄 할 수 있습니다 당신이 내부 클래스의 정적을하고 인스턴스화하는 경우 Outer.Inner i = new Outer.Inner();

Adelin

중첩 클래스는 매우 일반적인 용어입니다. 최상위 레벨이 아닌 모든 클래스는 중첩 클래스입니다. 내부 클래스는 정적이 아닌 중첩 클래스입니다. Joseph Darcy는 Nested, Inner, Member 및 Top-Level Classes에 대해 아주 좋은 설명을 작성했습니다.

Wouter Coekaerts

음... 내부 클래스는 중첩 클래스입니다... 익명 클래스와 내부 클래스를 의미합니까?

편집: 실제로 내부 대 익명을 의미했다면 내부 클래스는 다음과 같은 클래스 내에 정의된 클래스일 뿐입니다.

 public class A { public class B { } }

익명 클래스는 익명으로 정의된 클래스의 확장이므로 다음과 같이 실제 "클래스가 정의되지 않습니다.

 public class A { } A anon = new A() { /* you could change behavior of A here */ };

추가 편집:

Wikipedia 는 Java에 차이가 있다고 주장 하지만 8년 동안 Java로 작업해 왔으며 그런 구별은 처음 듣습니다... 말할 것도 없이 주장을 뒷받침할 참조가 없습니다... bottom 행에서 내부 클래스는 클래스 내에 정의된 클래스(정적이든 아니든)이고 중첩은 같은 것을 의미하는 또 다른 용어일 뿐입니다.

정적 중첩 클래스와 비 정적 중첩 클래스 사이에는 미묘한 차이가 있습니다... 기본적으로 비 정적 내부 클래스는 둘러싸는 클래스의 인스턴스 필드 및 메서드에 대한 암시적 액세스를 갖습니다(따라서 정적 컨텍스트에서 구성할 수 없으며 컴파일러가 됩니다. 오류). 반면에 정적 중첩 클래스는 인스턴스 필드 및 메서드에 대한 암시적 액세스가 없으며 정적 컨텍스트에서 구성할 수 있습니다.

Mike Stone

Java 및/또는 중첩 클래스에 대한 초보자를 대상으로 하는 학습자

중첩 클래스는 다음 중 하나일 수 있습니다.
1. 정적 중첩 클래스.
2. 비 정적 중첩 클래스. (내부 클래스 라고도 함) => 이것을 기억하십시오

1.이너클래스
예시:

 class OuterClass { /* some code here...*/ class InnerClass { } /* some code here...*/ }

내부 클래스는 중첩 클래스의 하위 집합입니다.

• 내부 클래스는 특정 유형의 중첩 클래스입니다.
• 내부 클래스는 중첩 클래스의 하위 집합입니다.
• 내부 클래스도 중첩 클래스라고 말할 수 있지만 중첩 클래스도 내부 클래스 라고 말할 수는 없습니다 .

이너 클래스의 특기:

• 내부 클래스의 인스턴스는 "비공개"로 표시된 경우에도 외부 클래스의 모든 멤버에 액세스할 수 있습니다.

2. 정적 중첩 클래스:
예시:

 class EnclosingClass { static class Nested { void someMethod() { System.out.println("hello SO"); } } }

사례 1: 둘러싸지 않는 클래스에서 정적 중첩 클래스 인스턴스화

 class NonEnclosingClass { public static void main(String[] args) { /*instantiate the Nested class that is a static member of the EnclosingClass class: */ EnclosingClass.Nested n = new EnclosingClass.Nested(); n.someMethod(); //prints out "hello" } }

사례 2: 둘러싸는 클래스에서 정적 중첩 클래스 인스턴스화

 class EnclosingClass { static class Nested { void anotherMethod() { System.out.println("hi again"); } } public static void main(String[] args) { //access enclosed class: Nested n = new Nested(); n.anotherMethod(); //prints out "hi again" } }

정적 클래스의 전문:

• 정적 내부 클래스는 외부 클래스의 정적 멤버에만 액세스할 수 있고 비정적 멤버에는 액세스할 수 없습니다.

결론:
질문: Java에서 내부 클래스와 정적 중첩 클래스의 주요 차이점은 무엇입니까?
답변: 위에서 언급한 각 클래스의 세부 사항을 살펴보십시오.

VeKe

Java의 내부 클래스 와 중첩 정적 클래스 는 모두 Java의 최상위 클래스라고 하는 다른 클래스 내부에 선언된 클래스입니다. Java 용어로 중첩 클래스를 static으로 선언하면 Java에서는 중첩된 정적 클래스라고 하고 비정적 중첩 클래스는 단순히 내부 클래스라고 합니다.

Java에서 내부 클래스란 무엇입니까?

최상위 레벨이 아니거나 다른 클래스 내부에 선언된 클래스를 중첩 클래스라고 하고 이러한 중첩 클래스 중에서 비정적으로 선언된 클래스를 Java에서 내부 클래스라고 합니다. Java에는 세 가지 종류의 내부 클래스가 있습니다.

1) 로컬 내부 클래스 - 코드 블록 또는 메소드 내부에서 선언됩니다.
2) 익명 내부 클래스 - 참조할 이름이 없고 생성된 동일한 위치에서 초기화되는 클래스입니다.
3) 멤버 내부 클래스 - 외부 클래스의 비 정적 멤버로 선언됩니다.

 public class InnerClassTest { public static void main(String args[]) { //creating local inner class inside method ie main() class Local { public void name() { System.out.println("Example of Local class in Java"); } } //creating instance of local inner class Local local = new Local(); local.name(); //calling method from local inner class //Creating anonymous inner class in Java for implementing thread Thread anonymous = new Thread(){ @Override public void run(){ System.out.println("Anonymous class example in java"); } }; anonymous.start(); //example of creating instance of inner class InnerClassTest test = new InnerClassTest(); InnerClassTest.Inner inner = test.new Inner(); inner.name(); //calling method of inner class } //Creating Inner class in Java private class Inner{ public void name(){ System.out.println("Inner class example in java"); } } }

Java에서 중첩 정적 클래스는 무엇입니까?

중첩된 정적 클래스는 클래스 내부에서 멤버로 선언되고 정적으로 만들어지는 또 다른 클래스입니다. 중첩된 정적 클래스도 외부 클래스의 멤버로 선언되며 다른 멤버처럼 private, public 또는 protected로 만들 수 있습니다. 내부 클래스에 비해 중첩된 정적 클래스의 주요 이점 중 하나는 중첩된 정적 클래스의 인스턴스가 외부 클래스의 둘러싸는 인스턴스에 연결되지 않는다는 것입니다. 또한 Java에서 중첩된 정적 클래스의 인스턴스를 생성하기 위해 Outer 클래스의 인스턴스가 필요하지 않습니다 .

1) private을 포함한 외부 클래스의 정적 데이터 멤버 에 접근할 수 있다.
2) 정적 중첩 클래스는 비정적(인스턴스) 데이터 멤버 또는 메서드에 액세스할 수 없습니다.

 public class NestedStaticExample { public static void main(String args[]){ StaticNested nested = new StaticNested(); nested.name(); } //static nested class in java private static class StaticNested{ public void name(){ System.out.println("static nested class example in java"); } } }

참조: 예제가 있는 Java의 내부 클래스 및 중첩 정적 클래스

roottraveller

나는 여기 사람들이 다음과 같은 포스터에 주목해야 한다고 생각합니다. Static Nest Class는 단지 첫 번째 내부 클래스일 뿐입니다. 예를 들어:

 public static class A {} //ERROR public class A { public class B { public static class C {} //ERROR } } public class A { public static class B {} //COMPILE !!! }

요약하자면 정적 클래스는 포함된 클래스에 의존하지 않습니다. 따라서 일반 클래스에서는 사용할 수 없습니다. (일반 클래스에는 인스턴스가 필요하기 때문에).

hqt

클래스 내부에 정적 멤버 클래스를 선언하면 최상위 중첩 클래스 또는 정적 중첩 클래스라고 합니다. 다음과 같이 시연할 수 있습니다.

 class Test{ private static int x = 1; static class A{ private static int y = 2; public static int getZ(){ return B.z+x; } } static class B{ private static int z = 3; public static int getY(){ return Ay; } } } class TestDemo{ public static void main(String[] args){ Test t = new Test(); System.out.println(Test.A.getZ()); System.out.println(Test.B.getY()); } }

클래스 내부에서 비정적 멤버 클래스를 선언할 때 이를 내부 클래스라고 합니다. 내부 클래스는 다음과 같이 시연할 수 있습니다.

 class Test{ private int i = 10; class A{ private int i =20; void display(){ int i = 30; System.out.println(i); System.out.println(this.i); System.out.println(Test.this.i); } } }

Pankti

위의 답변 중 어느 것도 응용 프로그램 디자인 측면에서 중첩 클래스와 정적 중첩 클래스의 차이점을 실제 예제로 제공하지 않는다고 생각합니다. 그리고 정적 중첩 클래스와 내부 클래스의 주요 차이점은 외부 클래스 인스턴스 필드에 액세스하는 기능입니다.

다음 두 가지 예를 살펴보겠습니다.

정적 중첩 클래스: 정적 중첩 클래스를 사용하는 좋은 예는 빌더 패턴( https://dzone.com/articles/design-patterns-the-builder-pattern )입니다.

BankAccount의 경우 주로 정적 중첩 클래스를 사용합니다.

1. 정적 중첩 클래스 인스턴스는 외부 클래스보다 먼저 생성될 수 있습니다.

2. 빌더 패턴에서 빌더는 BankAccount를 생성하는 데 사용되는 도우미 클래스입니다.

3. BankAccount.Builder는 BankAccount에만 연결됩니다. BankAccount.Builder와 관련된 다른 클래스는 없습니다. 따라서 이름 규칙을 사용하지 않고 함께 구성하는 것이 좋습니다.

 public class BankAccount { private long accountNumber; private String owner; ... public static class Builder { private long accountNumber; private String owner; ... static public Builder(long accountNumber) { this.accountNumber = accountNumber; } public Builder withOwner(String owner){ this.owner = owner; return this; } ... public BankAccount build(){ BankAccount account = new BankAccount(); account.accountNumber = this.accountNumber; account.owner = this.owner; ... return account; } } }

내부 클래스: 내부 클래스의 일반적인 용도는 이벤트 핸들러를 정의하는 것입니다.https://docs.oracle.com/javase/tutorial/uiswing/events/generalrules.html

MyClass의 경우 주로 다음과 같은 이유로 내부 클래스를 사용합니다.

1. 내부 클래스 MyAdapter는 외부 클래스 멤버에 액세스해야 합니다.

2. 예제에서 MyAdapter는 MyClass에만 연결됩니다. MyAdapter와 관련된 다른 클래스는 없습니다. 따라서 이름 규칙을 사용하지 않고 함께 구성하는 것이 좋습니다.

 public class MyClass extends Applet { ... someObject.addMouseListener(new MyAdapter()); ... class MyAdapter extends MouseAdapter { public void mouseClicked(MouseEvent e) { ...// Event listener implementation goes here... ...// change some outer class instance property depend on the event } } }

Leogao

다이어그램

주요 차이점 static nested 및 non-static nested 클래스, 즉 static nested 비 정적 외측 반원에 액세스 할 수없는

yoAlex5

static nested class 와 inner class 의 예입니다.

외부 클래스.자바

 public class OuterClass { private String someVariable = "Non Static"; private static String anotherStaticVariable = "Static"; OuterClass(){ } //Nested classes are static static class StaticNestedClass{ private static String privateStaticNestedClassVariable = "Private Static Nested Class Variable"; //can access private variables declared in the outer class public static void getPrivateVariableofOuterClass(){ System.out.println(anotherStaticVariable); } } //non static class InnerClass{ //can access private variables of outer class public String getPrivateNonStaticVariableOfOuterClass(){ return someVariable; } } public static void accessStaticClass(){ //can access any variable declared inside the Static Nested Class //even if it private String var = OuterClass.StaticNestedClass.privateStaticNestedClassVariable; System.out.println(var); } }

외부 클래스 테스트:

 public class OuterClassTest { public static void main(String[] args) { //access the Static Nested Class OuterClass.StaticNestedClass.getPrivateVariableofOuterClass(); //test the private variable declared inside the static nested class OuterClass.accessStaticClass(); /* * Inner Class Test * */ //Declaration //first instantiate the outer class OuterClass outerClass = new OuterClass(); //then instantiate the inner class OuterClass.InnerClass innerClassExample = outerClass. new InnerClass(); //test the non static private variable System.out.println(innerClassExample.getPrivateNonStaticVariableOfOuterClass()); } }

Pritam Banerjee

우선 Static 클래스라는 클래스는 없습니다. 내부 클래스와 함께 사용하는 Static 수정자(중첩 클래스라고 함)는 이것이 외부 클래스의 정적 멤버라고 말합니다. 외부 클래스의 인스턴스. (이것이 원래 static의 이점입니다.)

Nested 클래스와 일반 내부 클래스 사용의 차이점은 다음과 같습니다.

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

먼저 Outerclass를 인스턴스화한 다음 Inner에 액세스할 수 있습니다.

그러나 클래스가 중첩된 경우 구문은 다음과 같습니다.

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

정적 키워드의 일반적인 구현으로 정적 구문을 사용합니다.

Sohi

Java 프로그래밍 언어를 사용하면 다른 클래스 내에서 클래스를 정의할 수 있습니다. 이러한 클래스를 중첩 클래스라고 하며 여기에 설명되어 있습니다.

 class OuterClass { ... class NestedClass { ... } }

중첩 클래스는 정적 및 비정적의 두 가지 범주로 나뉩니다. 정적으로 선언된 중첩 클래스를 정적 중첩 클래스라고 합니다. 비정적 중첩 클래스를 내부 클래스라고 합니다. 우리가 염두에 두어야 할 한 가지는 비정적 중첩 클래스(내부 클래스)가 private으로 선언된 경우에도 바깥쪽 클래스의 다른 멤버에 액세스할 수 있다는 것입니다. 정적 중첩 클래스는 바깥쪽 클래스의 다른 멤버가 정적인 경우에만 액세스할 수 있습니다. 외부 클래스의 비정적 멤버에 액세스할 수 없습니다. 클래스 메서드 및 변수와 마찬가지로 정적 중첩 클래스는 외부 클래스와 연결됩니다. 예를 들어 정적 중첩 클래스에 대한 개체를 만들려면 다음 구문을 사용합니다.

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

내부 클래스를 인스턴스화하려면 먼저 외부 클래스를 인스턴스화해야 합니다. 그런 다음 다음 구문을 사용하여 외부 객체 내에 내부 객체를 생성합니다.

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

중첩 클래스를 사용하는 이유

1. 한 곳에서만 사용되는 클래스를 논리적으로 그룹화하는 방법입니다.
2. 캡슐화를 증가시킵니다.
3. 더 읽기 쉽고 유지 관리 가능한 코드로 이어질 수 있습니다.

출처:Java™ 자습서 - 중첩 클래스

Mithun Debnath

이미 언급된 것 외에도 중첩 클래스의 또 다른 사용 사례는 중첩 클래스에 외부 클래스에서만 액세스할 수 있는 메서드가 있는 경우입니다. 이것은 외부 클래스가 중첩된 클래스의 개인 생성자, 필드 및 메서드에 액세스할 수 있기 때문에 가능합니다.

아래의 예에서, Bank 발행 할 수 Bank.CreditCard 개인 생성자가, 그리고 개인 사용하여 현재 은행의 정책에 따라 신용 카드의 한도를 변경할 수 setLimit(...) 의 인스턴스 메소드 Bank.CreditCard . limit 대한 직접 필드 액세스도 작동합니다). Bank.CreditCard 의 공용 메서드만 액세스할 수 있습니다.

 public class Bank { // maximum limit as per current bank policy // is subject to change private int maxLimit = 7000; // ------- PUBLIC METHODS --------- public CreditCard issueCard( final String firstName, final String lastName ) { final String number = this.generateNumber(); final int expiryDate = this.generateExpiryDate(); final int CVV = this.generateCVV(); return new CreditCard(firstName, lastName, number, expiryDate, CVV); } public boolean setLimit( final CreditCard creditCard, final int limit ) { if (limit <= this.maxLimit) { // check against current bank policy limit creditCard.setLimit(limit); // access private method Bank.CreditCard.setLimit(int) return true; } return false; } // ------- PRIVATE METHODS --------- private String generateNumber() { return "1234-5678-9101-1123"; // the numbers should be unique for each card } private int generateExpiryDate() { return 202405; // date is YYYY=2024, MM=05 } private int generateCVV() { return 123; // is in real-life less predictable } // ------- PUBLIC STATIC NESTED CLASS --------- public static final class CreditCard { private final String firstName; private final String lastName; private final String number; private final int expiryDate; private final int CVV; private int balance; private int limit = 100; // default limit // the constructor is final but is accessible from outer class private CreditCard( final String firstName, final String lastName, final String number, final int expiryDate, final int CVV ) { this.firstName = firstName; this.lastName = lastName; this.number = number; this.expiryDate = expiryDate; this.CVV = CVV; } // ------- PUBLIC METHODS --------- public String getFirstName() { return this.firstName; } public String getLastName() { return this.lastName; } public String getNumber() { return this.number; } public int getExpiryDate() { return this.expiryDate; } // returns true if financial transaction is successful // otherwise false public boolean charge(final int amount) { final int newBalance = this.balance - amount; if (newBalance < -this.limit) { return false; } this.balance = newBalance; return true; } // ------- PRIVATE METHODS --------- private int getCVV() { return this.CVV; } private int getBalance() { return this.balance; } private void setBalance(final int balance) { this.balance = balance; } private int getLimit() { return limit; } private void setLimit(final int limit) { this.limit = limit; } } }

JCvanDamme

차이점은 정적이기도 한 중첩된 클래스 선언을 둘러싸는 클래스 외부에서 인스턴스화할 수 있다는 것입니다.

내부 클래스 라고도 하는 정적 이 아닌 중첩된 클래스 선언이 있는 경우 Java는 둘러싸는 클래스를 통하지 않고는 이를 인스턴스화하도록 허용하지 않습니다. 내부 클래스에서 생성된 객체는 외부 클래스에서 생성된 객체와 연결되어 내부 클래스가 외부 클래스의 필드를 참조할 수 있습니다.

그러나 정적이면 링크가 존재하지 않고 외부 필드에 액세스할 수 없으므로(다른 개체와 같은 일반 참조를 통한 경우 제외) 따라서 중첩된 클래스를 자체적으로 인스턴스화할 수 있습니다.

DigitalRoss

Java 코드에서 발생할 수 있는 다양한 가능한 수정 및 오류 시나리오를 설명했습니다.

 class Outter1 { String OutStr; Outter1(String str) { OutStr = str; } public void NonStaticMethod(String st) { String temp1 = "ashish"; final String tempFinal1 = "ashish"; // below static attribute not permitted // static String tempStatic1 = "static"; // below static with final attribute not permitted // static final String tempStatic1 = "ashish"; // synchronized keyword is not permitted below class localInnerNonStatic1 { synchronized public void innerMethod(String str11) { str11 = temp1 +" sharma"; System.out.println("innerMethod ===> "+str11); } /* // static method with final not permitted public static void innerStaticMethod(String str11) { str11 = temp1 +" india"; System.out.println("innerMethod ===> "+str11); }*/ } // static class not permitted below // static class localInnerStatic1 { } } public static void StaticMethod(String st) { String temp1 = "ashish"; final String tempFinal1 = "ashish"; // static attribute not permitted below //static String tempStatic1 = "static"; // static with final attribute not permitted below // static final String tempStatic1 = "ashish"; class localInnerNonStatic1 { public void innerMethod(String str11) { str11 = temp1 +" sharma"; System.out.println("innerMethod ===> "+str11); } /* // static method with final not permitted public static void innerStaticMethod(String str11) { str11 = temp1 +" india"; System.out.println("innerMethod ===> "+str11); }*/ } // static class not permitted below // static class localInnerStatic1 { } } // synchronized keyword is not permitted static class inner1 { static String temp1 = "ashish"; String tempNonStatic = "ashish"; // class localInner1 { public void innerMethod(String str11) { str11 = temp1 +" sharma"; str11 = str11+ tempNonStatic +" sharma"; System.out.println("innerMethod ===> "+str11); } public static void innerStaticMethod(String str11) { // error in below step str11 = temp1 +" india"; //str11 = str11+ tempNonStatic +" sharma"; System.out.println("innerMethod ===> "+str11); } //} } //synchronized keyword is not permitted below class innerNonStatic1 { //This is important we have to keep final with static modifier in non // static innerclass below static final String temp1 = "ashish"; String tempNonStatic = "ashish"; // class localInner1 { synchronized public void innerMethod(String str11) { tempNonStatic = tempNonStatic +" ..."; str11 = temp1 +" sharma"; str11 = str11+ tempNonStatic +" sharma"; System.out.println("innerMethod ===> "+str11); } /* // error in below step public static void innerStaticMethod(String str11) { // error in below step // str11 = tempNonStatic +" india"; str11 = temp1 +" india"; System.out.println("innerMethod ===> "+str11); }*/ //} } }

Ashish Sharma

출처 : http:www.stackoverflow.com/questions/70324/java-inner-class-and-static-nested-class