Frage Java innere Klasse und statische geschachtelte Klasse


Was ist der Hauptunterschied zwischen einer inneren Klasse und einer statischen geschachtelten Klasse in Java? Spielt Design / Implementierung eine Rolle bei der Auswahl eines davon?


1464
2017-09-16 08:22


Ursprung


Antworten:


Von dem Java-Tutorial:

Geschachtelte Klassen sind in zwei Kategorien unterteilt: statische und nicht statische. Geschachtelte Klassen, die als statisch deklariert sind, werden einfach als statische verschachtelte Klassen bezeichnet. Nicht statische geschachtelte Klassen heißen innere Klassen.

Auf statische verschachtelte Klassen wird über den einschließenden Klassennamen zugegriffen:

OuterClass.StaticNestedClass

Um beispielsweise ein Objekt für die statische geschachtelte Klasse zu erstellen, verwenden Sie folgende Syntax:

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

Objekte, die Instanzen einer inneren Klasse sind, existieren innerhalb einer Instanz der äußeren Klasse. Betrachten Sie die folgenden Klassen:

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

Eine Instanz von InnerClass kann nur innerhalb einer Instanz von OuterClass existieren und hat direkten Zugriff auf die Methoden und Felder ihrer einschließenden Instanz.

Um eine innere Klasse zu instanziieren, müssen Sie zuerst die äußere Klasse instanziieren. Dann erstellen Sie das innere Objekt innerhalb des äußeren Objekts mit dieser Syntax:

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

sehen: Java Tutorial - Verschachtelte Klassen

Zur Vollständigkeit beachte, dass es auch so etwas wie ein innere Klasse ohne eine einschließende Instanz:

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

Hier, new A() { ... } ist ein innere Klasse definiert in einem statischen Kontext und hat keine einschließende Instanz.


1480
2017-09-16 08:28



Das Java-Tutorial sagt:

Terminologie: Verschachtelte Klassen sind   unterteilt in zwei Kategorien: statisch   und nicht-statisch. Geschachtelte Klassen, die   Static deklariert werden einfach aufgerufen   Statisch geschachtelte Klassen. Nicht statisch   Verschachtelte Klassen heißen inner   Klassen.

Im allgemeinen Sprachgebrauch werden die Begriffe "verschachtelt" und "innen" von den meisten Programmierern austauschbar verwendet, aber ich verwende den korrekten Begriff "verschachtelte Klasse", der sowohl die innere als auch die statische Klasse abdeckt.

Klassen können verschachtelt werden Ad infinitum, z.B. Klasse A kann Klasse B enthalten, die Klasse C enthält, die Klasse D usw. enthält. Jedoch ist mehr als eine Ebene der Klassenverschachtelung selten, da sie im allgemeinen schlecht gestaltet ist.

Es gibt drei Gründe, warum Sie eine geschachtelte Klasse erstellen könnten:

  • Organisation: Manchmal scheint es am sinnvollsten, eine Klasse in den Namespace einer anderen Klasse zu sortieren, besonders wenn sie in keinem anderen Kontext verwendet wird
  • access: geschachtelte Klassen haben speziellen Zugriff auf die Variablen / Felder ihrer enthaltenden Klassen (genau welche Variablen / Felder von der Art der geschachtelten Klasse abhängen, ob innerlich oder statisch).
  • Bequemlichkeit: Eine neue Datei für jeden neuen Typ erstellen zu müssen, ist wiederum lästig, besonders wenn der Typ nur in einem Kontext verwendet wird

Es gibt vier Arten von geschachtelten Klassen in Java. In Kürze sind sie:

  • statische Klasse: als statisches Mitglied einer anderen Klasse deklariert
  • innere Klasse: als Instanzenmitglied einer anderen Klasse deklariert
  • lokale innere Klasse: Innerhalb einer Instanzmethode einer anderen Klasse deklariert
  • anonyme innere Klasse: Wie eine lokale innere Klasse, aber als ein Ausdruck geschrieben, der ein einmaliges Objekt zurückgibt

Lassen Sie mich näher darauf eingehen.


Statische Klassen

Statische Klassen sind am einfachsten zu verstehen, da sie nichts mit Instanzen der enthaltenden Klasse zu tun haben.

Eine statische Klasse ist eine Klasse, die als statisches Mitglied einer anderen Klasse deklariert ist. Genau wie andere statische Member ist eine solche Klasse wirklich nur ein Aufhänger, der die enthaltene Klasse als Namespace verwendet. z.B. die Klasse Ziege als statisches Mitglied der Klasse deklariert Nashorn im Paket Pizza ist unter dem Namen bekannt Pizza.Rhino.Goat.

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

Offen gesagt, statische Klassen sind ein ziemlich wertloses Feature, da Klassen bereits in Pakete unterteilt sind. Der einzig wirklich denkbare Grund, eine statische Klasse zu erstellen, besteht darin, dass eine solche Klasse Zugriff auf die privaten statischen Member ihrer enthaltenden Klasse hat, aber ich finde, dass dies eine ziemlich lahme Begründung für das Vorhandensein der statischen Klassenfunktion ist.


Innere Klassen

Eine innere Klasse ist eine Klasse, die als nicht-statisches Mitglied einer anderen Klasse deklariert ist:

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

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

Wie bei einer statischen Klasse ist die innere Klasse als durch ihren Klassennamen qualifiziert bekannt. Pizza.Rhino.Goat, aber innerhalb der enthaltenden Klasse kann es durch seinen einfachen Namen bekannt sein. Jede Instanz einer inneren Klasse ist jedoch an eine bestimmte Instanz ihrer enthaltenden Klasse gebunden: oben Ziege erstellt in jerry, ist implizit an die Nashorn Beispiel Dies im jerry. Ansonsten machen wir das verbunden Nashorn Instanz explizit, wenn wir instanziieren Ziege:

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

(Beachten Sie, dass Sie sich auf den inneren Typ als gerecht beziehen Ziege im komischen Neu Syntax: Java leitet den enthaltenden Typ von der Nashorn Teil. Und ja neues rhino.Goat () hätte mir auch mehr Sinn gemacht.)

Was bringt uns das? Nun, die innere Klasseninstanz hat Zugriff auf die Instanzmitglieder der enthaltenden Klasseninstanz. Auf diese umschließenden Instanzenmitglieder wird innerhalb der inneren Klasse verwiesen über nur ihre einfachen Namen, nicht über  Dies (Dies in der inneren Klasse bezieht sich auf die innere Klasseninstanz, nicht die zugehörige enthaltende Klasseninstanz):

public class Rhino {

    private String barry;

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

In der inneren Klasse können Sie sich darauf beziehen Dies der enthaltenden Klasse als Rhinound du kannst es benutzen Dies sich auf seine Mitglieder beziehen, z.B. Rhino.this.barry.


Lokale innere Klassen

Eine lokale innere Klasse ist eine Klasse, die im Hauptteil einer Methode deklariert ist. Eine solche Klasse ist nur innerhalb ihrer containing-Methode bekannt, sodass sie nur instanziiert werden kann und auf ihre Member innerhalb ihrer containing-Methode zugegriffen werden kann. Die Verstärkung besteht darin, dass eine lokale innere Klasseninstanz mit den letzten lokalen Variablen ihrer enthaltenden Methode verknüpft ist und auf diese zugreifen kann. Wenn die Instanz eine letzte lokale Methode ihrer containing-Methode verwendet, behält die Variable den Wert bei, den sie zum Zeitpunkt der Erstellung der Instanz beibehielt, selbst wenn die Variable den Gültigkeitsbereich verlassen hat (dies ist tatsächlich die primitive, eingeschränkte Version von Closures von Java).

Da eine lokale innere Klasse weder Mitglied einer Klasse noch eines Pakets ist, wird sie nicht mit einer Zugriffsebene deklariert. (Seien Sie jedoch klar, dass die eigenen Mitglieder Zugriffsebenen wie in einer normalen Klasse haben.)

Wenn eine lokale innere Klasse in einer Instanzmethode deklariert ist, ist eine Instanziierung der inneren Klasse an die Instanz gebunden, die von der Methode der enthaltenden Methode gehalten wird Dies zum Zeitpunkt der Erzeugung der Instanz, und so sind die Instanzmitglieder der enthaltenden Klasse wie in einer Instanz der inneren Klasse zugänglich. Eine lokale innere Klasse wird einfach instanziiert über seinen Namen, z.B. lokale innere Klasse Katze wird instanziiert als neue Katze (), nicht neu this.Cat (), wie Sie vielleicht erwarten.


Anonyme innere Klassen

Eine anonyme innere Klasse ist eine syntaktisch bequeme Art, eine lokale innere Klasse zu schreiben. In den meisten Fällen wird eine lokale innere Klasse höchstens einmal jedes Mal instanziiert, wenn ihre containing-Methode ausgeführt wird. Es wäre also schön, wenn wir die lokale innere Klassendefinition und ihre einzelne Instanziierung in einer bequemen Syntaxform kombinieren könnten, und es wäre auch schön, wenn wir uns keinen Namen für die Klasse ausdenken müssten (umso weniger hilfreich Namen, die Ihr Code enthält, desto besser). Eine anonyme innere Klasse erlaubt beides:

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

Dies ist ein Ausdruck, der eine neue Instanz einer unbenannten Klasse zurückgibt, die sich erweitert ParentClassName. Sie können keinen eigenen Konstruktor angeben. vielmehr wird implizit einer geliefert, der einfach den Superkonstruktor aufruft, also müssen die gelieferten Argumente zum Superkonstruktor passen. (Wenn der Elternteil mehrere Konstruktoren enthält, wird der "einfachste" als "einfachste" bezeichnet, wie durch ein ziemlich komplexes Regelwerk bestimmt, das nicht im Detail zu lernen lohnt - achten Sie nur darauf, was NetBeans oder Eclipse Ihnen sagen.)

Alternativ können Sie eine zu implementierende Schnittstelle angeben:

new *InterfaceName*() {*members*}

Eine solche Deklaration erstellt eine neue Instanz einer unbenannten Klasse, die Object und implementiert erweitert Schnittstellenname. Auch hier können Sie keinen eigenen Konstruktor angeben. In diesem Fall liefert Java implizit einen Konstruktor "no-arg, do-nothing" (daher gibt es in diesem Fall niemals Konstruktorargumente).

Obwohl Sie einer anonymen inneren Klasse keinen Konstruktor geben können, können Sie dennoch beliebige Setups verwenden, indem Sie einen Initialisierungsblock (einen {} -Block außerhalb einer beliebigen Methode) verwenden.

Machen Sie sich klar, dass eine anonyme innere Klasse einfach eine weniger flexible Möglichkeit ist, eine lokale innere Klasse mit einer Instanz zu erstellen. Wenn Sie eine lokale innere Klasse möchten, die mehrere Schnittstellen implementiert oder Schnittstellen implementiert, während Sie eine andere Klasse erweitern als Objekt Oder wenn Sie einen eigenen Konstruktor angeben, müssen Sie eine normale benannte lokale innere Klasse erstellen.


524
2017-09-16 09:24



Ich glaube nicht, dass der wirkliche Unterschied in den obigen Antworten deutlich wurde.

Um die Bedingungen richtig zu machen:

  • Eine geschachtelte Klasse ist eine Klasse, die in einer anderen Klasse auf Quellcodeebene enthalten ist.
  • Es ist statisch, wenn Sie es mit der Deklaration deklarieren statisch Modifikator.
  • Eine nicht statische geschachtelte Klasse wird innere Klasse genannt. (Ich bleibe bei der nicht statischen geschachtelten Klasse.)

Martins Antwort ist soweit richtig. Die eigentliche Frage lautet jedoch: Was ist der Zweck, eine verschachtelte Klasse für statisch zu deklarieren oder nicht?

Sie nutzen Statisch geschachtelte Klassen Wenn Sie Ihre Klassen nur zusammenhalten möchten, wenn sie thematisch zusammen gehören oder wenn die verschachtelte Klasse ausschließlich in der einschließenden Klasse verwendet wird. Es gibt keinen semantischen Unterschied zwischen einer statischen verschachtelten Klasse und jeder anderen Klasse.

Nicht statische geschachtelte Klassen sind ein anderes Tier. Ähnlich wie anonyme innere Klassen sind solche verschachtelten Klassen tatsächlich Closures. Das bedeutet, dass sie ihren umgebenden Bereich und ihre umschließende Instanz erfassen und zugänglich machen. Vielleicht wird ein Beispiel das klären. Sieh diesen Stummel eines Containers:

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

In diesem Fall möchten Sie einen Verweis von einem untergeordneten Element auf den übergeordneten Container haben. Mit einer nicht statischen geschachtelten Klasse funktioniert dies ohne etwas Arbeit. Sie können auf die umschließende Instanz von Container mit der Syntax zugreifen Container.this.

Weitere Hardcore-Erklärungen folgen:

Wenn Sie sich die Java-Bytecodes anschauen, die der Compiler für eine (nicht-statische) verschachtelte Klasse generiert, könnte es noch deutlicher werden:

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

Wie Sie sehen können, erstellt der Compiler ein verstecktes Feld Container this$0. Dies wird im Konstruktor festgelegt, der über einen zusätzlichen Parameter vom Typ Container verfügt, um die umschließende Instanz anzugeben. Sie können diesen Parameter nicht in der Quelle anzeigen, aber der Compiler generiert ihn implizit für eine verschachtelte Klasse.

Martins Beispiel

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

würde also zu einem Aufruf von etwas wie (in Bytecodes) kompiliert werden

new InnerClass(outerObject)

Der Vollständigkeit halber:

Eine anonyme Klasse ist ein perfektes Beispiel für eine nicht-statische geschachtelte Klasse, der kein Name zugeordnet ist und auf die später nicht mehr verwiesen werden kann.


124
2017-09-16 09:12



Ich denke, dass keine der obigen Antworten Ihnen den wahren Unterschied zwischen einer geschachtelten Klasse und einer statischen geschachtelten Klasse im Hinblick auf das Anwendungsdesign erklärt:

Überblick

Eine geschachtelte Klasse könnte nichtstatisch oder statisch sein und in jedem Fall ist eine Klasse, die in einer anderen Klasse definiert ist. Eine verschachtelte Klasse sollte nur existieren, um zu dienen, umschließende KlasseWenn eine verschachtelte Klasse für andere Klassen (nicht nur für das Einschließen) nützlich ist, sollte sie als eine Klasse auf oberster Ebene deklariert werden.

Unterschied

Nicht verschachtelte Klasse : ist implizit der einschließenden Instanz der enthaltenden Klasse zugeordnet, dh es können Methoden aufgerufen und auf Variablen der umgebenden Instanz zugegriffen werden. Eine übliche Verwendung einer nicht-statischen verschachtelten Klasse besteht darin, eine Adapter-Klasse zu definieren.

Statisch geschachtelte Klasse : kann nicht auf umschließende Klasseninstanzen zugreifen und Methoden darauf aufrufen, sollte also verwendet werden, wenn die verschachtelte Klasse keinen Zugriff auf eine Instanz der einschließenden Klasse benötigt. Eine allgemeine Verwendung der statischen verschachtelten Klasse besteht darin, eine Komponente des äußeren Objekts zu implementieren.

Fazit

Der Hauptunterschied zwischen den beiden ist vom Design her gesehen: Nichtstatische geschachtelte Klasse kann auf Instanz der Containerklasse zugreifen, während statisch nicht möglich ist.


82
2018-05-27 07:43



Vereinfacht ausgedrückt benötigen wir verschachtelte Klassen, da Java keine Closures bereitstellt.

Verschachtelte Klassen sind Klassen, die im Rumpf einer anderen einschließenden Klasse definiert sind. Sie sind von zwei Arten - statisch und nicht-statisch.

Sie werden als Mitglieder der umschließenden Klasse behandelt. Daher können Sie einen der vier Zugriffsbezeichner angeben - private, package, protected, public. Diesen Luxus haben wir nicht mit erstklassigen Klassen, die nur deklariert werden können public oder Paket-privat.

Innere Klassen, auch Nicht-Stapelklassen, haben Zugriff auf andere Mitglieder der obersten Klasse, selbst wenn sie als privat deklariert sind. Statische verschachtelte Klassen haben keinen Zugriff auf andere Mitglieder der obersten Klasse.

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

Inner1 ist unsere statische innere Klasse und Inner2 ist unsere innere Klasse, die nicht statisch ist. Der Hauptunterschied zwischen ihnen, Sie können nicht erstellen Inner2 Instanz ohne eine äußere, wo Sie eine erstellen können Inner1 Objekt unabhängig.

Wann würdest du den inneren Unterricht benutzen?

Denken Sie an eine Situation, in der Class A und Class B sind verwandt, Class B muss zugreifen Class A Mitglieder und Class B bezieht sich nur auf Class A. Innere Klassen kommen ins Spiel.

Um eine Instanz der inneren Klasse zu erstellen, müssen Sie eine Instanz Ihrer äußeren Klasse erstellen.

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

oder

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

Wann würdest du statische innere Klasse benutzen?

Sie würden eine statische innere Klasse definieren, wenn Sie wissen, dass sie keine Beziehung zur Instanz der umschließenden Klasse / obersten Klasse hat. Wenn Ihre innere Klasse keine Methoden oder Felder der äußeren Klasse verwendet, ist es nur eine Verschwendung von Speicherplatz, also machen Sie es statisch.

Um beispielsweise ein Objekt für die statische geschachtelte Klasse zu erstellen, verwenden Sie folgende Syntax:

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

Der Vorteil einer statischen geschachtelten Klasse ist, dass sie kein Objekt der enthaltenden Klasse / Top-Klasse benötigt. Dadurch können Sie die Anzahl der Objekte reduzieren, die Ihre Anwendung zur Laufzeit erstellt.


30
2017-10-17 22:35



Ich denke, die Konvention, die allgemein befolgt wird, ist diese:

  • statische Klasse innerhalb einer Top-Level-Klasse ist a geschachtelte Klasse
  • nicht statische Klasse innerhalb einer Top-Level-Klasse ist a innere Klasse, welche weiter hat zwei weitere Formen:
    • lokale Klasse - benannte Klassen, die innerhalb eines Blocks wie eine Methode oder ein Konstruktorkörper deklariert sind
    • anonyme Klasse - unbenannte Klassen, deren Instanzen in Ausdrücken und Anweisungen erstellt werden

Allerdings nur wenige andere Punkte zum Erinnern sind:

  • Top-Level-Klassen und statische geschachtelte Klassen sind semantisch gleich, außer dass sie im Fall einer statischen geschachtelten Klasse einen statischen Verweis auf private statische Felder / Methoden ihrer Outer-Klasse [übergeordnet] und umgekehrt bereitstellen können.

  • Innere Klassen haben Zugriff auf Instanzvariablen der einschließenden Instanz der Outer [parent] -Klasse. Nicht alle inneren Klassen haben jedoch umschließende Instanzen, zum Beispiel innere Klassen in statischen Kontexten, wie eine anonyme Klasse, die in einem statischen Initialisierungsblock verwendet wird, nicht.

  • Die anonyme Klasse erweitert standardmäßig die übergeordnete Klasse oder implementiert die übergeordnete Schnittstelle, und es gibt keine weitere Klausel, um eine andere Klasse zu erweitern oder weitere Schnittstellen zu implementieren. Damit,

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

Ich fühle, dass die größere Frage offen bleibt, welche zu verwenden ist und wann? Nun, das hängt hauptsächlich davon ab, mit welchem ​​Szenario du es zu tun hast, aber die Antwort von @jrudolph zu lesen kann dir helfen, eine Entscheidung zu treffen.


24
2017-12-16 11:38



Hier sind die wichtigsten Unterschiede und Ähnlichkeiten zwischen der Java-internen Klasse und der statischen geschachtelten Klasse.

Ich hoffe es hilft!

Innere Klasse

  • Kann Zugreifen zur äußeren Klasse sowohl Instanz als auch statisch Methoden und Felder
  • Assoziiert mit der Instanz der umschließenden Klasse um es zu instanziieren, braucht es zuerst eine Instanz der äußeren Klasse (Anmerkung Neu Stichwort Ort):

    Outerclass.InnerClass innerObject = outerObject.new Innerclass();
    
  • Kann nicht irgendeinen definieren statische Mitglieder selbst

  • Kann nicht haben Klasse oder Schnittstelle Erklärung

Statisch geschachtelte Klasse

  • Habe keinen Zugriff äußere Klasse Beispiel Methoden oder Felder

  • Nicht mit einer Instanz der umschließenden Klasse verknüpft Also um es zu instanziieren:

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

Ähnlichkeiten

  • Beide Innere Klassen kann sogar zugreifen private Felder und Methoden von äußere Klasse
  • Auch der Äußere Klasse Zugang haben zu private Felder und Methoden von innere Klassen
  • Beide Klassen können einen privaten, geschützten oder öffentlichen Zugriffsmodifikator haben

Warum verschachtelte Klassen verwenden?

Laut Oracle-Dokumentation gibt es mehrere Gründe (vollständige Dokumentation):

  • Es ist eine Möglichkeit, Klassen logisch zu gruppieren, die nur an einer Stelle verwendet werden: Wenn eine Klasse nur für eine andere Klasse nützlich ist, ist es logisch, sie in diese Klasse einzubetten und sie zusammen zu halten. Die Verschachtelung solcher "Hilfsklassen" macht ihr Paket schlanker.

  • Es erhöht die Kapselung: Betrachten Sie zwei Klassen der obersten Ebene, A und B, wo B Zugriff auf Mitglieder von A benötigt, die andernfalls als privat deklariert würden. Durch das Verstecken der Klasse B innerhalb der Klasse A können die Mitglieder von A als privat deklariert werden und B kann auf sie zugreifen. Außerdem kann B selbst vor der Außenwelt verborgen sein.

  • Es kann zu besser lesbarem und wartbarem Code führen: Durch das Verschachteln kleiner Klassen innerhalb von Klassen der obersten Ebene wird der Code näher an den Ort der Verwendung gebracht.


23
2017-12-31 20:53



Geschachtelte Klasse: Klasse innerhalb der Klasse

Typen:

  1. Statisch geschachtelte Klasse
  2. Nicht-statische geschachtelte Klasse [Innere Klasse]

Unterschied:

Nicht-statische geschachtelte Klasse [Innere Klasse]

In nicht statischen geschachtelten Klassen existiert das Objekt der inneren Klasse innerhalb des Objekts der äußeren Klasse. Damit ist das Datenelement der äußeren Klasse für die innere Klasse zugänglich. Um ein Objekt der inneren Klasse zu erzeugen, müssen wir zuerst das Objekt der äußeren Klasse erzeugen.

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

Statisch geschachtelte Klasse

Im statischen geschachtelten Klassenobjekt der inneren Klasse wird kein Objekt der äußeren Klasse benötigt, weil das Wort "statisch" anzeigt, dass kein Objekt erzeugt werden muss.

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

Wenn Sie auf x zugreifen möchten, schreiben Sie die folgende interne Methode

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

13
2018-04-04 10:14