Klasa wewnętrzna Java i klasa zagnieżdżona statycznie

The Java tutorial says :

Terminologia: klasy zagnieżdżone są podzielone na dwie kategorie: statyczne i nie statyczne. Zagnieżdżone klasy, które są deklarowane statyczne są po prostu nazywane klasy zagnieżdżone statyczne. Niestatyczne klasy zagnieżdżone nazywane są wewnętrznymi klasy.

W potocznym mowie, terminy " zagnieżdżona "i" wewnętrzna "są używane zamiennie przez większość programistów, ale użyję poprawnego terminu" Klasa zagnieżdżona", który obejmuje zarówno wewnętrzną, jak i wewnętrzną statyczne.

Klasy mogą być zagnieżdżane ad infinitum , np. Klasa A może zawierać klasę B, która zawiera klasę C, która zawiera klasę D, itd. Jednak więcej niż jeden poziom zagnieżdżania klas jest rzadki, ponieważ jest to generalnie zły projekt.

Istnieją trzy powody, dla których można utworzyć klasę zagnieżdżoną:

• organizacja: czasami najbardziej sensowne wydaje się posortowanie klasy do przestrzeni nazw innej klasy, zwłaszcza gdy nie będzie ona używana w żadnym innym kontekście
• dostęp: klasy zagnieżdżone mają specjalny dostęp do zmiennych / pól swoich klas zawierających (dokładnie, które zmienne/pola zależą od rodzaju zagnieżdżonej klasy, czy to wewnętrznej czy statycznej).
• wygoda: tworzenie nowego pliku dla każdego nowego typu jest kłopotliwe, zwłaszcza gdy Typ będzie używany tylko w jednym kontekście

Istnieją cztery rodzaje zagnieżdżonych klas w Javie . W skrócie są to:

• Klasa statyczna : zadeklarowana jako statyczna członek innej klasy
• Klasa wewnętrzna: zadeklarowana jako członek instancji innej klasy
• local inner class: zadeklarowana wewnątrz metody instancji innej klasy
• anonymous inner class : podobnie jak lokalna Klasa wewnętrzna, ale zapisywana jako wyrażenie, które zwraca jednorazowy obiekt

Klasy Statyczne

Klasy statyczne są najprostszym rodzajem do zrozumienia ponieważ nie mają nic wspólnego z instancjami klasy zawierającej.

Klasa statyczna jest klasą zadeklarowaną jako statyczny członek innej klasy. Podobnie jak inne statyczne elementy, taka klasa jest tak naprawdę tylko wieszakiem, który używa klasy zawierającej jako swojej przestrzeni nazw, np. Klasa Goat zadeklarowana jako statyczny członek klasy Rhino w pakiecie pizza jest znana pod nazwą pizza.Nosorożec.Koza .

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

Szczerze mówiąc, statyczne klasy są dość bezwartościową cechą, ponieważ klasy są już podzielone na przestrzenie nazw według pakietów. Jedynym możliwym powodem do stworzenia klasy statycznej jest to, że taka klasa ma dostęp do prywatnych statycznych członków klasy, ale uważam to za dość lamerskie uzasadnienie istnienia funkcji klasy statycznej.

Klasy Wewnętrzne

Klasa wewnętrzna jest klasą zadeklarowaną jako niestatyczny członek innej klasy:

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

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

Jak z Klasa statyczna, Klasa wewnętrzna znana jest pod nazwą klasy .Nosorożec.Koza , ale wewnątrz klasy może być znana pod prostą nazwą. Jednak każda instancja klasy wewnętrznej jest powiązana z konkretną instancją klasy zawierającej: powyżej Goat utworzony w jerry, jest pośrednio powiązany z Rhino instancją to w jerry. W przeciwnym razie tworzymy skojarzoną instancję Rhino explicit when we instantiate Goat :

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

(zauważ, że zwracasz uwagę na typ wewnętrzny jako tylko Goat w dziwnej new składnia: Java wywiera Typ zawierający z rhino część. I, tak Nowy nosorożec.Koza () dla mnie też miałoby to większy sens.)

public class Rhino {

    private String barry;

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

W klasie wewnętrznej możesz odnieść się dotego klasy zawierającej jako Rhino.to, a możesz użyć to , aby odnieść się do jego członków, np. Rhino.to.barry .

Local Inner Classes

A local inner class to klasa zadeklarowana w ciele metody. Taka klasa jest znana tylko w jej metodzie zawierającej, więc może być tworzona instancyjnie i mieć dostęp do jej członków w jej metodzie zawierającej. Zysk polega na tym, że lokalna instancja klasy wewnętrznej jest powiązana i może uzyskać dostęp do końcowych zmiennych lokalnych swojej metody zawierającej. Gdy instancja używa ostatecznej lokalnej metody zawierającej, zmienna zachowuje wartość przechowywaną w momencie tworzenia instancji, nawet jeśli zmienna wyszedł poza zasięg (jest to faktycznie prymitywna, limitowana wersja Javy).

Ponieważ lokalna Klasa wewnętrzna nie jest członkiem klasy ani pakietu, nie jest deklarowana z poziomem dostępu. (Być jednak jasne, że jego członkowie mają poziomy dostępu jak w normalnej klasie.)

Jeśli lokalna Klasa wewnętrzna jest zadeklarowana w metodzie instancji, instancja klasy wewnętrznej jest powiązana z instancją przechowywaną przez metodę zawierającą this w czasie utworzenie instancji, a więc składowe instancji klasy zawierającej są dostępne jak w klasie wewnętrznej instancji. Lokalna Klasa wewnętrzna jest tworzona po prostu poprzez jej nazwę, np. lokalna Klasa wewnętrzna Cat jest tworzona jako new Cat () , a nie new this.Cat () jak można się spodziewać.

Anonimowe Klasy Wewnętrzne

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

Jest to wyrażenie zwracające nową instancję nienazwanej klasy która rozszerza ParentClassName. Nie możesz podać własnego konstruktora; zamiast tego jest dostarczany w domyśle, który po prostu nazywa super konstruktor, więc dostarczone argumenty muszą pasować do super konstruktora. (Jeśli rodzic zawiera wiele konstruktorów, nazywa się "najprostszy", "najprostszy" zgodnie z dość złożonym zestawem reguł, których nie warto uczyć się szczegółowo-po prostu zwróć uwagę na to, co mówią ci NetBeans lub Eclipse.)

Alternatywnie można określić interfejs do implementacji:

new *InterfaceName*() {*members*}

Taka deklaracja tworzy nową instancję nienazwanej klasy, która rozszerza obiekt i implementuje nazwę interfejsu . Ponownie, nie możesz dostarczyć własnego konstruktora; w tym przypadku Java domyślnie dostarcza konstruktora no-arg, do-nothing (więc nigdy nie będzie argumentów konstruktora w tym przypadku).

Nawet jeśli nie możesz nadać anonimowej klasie wewnętrznej konstruktora, nadal możesz wykonać dowolną konfigurację, używając bloku inicjalizacji (a {} blok umieszczony poza dowolną metodą).

Wyjaśnij, że anonimowa Klasa wewnętrzna jest po prostu mniej elastycznym sposobem tworzenia lokalnej klasy wewnętrznej z jedną instancją. Jeśli chcesz mieć lokalną klasę wewnętrzną, która implementuje wiele interfejsów lub która implementuje interfejsy podczas rozszerzania jakiejś klasy innej niż Object lub która określa własny konstruktor, utknąłeś w tworzeniu zwykłej, nazwanej local inner class.

Myślę, że prawdziwa różnica nie stała się jasna w powyższych odpowiedziach.

Pierwsze poprawne sformułowanie:

• Klasa zagnieżdżona jest klasą, która jest zawarta w innej klasie na poziomie kodu źródłowego.
• jest statyczny, jeśli zadeklarujesz go za pomocą modyfikatora static.
• niestatyczna Klasa zagnieżdżona nazywana jest klasą wewnętrzną. (I stay with non-static zagnieżdżone klasy.)

Odpowiedź Martina jest jak na razie słuszna. Jednak prawdziwe pytanie brzmi: Co to jest cel deklaracji klasy zagnieżdżonej statyczny czy nie?

Używasz statycznych klas zagnieżdżonych , jeśli chcesz trzymać swoje klasy razem, jeśli należą one miejscowo do siebie lub jeśli Klasa zagnieżdżona jest używana wyłącznie w klasie zamykającej. Nie ma różnicy semantycznej między statyczną klasą zagnieżdżoną a każdą inną klasą.

Niestatyczne klasy zagnieżdżone to inna bestia. Podobnie jak anonimowe klasy wewnętrzne, takie zagnieżdżone klasy są w rzeczywistości zamknięciami. Że oznacza to, że przechwytywają otaczający ich zasięg i otaczającą instancję i czynią ją dostępną. Być może przykład to wyjaśni. Zobacz ten fragment kontenera:

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

W tym przypadku chcesz mieć odniesienie od elementu potomnego do kontenera nadrzędnego. Używając niestatycznej klasy zagnieżdżonej, działa to bez żadnej pracy. Można uzyskać dostęp do instancji kontenera za pomocą składni Container.this.

Więcej wyjaśnień hardcore:

Jeśli spojrzysz na Javę bajtowe kody generowane przez kompilator dla zagnieżdżonej klasy (niestatycznej) mogą stać się jeszcze bardziej przejrzyste:

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

Jak widać kompilator tworzy ukryte pole Container this$0. Jest to ustawione w konstruktorze, który ma dodatkowy parametr typu Container, aby określić instancję zamykającą. Nie widzisz tego parametru w źródle, ale kompilator domyślnie generuje go dla zagnieżdżonej klasy.

Przykład Martina

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

Byłoby więc skompilowane do wywołania czegoś takiego jak (w bytecodes)

new InnerClass(outerObject)

Dla kompletności:

Klasa anonimowa jest doskonałym przykładem niestatycznej klasy zagnieżdżonej, która po prostu nie ma nazwy powiązanej z nią i nie może być odwołana później.

Myślę, że żadna z powyższych odpowiedzi nie wyjaśnia Ci rzeczywistej różnicy między klasą zagnieżdżoną a klasą zagnieżdżoną statycznie w zakresie projektowania aplikacji:

Przegląd

Klasa zagnieżdżona może być niestatyczna lub statyczna i w każdym przypadku jest klasą zdefiniowaną w ramach innej klasy . Klasa zagnieżdżona powinna istnieć tylko do serve is enclosing class , jeśli Klasa zagnieżdżona jest użyteczna przez inne klasy( nie tylko enclosing), powinna być zadeklarowana jako najwyższy poziom klasy.

Różnica

Niestatyczna Klasa zagnieżdżona: jest domyślnie powiązana z zamykającą instancją klasy zawierającej, co oznacza, że możliwe jest wywołanie metod i dostępu do zmiennych tej instancji. Jednym z powszechnych zastosowań niestatycznej klasy zagnieżdżonej jest zdefiniowanie klasy adaptera.

Statyczna Klasa zagnieżdżona: nie może uzyskać dostępu do instancji klasy zamykającej i wywoływać na niej metody, więc powinna być używana, gdy Klasa zagnieżdżona nie wymaga dostępu do instancja klasy zamykającej . Powszechnym zastosowaniem klasy zagnieżdżonej statycznej jest implementacja elementów obiektu zewnętrznego.

Podsumowanie

Więc główna różnica między tymi dwoma z punktu widzenia projektu jest taka: nonstatic Klasa zagnieżdżona może uzyskać dostęp do instancji klasy kontenera, podczas gdy statyczna nie może .

W prostych słowach potrzebujemy klas zagnieżdżonych przede wszystkim dlatego, że Java nie zapewnia zamknięć.

Klasy zagnieżdżone są klasami zdefiniowanymi wewnątrz ciała innej klasy zamykającej. Są dwa typy-statyczne i niestatyczne.

Są one traktowane jako członkowie klasy enclosing, stąd można podać dowolny z czterech specyfikacji dostępu - private, package, protected, public. Nie mamy tego luksusu z klasami najwyższego poziomu, które można zadeklarować tylko public lub Pakietem-prywatnym.

Klasy wewnętrzne klasy bez stosu aka mają dostęp do innych członków najwyższej klasy, nawet jeśli są zadeklarowane jako prywatne, podczas gdy statyczne klasy zagnieżdżone nie mają dostępu do innych członków najwyższej klasy.

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

Inner1 jest naszą statyczną klasą wewnętrzną i {[7] } jest naszą klasą wewnętrzną, która nie jest statyczna. Zasadnicza różnica między nimi polega na tym, że nie można utworzyć instancji Inner2 bez zewnętrznej gdzie, ponieważ można utworzyć obiekt Inner1 niezależnie.

Kiedy użyłbyś Inner class?

Pomyśl o sytuacja, w której Class A i Class B są powiązane, Class B musi uzyskać dostęp do Class A członków, a Class B jest związana tylko z Class A. Wewnętrzne klasy wchodzą w obraz.

Aby utworzyć instancję klasy wewnętrznej, musisz utworzyć instancję klasy zewnętrznej.

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

Lub

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

Kiedy użyjesz statycznej klasy wewnętrznej?

Zdefiniowałbyś statyczną klasę wewnętrzną, gdy wiesz, że nie ma ona żadnego związku z instancją klasy / top klasy. Jeśli twoja klasa wewnętrzna nie używa metod lub pól klasy zewnętrznej, jest to po prostu strata miejsca, więc zrób to statycznie.

Na przykład, aby utworzyć obiekt dla statycznej klasy zagnieżdżonej, użyj składni:

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

Zaletą statycznej klasy zagnieżdżonej jest to, że nie potrzebuje ona do działania obiektu zawierającego klasę/top class. Może to pomóc w zmniejszeniu liczby obiektów, które aplikacja tworzy w czasie wykonywania.

Myślę, że konwencja, która jest ogólnie przestrzegana jest taka:

• klasa statyczna wewnątrz klasy najwyższego poziomu znajduje się Klasa zagnieżdżona
• klasa niestatyczna w obrębie klasy najwyższego poziomu jest klasa wewnętrzna , która dalej ma jeszcze dwie formy:
  • local class - klasy nazwane zadeklarowane wewnątrz bloku jak Metoda lub ciało konstruktora
  • klasa anonimowa - nienazwane klasy, których instancje są tworzone w wyrażeniach and statements

Jednak kilka innych punktów do zapamiętania to:

• Klasy najwyższego poziomu i statyczna Klasa zagnieżdżona są semantycznie takie same z tym wyjątkiem, że w przypadku statycznej klasy zagnieżdżonej może ona statycznie odwoływać się do prywatnych statycznych pól/metod swojej zewnętrznej [macierzystej] klasy i odwrotnie.

• Klasy wewnętrzne mają dostęp do zmiennych instancji zamykającej instancję zewnętrznej klasy [rodzica]. Jednak nie wszystkie klasy wewnętrzne mają zamykanie instancji, na przykład klas wewnętrznych w statycznych kontekstach, takich jak anonimowa Klasa używana w statycznym bloku inicjalizacji, nie robi tego.

• Klasa Anonymous domyślnie rozszerza klasę rodzica lub implementuje interfejs rodzica i nie ma dalszej klauzuli, która rozszerzyłaby jakąkolwiek inną klasę lub zaimplementowałaby więcej interfejsów. Więc

  • new YourClass(){}; oznacza class [Anonymous] extends YourClass {}
  • new YourInterface(){}; oznacza class [Anonymous] implements YourInterface {}

Czuję, że większe pytanie, które pozostaje otwarty, którego użyć i kiedy? Cóż, to zależy głównie od tego, z jakim scenariuszem masz do czynienia, ale czytanie odpowiedzi udzielonej przez @jrudolph może pomóc w podjęciu decyzji.

Oto kluczowe różnice i podobieństwa pomiędzy klasą wewnętrzną Javy a klasą zagnieżdżoną statycznie.

Klasa wewnętrzna

• może uzyskać dostęp do zewnętrznej klasy zarówno do instancji, jak i statycznych metod i pól

• W związku z instancją klasy zamkniętej, aby utworzyć instancję najpierw potrzebna jest instancja klasy zewnętrznej (Uwaga new miejsce ze słowem kluczowym):

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

• Nie można zdefiniować żadnego static members itself

• Cannot have Class or Interface declaration

Static zagnieżdżona klasa

• Nie można uzyskać dostępu do Klasa zewnętrzna instancja metody lub pola

• Nie jest powiązany z żadną instancją klasy , aby utworzyć jej instancję:

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

Podobieństwa

• obie wewnętrzne klasy mogą uzyskać dostęp nawet prywatny fields and methods of outer class
• również Klasa zewnętrzna ma dostęp do prywatnych pól i metod z klas wewnętrznych
• obie klasy mogą mieć modyfikator dostępu prywatnego, chronionego lub publicznego

Dlaczego Warto Używać Klas Zagnieżdżonych?

Zgodnie z dokumentacją Oracle istnieje kilka powodów ( pełna dokumentacja):

• Jest to sposób logicznego grupowania klas, które są tylko używane w jednym miejscu: jeśli klasa jest użyteczna tylko dla jednej innej klasy, to logiczne jest osadzenie jej w tej klasie i trzymanie jej razem. Zagnieżdżanie takich "klas pomocniczych" usprawnia ich pakiet.

• Zwiększa enkapsulację: rozważ dwie klasy najwyższego poziomu, A i B, gdzie B potrzebuje dostępu do członków a, które w przeciwnym razie byłyby uznane za prywatne. Ukrywając klasę B wewnątrz klasy a, członkowie A mogą zostać uznani za prywatne, A B może uzyskać do nich dostęp. W ponadto sam B może być ukryty przed światem zewnętrznym.

• Może to prowadzić do bardziej czytelnego i łatwego do utrzymania kodu: Zagnieżdżanie małych klas w klasach najwyższego poziomu umieszcza kod bliżej miejsca, w którym jest używany.

Klasa zagnieżdżona: Klasa wewnątrz klasy

Typy:

1. Static zagnieżdżona Klasa
2. Klasa Non-static zagnieżdżona [Klasa wewnętrzna]

Różnica:

Klasa Non-static zagnieżdżona [Klasa wewnętrzna]

In non-static nested class object of inner class exist within object of outer class. Tak, że element danych klasy zewnętrznej jest dostępny dla klasy wewnętrznej. Aby więc stworzyć obiekt klasy wewnętrznej musimy stworzyć obiekt klasy zewnętrznej najpierw.

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

Static nested class

W Statycznej zagnieżdżonej klasie obiekt klasy wewnętrznej nie potrzebuje obiektu klasy zewnętrznej, ponieważ słowo "static" wskazuje, że nie ma potrzeby tworzenia obiektu.

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

Jeśli chcesz uzyskać dostęp do x, napisz następującą metodę wewnątrz

  outerclass.nestedclass.x;  i.e. System.out.prinltn( outerclass.nestedclass.x);

Instancja klasy wewnętrznej jest tworzona, gdy jest tworzona instancja klasy zewnętrznej. Dlatego elementy i metody klasy wewnętrznej mają dostęp do elementów i metod instancji (obiektu) klasy zewnętrznej. Gdy instancja klasy zewnętrznej wykracza poza zakres, również instancje klasy wewnętrznej przestają istnieć.

Klasa zagnieżdżona statycznie nie ma konkretnej instancji. Jest po prostu ładowany, gdy jest używany po raz pierwszy (tak jak metody statyczne). To jest całkowicie niezależny obiekt, którego metody i zmienne nie mają dostępu do instancji klasy zewnętrznej.

Statyczne klasy zagnieżdżone nie są sprzężone z zewnętrznym obiektem, Są szybsze i nie pobierają pamięci sterty/stosu, ponieważ nie jest konieczne tworzenie instancji takiej klasy. Dlatego regułą jest próba zdefiniowania statycznej klasy zagnieżdżonej, o możliwie ograniczonym zakresie (private > = class > = protected > = public) , a następnie przekonwertowanie jej na klasę wewnętrzną (przez usunięcie" statycznego " identyfikatora) i poluzowanie zakresu, jeśli jest to naprawdę konieczne.

Istnieje subtelność użycia zagnieżdżonych klas statycznych, które mogą być przydatne w pewnych sytuacjach.

Podczas gdy atrybuty statyczne zostają utworzone zanim Klasa zostanie utworzona poprzez konstruktor, statyczne atrybuty wewnątrz zagnieżdżonych klas statycznych wydają się być tworzone dopiero po konstruktor klasy jest wywoływany, a przynajmniej dopiero po pierwszym odwołaniu się do atrybutów, nawet jeśli są oznaczone jako "ostateczne".

Rozważ to przykład:

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

Mimo że 'zagnieżdżone' i 'innerItem' są zadeklarowane jako 'static final'. the setting zagnieżdżone.innerItem odbywa się dopiero po utworzeniu instancji klasy (lub przynajmniej dopiero po pierwszym odwołaniu się do zagnieżdżonego elementu statycznego), jak widać na własne oczy komentując i nie komentując wersów, do których się odwołuję, powyżej. To samo nie trzyma prawdziwe dla "outerItem".

Przynajmniej to widzę w Javie 6.0.

W przypadku tworzenia instancji, instancja non statyczna Klasa wewnętrzna jest tworzona z odniesieniem do obiekt klasy zewnętrznej, w której jest zdefiniowany. To oznacza to, że ma including instancji. Ale instancja statycznej klasy wewnętrznej jest tworzony z odniesieniem do klasy zewnętrznej, a nie z odniesienie do obiektu klasy zewnętrznej. To oznacza, że nie zawierają instancji.

Na przykład:

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();
    A.B obj1 =o.new B();//need of inclosing instance

    A.C obj2 =new A.C();

    // not need of reference of object of outer class….
  }
}

Myślę, że nie ma tu wiele do dodania, większość odpowiedzi doskonale wyjaśnia różnice między statycznymi klasami zagnieżdżonymi a klasami wewnętrznymi. Rozważ jednak następujący problem podczas używania klas zagnieżdżonych vs klas wewnętrznych. Jak wspomniano w kilku odpowiedziach, wewnętrzne klasy nie mogą być utworzone bez I instancji ich klasy zamykającej, co oznacza, że trzymają Wskaźnik do instancji ich klasy zamykającej, co może prowadzić do przepełnienia pamięci lub przepełnienia stosu wyjątek ze względu na fakt, że GC nie będzie w stanie pobierać śmieci, nawet jeśli nie będą już używane. Aby to wyjaśnić, sprawdź następujący kod:

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

}

Jeśli usuniesz komentarz do // inner = null; program wystawi "jestem zniszczony !", ale utrzymanie tego komentarza nie będzie.
Powodem jest to, że biała wewnętrzna instancja jest nadal odwoływana, GC nie może jej zebrać, a ponieważ odwołuje się (ma wskaźnik do) do zewnętrznej instancji, której nie jest zbierana też. Mając wystarczająco dużo tych obiektów w projekcie i może zabraknąć pamięci.
W porównaniu ze statycznymi klasami wewnętrznymi, które nie posiadają punktu do wewnętrznej instancji klasy, ponieważ nie są związane z instancją, ale z klasą. Powyższy program może wydrukować "jestem zniszczony !" jeśli uczynisz klasę wewnętrzną statyczną i instancyjną z Outer.Inner i = new Outer.Inner();

Terminy są używane zamiennie. Jeśli chcesz być naprawdę pedantyczny, to możesz zdefiniować "klasę zagnieżdżoną", aby odnosić się do statycznej klasy wewnętrznej, która nie ma zamykającej się instancji. W kodzie możesz mieć coś takiego:

public class Outer {
    public class Inner {}

    public static class Nested {}
}

Klasa zagnieżdżona jest bardzo ogólnym terminem: każda klasa, która nie jest najwyższym poziomem, jest klasą zagnieżdżoną. Klasa wewnętrzna jest niestatyczną klasą zagnieżdżoną. Joseph Darcy napisał bardzo ładne Wyjaśnienie na temat klas zagnieżdżonych, wewnętrznych, członkowskich i najwyższego poziomu .

Hmmm... Klasa wewnętrzna jest klasą zagnieżdżoną... masz na myśli anonimową klasę i wewnętrzną klasę?

Edit: jeśli rzeczywiście chodziło Ci o wewnętrzne vs anonymous... Klasa wewnętrzna jest po prostu klasą zdefiniowaną w ramach klasy, takiej jak:

public class A {
    public class B {
    }
}

Podczas gdy Klasa anonimowa jest rozszerzeniem klasy zdefiniowanej anonimowo, więc żadna rzeczywista " klasa nie jest zdefiniowana, jak w:

public class A {
}

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

Dalsza Edycja:

Wikipedia twierdzi, że jest różnica w Javie, ale pracuję z Javą od 8 lat i po raz pierwszy usłyszałem takie wyróżnienie... nie wspominając, że nie ma tam żadnych odniesień, aby potwierdzić roszczenie... podsumowując, Klasa wewnętrzna jest klasą zdefiniowaną wewnątrz klasy (statyczną lub nie), a zagnieżdżona to kolejny termin oznaczający to samo.

Istnieje subtelna różnica pomiędzy klasą zagnieżdżoną statyczną i niestatyczną... zasadniczo niestatyczne klasy wewnętrzne mają niejawny dostęp do pól instancji i metod klasy zamykającej (dlatego nie mogą być skonstruowane w statyczny kontekst, będzie to błąd kompilatora). Z drugiej strony, klasy zagnieżdżone statycznie nie mają dostępu do pól instancji i metod i mogą być konstruowane w kontekście statycznym.

W tym celu należy skontaktować się z Działem Obsługi Klienta i skontaktować się z Działem Obsługi Klienta.]}

Klasy zagnieżdżone mogą być albo:
1. Klasy zagnieżdżone statyczne.
2. Niestatyczne klasy zagnieżdżone. (znany również jako Inner classes ) = > Proszę zapamiętać to

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

Specjalność klasy wewnętrznej:

• instancja klasy wewnętrznej ma dostęp do wszystkich członków klasy zewnętrznej, nawet tych, które są oznaczone jako "prywatne"

2.Statyczne Klasy Zagnieżdżone:
Przykład:

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

Case 1:Tworzenie instancji statycznej klasy zagnieżdżonej z klasy nie zamykającej

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

Przypadek 2:utworzenie instancji statycznej klasy zagnieżdżonej z klasy zamykającej

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

}

Specjalność klas statycznych:

• statyczna Klasa wewnętrzna będzie miała dostęp tylko do statycznych członków klasy zewnętrznej i nie będzie miała dostępu do niestatycznych członków.

Wniosek:
pytanie: Jaka jest główna różnica między klasą wewnętrzną a statyczna Klasa zagnieżdżona w Javie?
ODPOWIEDŹ: po prostu przejrzyj szczegóły każdej klasy wymienionej powyżej.

Klasa wewnętrzna i zagnieżdżona statyczna klasa w Javie obie są klasami zadeklarowanymi wewnątrz innej klasy, znanej jako klasa najwyższego poziomu w Javie. W terminologii Javy, jeśli zadeklarujesz zagnieżdżoną klasę statyczną, będzie ona nazywana zagnieżdżoną klasą statyczną w Javie, podczas gdy niestatyczne zagnieżdżone klasy są po prostu określane jako klasa wewnętrzna.

Czym jest klasa wewnętrzna w Javie?

Każda klasa, która nie jest najwyższym poziomem lub zadeklarowana wewnątrz innej klasy jest znana jako klasa zagnieżdżona i z tych klasy zagnieżdżone, klasy, które są deklarowane jako niestatyczne, są znane jako klasa wewnętrzna w Javie. w Javie istnieją trzy rodzaje klas wewnętrznych:

1) Local inner class-jest zadeklarowana wewnątrz bloku kodu lub metody.
2) Anonymous Inner class - jest klasą, która nie ma nazwy do odwołania i zainicjalizowana w tym samym miejscu, w którym zostanie utworzona.
3) Klasa wewnętrzna członka-jest deklarowana jako niestatyczna Klasa zewnętrzna.

public class InnerClassTest {
    public static void main(String args[]) {      
        //creating local inner class inside method i.e. 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");
        }
    }
}

Co jest zagnieżdżoną klasą statyczną w Java?

Zagnieżdżona Klasa statyczna jest inną klasą, która jest deklarowana wewnątrz klasy jako członek i staje się statyczna. Zagnieżdżona Klasa statyczna jest również zadeklarowana jako członek klasy zewnętrznej i może być prywatna, Publiczna lub chroniona, jak każdy inny członek. Jedną z głównych zalet zagnieżdżonej klasy statycznej nad klasą wewnętrzną jest to, że instancja zagnieżdżonej klasy statycznej nie jest dołączona do żadnej zamykającej się instancji klasy zewnętrznej. nie potrzebujesz również żadnej instancji zewnętrznej klasy, aby utworzyć instancję zagnieżdżoną Klasa statyczna w Javie .

1) może uzyskać dostęp do statycznych członków danych klasy zewnętrznej, w tym prywatnej.
2) statyczna Klasa zagnieżdżona nie może uzyskać dostępu do niestatycznego (instancji) elementu danych lub metody .

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

Ref: Klasa wewnętrzna i zagnieżdżona Klasa statyczna w Javie z przykładem

Myślę, że ludzie tutaj powinni zauważyć plakat, że: Klasa Static Nest tylko pierwsza klasa wewnętrzna. Na przykład:

 public static class A {} //ERROR

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

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

 }

Podsumowując, Klasa statyczna nie zależy od tego, która klasa jej zawiera. Więc nie mogą w normalnej klasie. (ponieważ normalna Klasa potrzebuje instancji).

Kiedy deklarujemy statyczną klasę member wewnątrz klasy, jest ona znana jako klasa zagnieżdżona najwyższego poziomu lub klasa zagnieżdżona statycznie. Można to wykazać jak poniżej:

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 A.y;
        }
    }
}

class TestDemo{
     public static void main(String[] args){
        Test t = new Test();
        System.out.println(Test.A.getZ());
        System.out.println(Test.B.getY());
    }
}

Kiedy deklarujemy niestatyczną klasę członkowską wewnątrz klasy, jest ona znana jako klasa wewnętrzna. Klasa wewnętrzna może być zademonstrowana jak poniżej:

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

Oto przykład static nested class i inner class:

Klasa zewnętrzna.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()); 

    }

}

Różnica polega na tym, że deklaracja klasy zagnieżdżonej, która jest również statyczna, może być utworzona poza klasą zamykającą.

Jeśli masz zagnieżdżoną deklarację klasy, która jest a nie statyczna, znana również jako Klasa wewnętrzna , Java nie pozwoli Ci utworzyć jej instancji, z wyjątkiem klasy zamkniętej. Obiekt utworzony z klasy wewnętrznej jest powiązany z obiektem utworzonym z klasy zewnętrznej, więc Klasa wewnętrzna może odwoływać się do pól zewnętrznej.

Ale jeśli to statyczne, wtedy link nie istnieje, zewnętrzne pola nie mogą być dostępne (z wyjątkiem zwykłego odniesienia, jak każdy inny obiekt) i dlatego można utworzyć instancję klasy zagnieżdżonej samodzielnie.

Po pierwsze nie ma takiej klasy zwanej klasą statyczną.Użycie modyfikatora statycznego z klasą wewnętrzną (nazywaną klasą zagnieżdżoną) mówi, że jest ona statycznym członkiem klasy zewnętrznej, co oznacza, że możemy uzyskać do niej dostęp tak jak do innych statycznych członków i bez posiadania żadnej instancji klasy zewnętrznej. (Co jest korzyścią ze statycznego oryginału.)

Różnica między klasą zagnieżdżoną a zwykłą klasą wewnętrzną wynosi:

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

Najpierw możemy utworzyć instancję klasy zewnętrznej, potem możemy uzyskać dostęp do wewnętrznej.

Ale jeśli klasa jest zagnieżdżona, to składnia jest następująca:

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

Który używa składni statycznej jako normalnej implementacji słowa kluczowego statycznego.

Zilustrowałem różne możliwe scenariusze poprawności i błędów, które mogą wystąpić w kodzie 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);
                        }*/
                    //}
                }
    }

Tylko kilka dodatków po przeczytaniu samouczka Javy oracle w klasach i obiektach. Może to pomóc, jeśli znasz model pamięci Javy dla klasy wewnętrznej i klasy zagnieżdżonej statycznie. Przeczytaj poniższe trzy pytania, aby poznać filozofię, dlaczego Klasa wewnętrzna i klasa statyczna są zaprojektowane przez Javę w ten sposób. Wtedy możesz wiedzieć, kiedy użyć klasy wewnętrznej, a kiedy statycznej klasy zagnieżdżonej.

Jak wewnętrzny obiekt klasy rezyduje w pamięci?

Pamięć management-wewnętrzna Klasa statyczna w Javie

Kiedy statyczna Klasa zagnieżdżona (i jej statyczne elementy) są ładowane do pamięci?

Następnie przeczytaj to, aby porównać wewnętrzną klasę i statyczną klasę zagnieżdżoną.

Jaka jest zaleta tworzenia klasy wewnętrznej jako statycznej w Javie?