생성자 class inner java 자바 내부 클래스와 정적 중첩 클래스




12 Answers

Java 튜토리얼의 내용 :

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

일반적으로 말하면 "중첩 된"및 "내부"라는 용어는 대부분의 프로그래머가 상호 교환하여 사용하지만 내부 및 정적을 모두 포함하는 올바른 "중첩 된 클래스"라는 용어를 사용합니다.

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

중첩 된 클래스를 만들 수있는 세 가지 이유가 있습니다.

  • organization : 클래스를 다른 클래스의 네임 스페이스로 정렬하는 것이 가장 현명한 경우가 있는데, 다른 어떤 상황에서도 사용되지 않을 때 특히 그렇습니다.
  • 액세스 : 중첩 클래스는 포함하는 클래스의 변수 / 필드에 대한 특별한 액세스 권한을가집니다 (내부 또는 정적 여부와 상관없이 중첩 클래스의 종류에 따라 정확히 어떤 변수 / 필드가 사용되는지).
  • 편의성 : 모든 새로운 유형에 대해 새 파일을 작성해야하는 번거 로움이 있습니다. 특히 형식이 한 문맥에서만 사용될 때 특히 그렇습니다.

Java 에는 4 가지 중첩 클래스가 있습니다. 요약하면 다음과 같습니다.

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

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


정적 클래스

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

정적 클래스는 다른 클래스의 정적 멤버로 선언 된 클래스입니다. 다른 정적 멤버와 마찬가지로 클래스는 실제로 클래스를 포함하는 클래스를 네임 스페이스로 사용합니다. 예를 들어 패키지 피자 에서 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 가 포함 된 것으로 규정되지만 포함하는 클래스 내부에서는 간단한 이름으로 알 수 있습니다. 그러나 내부 클래스의 모든 인스턴스는 포함하는 클래스의 특정 인스턴스에 연결됩니다. 위의 jerry 에서 만든 GoatjerryRhino 인스턴스에 암시 적으로 연결되어 있습니다. 그렇지 않으면 Goat 을 인스턴스화 할 때 연관된 Rhino 인스턴스를 명시 적으로 만듭니다.

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

(자바가 Rhino 에서 포함 된 타입을 추론하고, 새로운 rhino.Goat () 가 나에게 더 의미가 있었을 것입니다.

그러면 우리가 무엇을 얻게 될까요? 내부 클래스 인스턴스는 포함하는 클래스 인스턴스의 인스턴스 멤버에 액세스 할 수 있습니다. 이러한 인 클로징 인스턴스 멤버는 이것을 통하지 않고 단순한 이름을 통해 내부 클래스 내부에서 참조됩니다 (내부 클래스의 경우 내부 클래스 인스턴스를 참조하며 연결된 클래스 인스턴스는 포함하지 않습니다).

public class Rhino {

    private String barry;

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

내부 클래스에서 이것을 포함하는 클래스를 Rhino 로 참조 할 수 있습니다. 클래스를 사용하여 Rhino.this.barry같은 멤버를 참조 할 수 있습니다.


로컬 내부 클래스

로컬 내부 클래스는 메서드 본문에서 선언 된 클래스입니다. 이러한 클래스는 포함하는 메서드 내에서만 알 수 있으므로 인스턴스화하고 해당 멤버를 포함하는 메서드 내에서 멤버에 액세스 할 수 있습니다. 이득은 로컬 내부 클래스 인스턴스가 묶여 있고 포함하는 메서드의 최종 로컬 변수에 액세스 할 수 있다는 것입니다. 인스턴스가 포함 메서드의 최종 로컬을 사용하면 변수가 범위를 벗어 났더라도 (즉, Java의 제한된 클로저의 제한된 버전의 클로저 인 경우에도) 변수는 인스턴스를 만들 때 보유한 값을 유지합니다.

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

인스턴스 메소드로 로컬의 내부 클래스가 선언되고있는 경우, 내부 클래스의 인스턴스화는 인스턴스의 작성시에 this 를 포함하고있는 메소드에 의해 보관 유지되고있는 인스턴스에 묶여 지므로, 포함하는 클래스의 인스턴스 멤버는 인스턴스와 같이 액세스 할 수 있습니다 내부 클래스. 로컬 내부 클래스는 이름을 통해 간단히 인스턴스화 됩니다 ( 예 : 로컬 내부 클래스). Cat 은 새로운 this ()가 아니라 새 this.Cat ()로 인스턴스화됩니다.


익명 내부 클래스

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

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

이것은 ParentClassName 을 확장하는 이름없는 클래스의 새 인스턴스를 반환하는 표현식입니다. 자신 만의 생성자를 제공 할 수는 없습니다. 오히려 단순히 슈퍼 생성자를 호출하는 하나가 암시 적으로 제공되므로 제공된 인수는 슈퍼 생성자에 적합해야합니다. (부모가 여러 생성자를 포함하고 있다면 "가장 단순한"이라고 불리는데, 자세히 배우는 데 신경 쓸 가치가없는 다소 복잡한 규칙 집합에 의해 결정되므로 "NetBeans 또는 Eclipse에 대한 설명에주의하십시오.)

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

new *InterfaceName*() {*members*}

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

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

익명의 내부 클래스는 하나의 인스턴스로 로컬 내부 클래스를 만드는 덜 유연한 방법이라는 것을 분명히하십시오. 여러 개의 인터페이스를 구현하는 로컬 내부 클래스 또는 Object가 아닌 다른 클래스를 확장하거나 자체 생성자를 지정하는 인터페이스를 구현하려는 경우에는 로컬 내부 클래스를 만듭니다.

자바 static inner class

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




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

오버뷰

중첩 된 클래스 는 비 정적이거나 정적 일 수 있으며 각각의 경우 에 다른 클래스 내에 정의 된 클래스 입니다. 중첩 된 클래스는 오직 클래스를 둘러싸는 클래스로만 존재해야합니다 . 중첩 된 클래스가 다른 클래스에서 유용 할 경우 (둘러싸기만 해당) 최상위 클래스로 선언해야합니다.

Nonstatic Nested class : 포함하는 클래스의 둘러싼 인스턴스에 암시 적으로 연결되어 있습니다. 즉, 포함 된 인스턴스의 메서드 및 액세스 변수를 호출 할 수 있습니다. 비 정적 중첩 클래스의 일반적인 용도 중 하나는 Adapter 클래스를 정의하는 것입니다.

정적 중첩 클래스 : 둘러싸는 클래스 인스턴스에 액세스 할 수없고 메서드를 호출 할 수 없으므로 중첩 클래스가 해당 클래스의 인스턴스에 액세스하지 않아도되는 경우 사용해야합니다. 정적 중첩 클래스의 일반적인 용도는 외부 객체의 구성 요소를 구현하는 것입니다.

결론

따라서 디자인 관점에서 볼 때 두 가지의 주요 차이점은 비 정적 중첩 클래스는 컨테이너 클래스의 인스턴스에 액세스 할 수 있지만 정적은 그렇지 못합니다 .




제 생각에, 일반적으로 따라 오는 국제 대회는 다음과 같습니다 :

  • 최상위 클래스의 static 클래스중첩 클래스입니다.
  • 최상위 클래스 내에서 정적이 아닌 클래스는 내부 클래스로 , 두 개의 형식이 더 있습니다.
    • 로컬 클래스 - 메서드 또는 생성자 본문처럼 블록 내부에 선언 된 명명 된 클래스
    • 익명 클래스 - 인스턴스가 표현식 및 명령문에서 작성된 이름이없는 클래스

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

  • 최상위 클래스와 정적 중첩 클래스는 정적으로 중첩 된 클래스의 경우 Outer [parent] 클래스의 전용 정적 필드 / 메서드에 대한 정적 참조를 만들 수 있다는 점을 제외하고는 의미 상 동일합니다.

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

  • 익명 클래스는 기본적으로 상위 클래스를 확장하거나 상위 인터페이스를 구현하므로 다른 클래스를 확장하거나 더 이상 인터페이스를 구현할 절이 없습니다. 그래서,

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

어느 쪽이 언제 열려야하는 더 큰 질문이 언제 느껴지나요? 글쎄요, 대부분 당신이 다루는 시나리오에 달려 있지만, @jrudolph가 준 답장을 읽는 것은 당신이 어떤 결정을 내리는 데 도움이 될 수 있습니다.




중첩 된 클래스 : 클래스 내부의 클래스

유형 :

  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;  i.e. System.out.prinltn( outerclass.nestedclass.x);



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

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

다음 예제를 고려하십시오.

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

'중첩 된'과 'innerItem'은 둘 다 '정적 최종'으로 선언됩니다. nested.innerItem의 설정은 클래스가 인스턴스화 될 때까지 (또는 중첩 된 정적 항목이 처음 참조 될 때까지) 적어도 내가 참조하는 행을 주석 처리하고 주석 처리를 제거하여 볼 수 있기 전까지는 일어나지 않습니다. 위. 'outerItem'도 마찬가지입니다.

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




여기에 추가 할 부분이 많이 없다고 생각합니다. 대부분의 대답은 정적 중첩 클래스와 내부 클래스의 차이점을 완벽하게 설명합니다. 그러나 중첩 클래스와 내부 클래스를 사용할 때는 다음 문제를 고려하십시오. 몇 가지 대답에서 언급했듯이 내부 클래스는 내부 클래스가 내부 클래스없이 인스턴스화 될 수 없으므로 내부 클래스는 내부 클래스를 포함하는 클래스의 인스턴스없이 인스턴스화 될 수 있습니다. 즉, 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 i.e 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; 에서 주석을 제거하면 // inner = null; 이 프로그램은 " 나는 파괴되었습니다! "라고 표시 할 것이지만, 이것을 주석으로 유지하면 그렇지 않을 것입니다.
그 이유는 흰색 내부 인스턴스가 여전히 GC가 그것을 수집 할 수 없으며 외부 인스턴스를 참조 (포인터가 있음)하므로 수집되지 않는다는 것입니다. 프로젝트에 이러한 개체가 충분하고 메모리가 부족할 수 있습니다.
인스턴스와 관련이 없지만 클래스와 관련되어 있기 때문에 내부 클래스 인스턴스에 대한 포인터를 보유하지 않는 정적 내부 클래스와 비교합니다. 위의 프로그램은 Inner 클래스를 정적으로 만들고 Outer.Inner i = new Outer.Inner(); 인스턴스화하면 " 나는 파괴되었습니다! " 라고 인쇄 할 수 있습니다 Outer.Inner i = new Outer.Inner();




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




Java 및 / 또는 중첩 클래스 초보자 인 학습자 타겟팅

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


1. 내부 수업
예:

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


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

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

내부 클래스의 특수성 :

  • 내부 클래스의 인스턴스는 외부 클래스의 모든 멤버에 액세스 할 수 있습니다 . 심지어 "private"로 표시된 멤버까지도 액세스 할 수 있습니다.


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에서 내부 클래스와 정적 중첩 클래스 간의 주요 차이점은 무엇입니까?
답변 : 위에서 언급 한 각 클래스의 세부 사항을 살펴보십시오.




여기 사람들이 포스터에 주목해야한다고 생각합니다. 정적 중첩 클래스는 첫 번째 내부 클래스에 불과합니다. 예 :

 public static class A {} //ERROR

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

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

 }

따라서 요약하면 static 클래스는 클래스에 포함되지 않습니다. 그래서 정상적인 수업을들을 수 없습니다. (정상적인 클래스는 인스턴스가 필요하기 때문에).




다음은 static nested class및 의 예입니다 inner class.

OuterClass.java

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

}

OuterClassTest :

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

    }

}



무엇보다도 먼저 Static 클래스라고하는 클래스는 없습니다. 내부 클래스 (중첩 클래스라고 함)와 함께 정적 수정자를 사용하면 외부 클래스의 정적 멤버이므로 다른 정적 멤버와 마찬가지로 액세스 할 수 있다는 것을 의미합니다. Outer 클래스의 인스턴스입니다. (정적 인 것의 이점은 원래있다.)

중첩 클래스와 일반 Inner 클래스의 차이점은 다음과 같습니다.

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

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

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

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

어떤 정적 키워드의 정상적인 구현으로 정적 구문을 사용합니다.




Java에서 정적 및 비 정적 중첩 클래스 간의 차이점

1) 중첩 된 정적 클래스는 Outer 클래스의 참조가 필요하지 않지만 정적 인 중첩 클래스 또는 내부 클래스는 Outer 클래스 참조가 필요합니다. Outer 클래스의 인스턴스를 만들지 않고 Inner 클래스의 인스턴스를 생성 할 수 없습니다. 중첩 된 클래스를 정적 ​​또는 비 정적으로 만드는 동안 고려해야 할 가장 중요한 사항입니다.

2) 정적 클래스는 실제로 클래스의 정적 멤버이며 정적 인 컨텍스트, 예를 들어 정적 메서드 또는 Outer 클래스의 정적 블록에서 사용할 수 있습니다.

3) 정적 및 비 정적 중첩 클래스 간의 또 다른 차이점은 메서드 및 필드를 중첩 된 정적 클래스에 직접 입력하는 것과 같이 비 정적 멤버에 액세스 할 수 없다는 것입니다. 만약 당신이 "정적이 아닌 구성원 정적 컨텍스트에서 사용할 수 없습니다"같은 오류가 나타납니다. Inner 클래스는 Outer 클래스의 정적 멤버와 정적 멤버가 아닌 멤버 모두에 액세스 할 수 있습니다.

public class OuterClass {
    private static String message = "Hello JAVA";

    // How to create instance of static and non static nested class
    public static void main(String... args) {

        // creating instance of nested Static class
        InnerClassStatic printer = new InnerClassStatic();

        //calling non static method of nested static class
        printer.printMessage();

        // creating instance of non static nested class or InnerClass class
        // In order to create instance of InnerClass class you need an OuterClass class instance
        OuterClass outerClass = new OuterClass(); //outerClass class instance for creating non static nested class

        InnerClass innerClass = outerClass.new InnerClass();
        innerClass.display();  //calling non static method of InnerClass class

        // we can also combine above steps in one step to create instance of InnerClass class
        InnerClass nonStaticIner = new OuterClass().new InnerClass();

        nonStaticIner.display(); // similarly you can now call InnerClass class method
    }


    // Static nested class
    private static class InnerClassStatic {
        //Only static member of OuterClass class is directly accessible in nested static class

        public void printMessage() {
            // Compile time error if message field is not static
            System.out.println("Message from nested static class : " + message);
        }
    }

    //non static nested class - also called InnerClass class
    private class InnerClass {

        // Both static and non static member of OuterClass class is accessible in this InnerClass class
        public void display() {
            System.out.println(" Message from non static nested or InnerClass class : " + message);
        }
    }
}

산출:

Message from nested static class : Hello JAVA
Message from non static nested or Inner class : Hello JAVA
Message from non static nested or Inner class : Hello JAVA

Java의 Static 및 Non Static 중첩 클래스 간의 차이점이 있습니다. 지금까지 우리는 멤버 Inner 클래스만을 다루었지만 Inner 클래스에는 다른 두 가지 타입, 예를 들어 Local 클래스와 Anonymous Inner 클래스를 언급하지 않았습니다. 이 Java 자습서에서는 Java에서 중첩 된 정적 클래스 란 무엇이며 중첩 된 정적 클래스와 비 정적 클래스 모두의 인스턴스를 Java에서 작성하는 방법을 살펴 보았습니다.

요약하면 내부 클래스는 Outer 클래스의 인스턴스를 필요로하지 않으므로 중첩 된 정적 클래스의 인스턴스를 쉽게 만들 수 있습니다. 예를 들어 Inner 클래스는 항상 Outer 클래스 인스턴스가 필요하며 Outer 클래스가 없으면 존재할 수 없습니다. 정적 클래스와 비 정적 클래스 중 하나를 선택해야한다면 정적 중첩 클래스를 사용하는 것이 좋습니다.




Related