Innere Java-Klasse und statisch verschachtelte Klasse

https://stackoverflow.com/questions/70324

09-06-2019
|

Frage

Was ist der Hauptunterschied zwischen einer inneren Klasse und einer statisch verschachtelten Klasse in Java?Spielt Design/Implementierung eine Rolle bei der Auswahl?

Lösung

Von den Java Tutorial :

Verschachtelte Klassen sind in zwei Kategorien unterteilt: statisch und nicht statisch. Verschachtelte Klassen, die statisch deklariert werden einfach statische verschachtelte Klassen genannt. Nicht-statische verschachtelte Klassen sind innere Klassen genannt.

Statische verschachtelte Klassen zugegriffen wird die einschließende Klassennamen:

OuterClass.StaticNestedClass

Zum Beispiel, ein Objekt für die statische verschachtelte Klasse zu erstellen, verwenden Sie die folgende Syntax:

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

Objekte, die Instanzen einer inneren Klasse sind vorhanden 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 existiert und direkten Zugang zu den Methoden hat und Feldern seiner umschließenden Instanz.

Um eine innere Klasse zu instanziiert, müssen Sie zuerst die äußeren Klasse instanziiert. Erstellen Sie dann das innere Objekt innerhalb des äußeren Objekts mit dieser Syntax:

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

siehe: Java Tutorial - Verschachtelte Klassen

Für Vollständigkeit beachten, dass es auch so etwas wie eine innere Klasse ohne eine umgebende Instanz :

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

Hier new A() { ... } ist eine innere Klasse in einem statischen Kontext definiert und keine umschließenden Instanz hat.

Andere Tipps

Das Java Tutorial sagt :

Terminologie: Verschachtelte Klassen sind in zwei Kategorien unterteilt: static und nicht-statisch. Verschachtelte Klassen, deklariert statische einfach aufgerufen werden statische verschachtelte Klassen. Nicht-statische verschachtelte Klassen werden als innere Klassen.

Im allgemeinen Sprachgebrauch werden die Begriffe „verschachtelt“ und „inneren“ austauschbar verwendet werden, indem die meisten Programmierer, aber ich werde den richtigen Begriff „verschachtelte Klasse“ verwendet werden, die sowohl innere als auch statische abdeckt.

Klassen verschachtelt werden können ad infinitum , z.B. Klasse A Klasse B kann enthalten, die Klasse C enthält, die Klasse D enthält usw. kann jedoch mehr als eine Ebene der Klasse Verschachtelung ist selten, da es in der Regel schlechtes Design ist.

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

Organisation: Manchmal scheint es am sinnvollsten, eine Klasse in den Namensraum einer anderen Klasse zu sortieren, vor allem, wenn es nicht in jedem anderen Kontext verwendet wird
Zugriff. Verschachtelte Klassen haben spezielle Zugriff auf die Variablen / Felder ihrer enthält Klassen (genau welche Variablen / Felder hängt von der Art der geschachtelten Klasse, ob innere oder statisch)
Komfort: eine neue Datei für jeden neuen Typen erstellen zu müssen ist störend empfunden wird, wieder, vor allem, wenn der Typ in einem Kontext nur dann verwendet werden

Es gibt vier Arten von geschachtelten Klasse in Java . Kurz gesagt, sie sind:

statische Klasse : als statisches Mitglied einer anderen Klasse deklariert
innere Klasse : als Instanz Mitglied einer anderen Klasse deklariert
lokale innere Klasse : innerhalb einer Instanzmethode einer anderen Klasse deklariert
anonyme innere Klasse : wie eine lokale innere Klasse, sondern als Ausdruck geschrieben, die ein einmaliges Objekt

Lassen Sie mich mehr Details erarbeiten in.

Statische Klassen

Statische Klassen sind die einfachste Art zu verstehen, weil sie nichts mit Instanzen der enthaltenden Klasse zu tun.

Eine statische Klasse ist eine Klasse als statisches Mitglied einer anderen Klasse deklariert. Genau wie andere statische Elemente, wie eine Klasse ist wirklich nur ein Aufhänger auf, dass nutzt die enthaltende Klasse als Namespace zB die Klasse Ziege als statisches Member der Klasse deklariert < em> Rhino im Paket Pizza ist bekannt unter dem Namen pizza.Rhino.Goat .

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

Ehrlich gesagt, statische Klassen sind ein ziemlich wertlos Feature, da Klassen bereits in Namespaces durch Pakete unterteilt sind. Der einzige wirkliche denkbare Grund eine statische Klasse zu erstellen ist, dass ein solche Klasse Zugriff auf die darin enthaltenen Klasse private static Mitglieder hat, aber ich finde dies eine ziemlich lahme Rechtfertigung für das statische Klasse Feature sein zu existieren.

Innere Klassen

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

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

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

Wie bei einer statischen Klasse ist die innere Klasse bekannt, wie durch die darin enthaltenen Klassennamen qualifiziert, pizza.Rhino.Goat , aber innerhalb der enthaltenden Klasse, kann er durch seinen einfachen Namen bekannt sein. Jedoch wird jede Instanz einer inneren Klasse auf eine bestimmte Instanz der umschließenden Klasse gebunden: oben, die Ziege erstellt in Jerry , wird implizit gebunden an den Rhino Instanz diese in Jerry . Ansonsten machen wir das zugehörige Rhino Instanz explizit, wenn wir instanziiert Ziege :

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

(Beachten Sie die innere Art beziehen sich nur Ziege in der seltsam neue Syntax: Java folgert die enthält Typ aus dem rhino Teil Und., ja neue rhino.Goat () wäre zu mehr Sinn für mich.)

Was hat das mit uns gewinnen? Nun, die innere Klasseninstanz hat Zugriff auf die Instanz Mitglieder des enthaltening Klasseninstanz. Diese umschließen Instanzelemente innerhalb der inneren Klasse bezeichnet über nur auf die Namen, nicht über diese ( diese in der inneren Klasse auf die innere Klasseninstanz bezieht, nicht der zugehörige enthält Klasseninstanz):

public class Rhino {

    private String barry;

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

In der inneren Klasse können Sie auf beziehen sich diese der enthaltenden Klasse als Rhino.this , und Sie können mit das beziehen an seine Mitglieder, eg Rhino.this.barry .

Lokale innere Klassen

Eine lokale innere Klasse ist eine Klasse, in dem Körper eines Verfahrens erklärt. Eine solche Klasse wird innerhalb seiner enthaltenden Methode nur bekannt ist, so kann sie nur instanziiert werden und haben ihre Mitglieder innerhalb seiner enthaltenden Methode zugegriffen. Die Verstärkung ist, dass eine lokale innere Klasseninstanz ist gebunden an und die endgültigen lokalen Variablen des umschließenden Verfahrens zugreifen kann. Wenn die Instanz eine endgültige lokal seiner enthält Methode verwendet, behält die Variable den Wert, den es zum Zeitpunkt der Instanz Schöpfung gehalten, auch wenn die Variable des Gültigkeitsbereiches gegangen (das ist effektiv Java roh, eingeschränkte Version von Schließungen).

Da eine lokale innere Klasse ist weder Mitglied einer Klasse oder das Paket, ist es nicht mit einer Zugriffsebene deklariert. (Seien Sie jedoch klar, dass ihre eigenen Mitglieder Zugriffsebene wie in einer normalen Klasse.)

Wenn eine lokale innere Klasse in einer Instanzmethode deklariert wird, eine Instanziierung der inneren Klasse gehalten an der Instanz gebunden durch die enthaltende Methode der das zum Zeitpunkt der Erstellung der Instanz, und so des enthaltenden Klasse Instanzmitglieder zugänglich sind wie in einer Instanz inneren Klasse. Eine lokale innere Klasse instanziiert einfach über seinen Namen, zB lokale innere Klasse Katze instanziiert als neue Cat () nicht neu this.Cat () wie man erwarten könnte.

Anonyme innere Klassen

Eine anonyme innere Klasse ist eine syntaktisch bequeme Möglichkeit, eine lokale innere Klasse zu schreiben. Am häufigsten wird eine lokale innere Klasse ist höchstens instanziiert nur einmal jedes Mal der darin enthaltenen Verfahren ausgeführt werden. Es wäre schön, dann, wenn wir die lokale innere Klassendefinition und seine einzige Instantiierung in eine bequemen Syntax Form kombinieren könnten, und es wäre auch schön, wenn wir nicht auf einen Namen für die Klasse zu denken haben (das weniger nicht hilfreich Name Code enthält, desto besser). Eine anonyme innere Klasse erlaubt es, diese beiden Dinge:

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

Dies ist ein Ausdruck eine neue Instanz einer ungenannten Klasse zurückkehren, die sich ParentClassName . Sie können Ihren eigenen Konstruktor nicht liefern; vielmehr wird man implizit geliefert, die einfach den Super Konstruktor ruft, so lieferten die Argumente der Super-Konstruktor passen muss. (Wenn die Eltern mehrere Konstruktoren enthält, die „einfachste“ one genannt wird, „einfachste“, wie er durch eine ziemlich komplexes Regelwerk bestimmt nicht der Mühe wert im Detail zu lernen -. Zahlen nur die Aufmerksamkeit auf das, was NetBeans oder Eclipse Ihnen sagen)

Alternativ können Sie auch eine Schnittstelle angeben zu implementieren:

new *InterfaceName*() {*members*}

Eine solche Erklärung erstellt eine neue Instanz eines ungenannten Klasse, die Objekt- und Arbeitsgeräte Interface erstreckt. Auch hier können Sie nicht Ihren eigenen Konstruktor übergeben werden; in diesem Fall liefert Java implizit ein no-arg, do-nothing-Konstruktor (so wird es nie Konstruktorargumente in diesem Fall sein).

Auch wenn Sie nicht eine anonyme innere Klasse einen Konstruktor geben kann, können Sie nach wie vor jede Einrichtung Sie einen Initialisierungsblocks möchten, mit (a {} Block außerhalb jeder Methode platziert).

Seien Sie klar, dass eine anonyme innere Klasse ist einfach eine weniger flexible Art und Weise eine lokale innere Klasse mit einer Instanz zu schaffen. Wenn Sie eine lokale innere Klasse, die mehrere Schnittstellen implementiert oder die Schnittstellen implementiert, während eine Klasse andere als Verlängerung Object oder die ihren eigenen Konstruktor gibt, sind Sie eine regelmäßige stecken Schaffung namens lokaleninnere Klasse.

Das glaube ich nicht der wirkliche Unterschied in den oben genannten Antworten klar wurde.

Sie zuerst die Begriffe richtig zu machen:

Eine verschachtelte Klasse ist eine Klasse, die in einer anderen Klasse in der Quellcode-Ebene enthalten ist.
Es ist statisch, wenn Sie es mit dem statisch Modifikator erklären.
Eine nicht-statische verschachtelte Klasse innere Klasse genannt. (Ich bleibe bei nicht-statischer verschachtelter Klasse).

Martin Antwort ist richtig so weit. Doch die eigentliche Frage ist: Was ist der Zweck eine verschachtelte Klasse statische oder nicht deklarieren

Mit statischen verschachtelten Klassen , wenn Sie nur wollen, um Ihre Klassen zusammen zu halten, wenn sie topisch zusammen oder wenn die geschachtelte Klasse gehören ausschließlich in der umgebenden Klasse verwendet. Es gibt keinen semantischen Unterschied zwischen einer statischen geschachtelten Klasse und jeder anderen Klasse.

Nicht-statische verschachtelte Klassen ist ein anderes Tier. Ähnlich wie anonyme innere Klassen sind solche verschachtelte Klassen tatsächlich Schließungen. Das bedeutet, dass sie ihre Umgebung Umfang und ihre umgebende Instanz erfassen und zugänglich machen. Vielleicht wird ein Beispiel, das klären. Sehen Sie diese Stummel eines Container:

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 von einem Kind Element an den übergeordneten Container eine Referenz haben. Unter Verwendung einer nicht-statische verschachtelte Klasse, funktioniert dies ohne etwas Arbeit. Sie können die umgebende Instanz von Containern mit der Syntax Container.this zugreifen zu können.

Weitere Hardcore Erklärungen folgt:

Wenn Sie auf der Java-Bytecode sucht der Compiler generiert für einen (nicht statisch) verschachtelt Klasse es werden könnte, noch deutlicher:

// 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 der Compiler sehen ein verstecktes Feld Container this$0 schafft. Dies wird in dem Konstruktor gesetzt, die einen zusätzlichen Parameter vom Typ Container weist umschließenden Instanz zu spezifizieren. Sie können diesen Parameter nicht in der Quelle sehen, aber der Compiler generiert es implizit für eine verschachtelte Klasse.

Martin Beispiel

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

würde so zu einem Aufruf von so etwas wie kompiliert werden (in Bytecode)

new InnerClass(outerObject)

Aus Gründen der Vollständigkeit halber:

Eine anonyme Klasse ist ein perfektes Beispiel für eine nicht-statische verschachtelte Klasse, die gerade keinen Namen zugeordnet ist und kann später nicht mehr referenziert werden.

Ich denke, dass keine der oben genannten Antworten auf Dir den wirklichen Unterschied zwischen einer verschachtelten Klasse und einer statischen geschachtelte Klasse in der Bezeichnung des Anwendungsdesigns erklären:

Übersicht

Eine verschachtelte Klasse nicht statische oder statisch und in jedem Fall sein könnte ist eine Klasse innerhalb einer anderen Klasse definiert . Es sollte eine verschachtelte Klasse gibt es nur Klasse zu dienen umschließenden , wenn eine verschachtelte Klasse von anderen Klassen (nicht nur das einschließende) nützlich ist, sollte als Top-Level-Klasse deklariert werden.

Differenz

nicht statische geschachtelte Klasse : implizit mit der umschließenden Instanz der enthaltenden Klasse zugeordnet ist, bedeutet dies, dass es möglich ist, Methoden und Zugriffsvariablen der umschließenden Instanz aufzuzurufen. Eine gemeinsame Verwendung einer nicht-statischen geschachtelte Klasse ist eine Adapter-Klasse zu definieren.

Statische geschachtelte Klasse : kann nicht auf Klasseninstanz umschließt und ruft Methoden auf sie, so verwendet werden soll, wenn die verschachtelte Klasse keinen Zugriff auf eine Instanz der umgebenden Klasse benötigen. Eine gemeinsame Verwendung von statischer verschachtelter Klasse ist eine Komponente des äußeren Objekts zu implementieren.

Fazit

Der Hauptunterschied zwischen den beiden von einem Design-Standpunkt aus ist. nicht statische geschachtelte Klasse kann Instanz der Container-Klasse zugreifen, während statische kann nicht

In einfachen Worten brauchen wir verschachtelte Klassen in erster Linie, weil Java Verschlüsse nicht bieten.

Verschachtelte Klassen sind Klassen im Inneren des Körpers eines anderen umgebenden Klasse definiert. Sie sind von zwei Typen - statische und nicht-statisch

Sie sind als Mitglieder der umgebenden Klasse behandelt, daher können Sie eine der vier Zugriffsbezeichner angeben - private, package, protected, public. Wir haben nicht diesen Luxus mit Top-Level-Klassen, die nur public oder Paket-private deklariert werden können.

Innere Klassen aka Non-Stack-Klassen Zugang zu anderen Mitgliedern der Spitzenklasse, auch wenn sie privat deklariert werden, während Statische verschachtelte Klassen keinen Zugriff auf andere Mitglieder der Spitzenklasse haben.

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 wesentliche Unterschied zwischen ihnen, können Sie keine Inner2 Instanz ohne eine äußere schaffen, in dem, wie Sie unabhängig voneinander eine Inner1 Objekt erstellen können.

Wann möchten Sie Inner-Klasse verwenden?

Denken Sie an eine Situation, in der Class A und Class B verwandt sind, muss Class B Class A Mitglieder zuzugreifen und Class B wird nur Class A bezogen. Innere Klassen ins Bild kommt.

Für eine Instanz von innerer Klasse erstellen, müssen Sie eine Instanz der äußeren Klasse erstellen.

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

oder

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

Wann möchten Sie statische innere Klasse verwenden?

Sie würden eine statische innere Klasse definieren, wenn Sie wissen, dass es keine Beziehung mit der Instanz der umgebenden Klasse / Spitzenklasse hat. Wenn Ihre innere Klasse keine Methoden oder Felder der äußeren Klasse verwenden, es ist nur eine Verschwendung von Speicherplatz, so macht es statisch.

Zum Beispiel, ein Objekt für die statische verschachtelte Klasse zu erstellen, verwenden Sie die folgende Syntax:

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

Der Vorteil einer statischen geschachtelten Klasse ist, dass es nicht ein Objekt der enthaltenden Klasse / Spitzenklasse muss arbeiten. Dies kann Ihnen helfen, die Anzahl der Objekte der Anwendung erstellt wird zur Laufzeit zu reduzieren.

Ich denke, die Konvention, die im Allgemeinen befolgt wird, ist folgende:

statische Klasse innerhalb einer Spitzenklasse ist a verschachtelte Klasse
nicht statische Klasse innerhalb einer Spitzenklasse ist a innere Klasse, was weiter zwei weitere Form hat:
- lokale Klasse – Benannte Klassen, die innerhalb eines Blocks wie einer Methode oder einem Konstruktorkörper deklariert werden
- anonyme Klasse - unbenannte Klassen, deren Instanzen in Ausdrücken und Anweisungen erstellt werden

Allerdings nur wenige andere weist auf Erinnerungen hin Sind:

Top-Level-Klassen und statisch verschachtelte Klassen sind semantisch gleich, mit der Ausnahme, dass statisch verschachtelte Klassen statisch auf private statische Felder/Methoden ihrer äußeren [übergeordneten] Klasse verweisen können und umgekehrt.
Innere Klassen haben Zugriff auf Instanzvariablen der umschließenden Instanz der äußeren [übergeordneten] Klasse.Allerdings haben nicht alle inneren Klassen umschließende Instanzen, zum Beispiel haben innere Klassen in statischen Kontexten, wie eine anonyme Klasse, die in einem statischen Initialisierungsblock verwendet wird, keine.
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.Also,
- new YourClass(){}; bedeutet class [Anonymous] extends YourClass {}
- new YourInterface(){}; bedeutet class [Anonymous] implements YourInterface {}

Meiner Meinung nach bleibt die größere Frage offen: Welches soll ich wann verwenden?Nun, das hängt hauptsächlich davon ab, mit welchem Szenario Sie es zu tun haben, aber das Lesen der Antwort von @jrudolph kann Ihnen bei der Entscheidungsfindung helfen.

Hier die wichtigsten Unterschiede und Ähnlichkeiten zwischen Java inneren Klasse und statische verschachtelte Klasse.

Hoffe, es hilft!

Inner Klasse

Kann zugreifen zu äußeren Klasse sowohl Instanz und statische Methoden und Felder
Verbunden mit Instanz der Klasse umschließenden so instanziiert es muss zuerst eine Instanz der äußeren Klasse (Anmerkung neue Stichwort Platz):
```
Outerclass.InnerClass innerObject = outerObject.new Innerclass();
```
Kann nicht definieren alle statische Mitglieder selbst
Kann nicht wurde Klasse oder Schnittstelle Erklärung

Statische verschachtelte Klasse

Kein Zugriff Außen Klasse Beispiel: Methoden oder Felder

Nicht mit jeder Instanz der umschließenden Klasse zugeordnet So instanziiert es:

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

Similarities

Beide Innere Klassen können zugreifen, auch private Felder und Methoden äußeren Klasse
Auch die Äußere Klasse haben Zugriff auf private Felder und Methoden innere Klassen
Beide Klassen können private haben, geschützt oder öffentlich Zugriffsmodifikator

Warum verwenden Verschachtelte Klassen?

Nach der Oracle-Dokumentation gibt es mehrere Gründe sind ( vollständige Dokumentation ):

Es ist eine Möglichkeit, logisch Klassen gruppieren, die nur an einem Ort verwendet werden: Wenn eine Klasse nur auf einer anderen Klasse nützlich ist, dann ist es logisch, es in dieser Klasse einzuzubetten und halten die beiden zusammen. Nesting solche "Hilfsklassen" macht ihr Paket schlanker.



Es erhöht die Verkapselung: Betrachten wir zwei Top-Level-Klassen A und B, wobei B Zugang zu den Mitgliedern von A benötigt, die sonst privat deklariert werden würde. Durch das Verbergen Mitglieder der Klasse B innerhalb der Klasse A, A der kann privat deklariert werden und B auf sie zugreifen können. Zusätzlich B selbst kann von der Außenwelt versteckt werden.



Es kann besser lesbar und wartbar Code führen. Nesting kleine Klassen innerhalb der obersten Ebene Klassen legt sich den Code näher an, wo es verwendet wird,

Verschachtelte Klasse: Klasse innerhalb der Klasse

Typen:

Statische verschachtelte Klasse
Non-statische verschachtelte Klasse [Inner Klasse]

Unterschied:

Nicht-statische verschachtelte Klasse [Inner Klasse]

In nicht-statischem nested Klassenobjekt der inneren Klasse existiert innerhalb Objekts der äußeren Klasse. So dass Daten Mitglied der äußeren Klasse ist zu innerer Klasse zugänglich. So Objekt der inneren Klasse erstellen wir erstes Objekt der äußeren Klasse erstellen müssen.

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

Statische verschachtelte Klasse

Bei der statischen geschachtelten Klasse Objekt der inneren Klasse nicht Gegenstand der äußeren Klasse benötigen, weil das Wort „statisch“ keine Notwendigkeit, zeigt Objekt zu erstellen.

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

Wenn Sie x zugreifen möchten, dann schreiben Sie das folgende innerhalb Methode

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

Die Instanz der inneren Klasse wird erstellt, wenn Instanz der äußeren Klasse erstellt. Daher sind die Elemente und Verfahren der inneren Klasse haben Zugang zu den Mitgliedern und Verfahren der Instanz (Objekt) der äußeren Klasse. Wenn die Instanz der äußeren Klasse den Gültigkeitsbereich verlässt, auch die inneren Klasseninstanzen aufhören zu existieren.

Die statische verschachtelte Klasse keine konkrete Instanz hat. Es ist nur geladen, wenn es zum ersten Mal (ebenso wie die statischen Methoden) verwendet wird. Es ist eine völlig unabhängige Einheit, deren Methoden und Variablen haben keinen Zugriff auf die Instanzen der äußeren Klasse.

Die statischen verschachtelten Klassen sind nicht mit dem äußeren Objekt gekoppelt, sie sind schneller, und sie nicht Heap / Stapelspeicher nehmen, weil es nicht notwendig Instanz dieser Klasse zu erstellen. Deshalb ist die Faustregel, um zu versuchen statische verschachtelte Klasse zu definieren, mit so wenig Spielraum wie möglich (privat> = class> = geschützt> = public), und wandeln sie dann in innerer Klasse (durch „statische“ Kennung entfernen) und lockerte der Umfang, wenn es wirklich notwendig ist.

Es gibt eine Feinheit über die Verwendung von verschachtelten statischen Klassen, die in bestimmten Situationen nützlich sein könnten.

Während statische Attribute instanziiert erhalten, bevor die Klasse über den Konstruktor instanziiert wird, statische Attribute innerhalb von verschachtelten statischen Klassen scheinen erst nach der instanziiert zu erhalten Klasse Konstruktor wird aufgerufen, oder zumindest nicht bis nach die Attribute zuerst Bezug genommen wird, auch wenn sie als ‚endgültig‘ gekennzeichnet ist.

Betrachten Sie dieses Beispiel:

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

Auch wenn ‚verschachtelt‘ und ‚innerItem‘ beide als ‚static final‘ deklariert. die Einstellung von nested.innerItem findet nicht statt, bis die Klasse instanziiert wird (oder zumindest erst nach dem verschachtelten statischen Elemente zuerst Bezug genommen wird), wie Sie selbst sehen können, durch Kommentare und uncommenting die Zeilen, die ich zu beziehen, siehe oben. Das gleiche ist nicht stichhaltig gilt für 'outerItem'.

Mindestens das ist, was in Java 6.0 ich sehe.

Im Fall von Instanz, die Instanz von Nicht statische innere Klasse ist mit dem Bezug erstellt von Gegenstand der äußeren Klasse, in der sie definiert ist. Diese bedeutet es, einschließend Instanz haben. Aber die Instanz von statischer innerer Klasse ist mit dem Bezug von Outer-Klasse erstellt wird, nicht mit die Referenz des Objektes der äußeren Klasse. Das bedeutet, es einschließend Instanz nicht.

Zum Beispiel:

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….
  }
}

Ich glaube nicht, dass es hier viel hinzuzufügen ist, die meisten Antworten perfekt auf die Unterschiede zwischen statischer geschachtelten Klasse und Inneren Klassen erklären. Beachten Sie jedoch das folgende Problem, wenn verschachtelte Klassen vs inneren Klassen verwenden. Wie erwähnt, in ein paar Antworten können innere Klassen nicht ohne instanziert werden und Instanz ihrer umgebenden Klasse, die bedeutet, dass sie HOLD Zeiger auf die Instanz ihrer umgebenden Klasse, wo führen zu einem Speicherüberlauf oder Stapelüberlaufausnahme aufgrund der Tatsache, die GC nicht zu Müll der Lage sein, sammeln die umschließende Klassen, auch wenn sie nicht verwendet werden mehr. Um diese klare Kontrolle machen den folgenden Code aus:

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

}

Wenn Sie den Kommentar auf // inner = null; Das Programm entfernen wird löscht " Ich bin zerstört! ", aber Beibehaltung dieser kommentierten wird es nicht.
Der Grund dafür ist, dass weiße innere Instanz noch GC referenziert wird es nicht sammeln kann und weil es verweist (hat einen Zeiger auf) die äußeree Instanz es nicht allzu gesammelt. Genügend dieser Objekte in Ihrem Projekt und können über genügend Arbeitsspeicher ausgeführt.
Im Vergleich zu statischen inneren Klassen, die keinen Punkt inneren Klasseninstanz nicht halten, weil es nicht Instanz verwendet ist, aber Klasse verwendet. Das obige Programm kann drucken „ Ich bin zerstört! “, wenn Sie innere Klasse statische und instanziiert mit Outer.Inner i = new Outer.Inner(); machen

Die Begriffe werden synonym verwendet. Wenn Sie wirklich pedantisch darüber sein wollen, dann sind Sie könnte definieren „verschachtelte Klasse“, um zu einer statischen inneren Klasse zu beziehen, eine, die keine umgebende Instanz hat. In Code, können Sie so etwas wie diese:

public class Outer {
    public class Inner {}

    public static class Nested {}
}

Das ist nicht wirklich eine allgemein akzeptierte Definition though.

Nested-Klasse ist ein sehr allgemeiner Begriff: jede Klasse, die eine verschachtelte Klasse nicht oberste Ebene ist. Eine innere Klasse ist eine nicht-statische geschachtelte Klasse. Joseph Darcy hat eine sehr schöne Erklärung über Verschachtelte, Inner, Mitglied und Top-Level-Klassen .

Ähm ... eine innere Klasse ist eine verschachtelte Klasse ... tun Sie anonyme Klasse und innere Klasse bedeuten?

Edit: Wenn Sie tatsächlich gegen anonyme innere gemeint ... eine innere Klasse ist nur eine Klasse innerhalb einer Klasse definiert, wie:

public class A {
    public class B {
    }
}

Während eine anonyme Klasse eine Erweiterung einer Klasse anonym definiert ist, so dass keine tatsächliche „Klasse definiert ist, wie in:

public class A {
}

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

Weitere Edit:

behauptet, gibt es einen Unterschied in Java, aber ich habe mit Java gearbeitet für 8 Jahre, und es ist das erste Mal hörte ich eine solche Unterscheidung ... nicht zu erwähnen, gibt es keine Hinweise gibt, die Forderung ... Unterm Strich zu sichern, eine innere Klasse eine Klasse innerhalb einer Klasse (statisch oder nicht) definiert ist, und verschachtelte ist nur ein weiterer Begriff, das gleiche zu bedeuten.

Es gibt einen feinen Unterschied zwischen statischer und nicht-statischer verschachtelter Klasse ... im Grunde nicht-statische innere Klassen haben impliziten Zugriff auf Instanzfelder und Methoden der umschließenden Klasse (also können sie nicht in einem statischen Kontext aufgebaut sein, es wird sein, einen Compiler-Fehler). Statische verschachtelte Klassen, auf der anderen Seite, haben keinen impliziten Zugriff auf Instanzfelder und Methoden, und können in einem statischen Kontext aufgebaut werden.

Targeting Lerner, die Anfänger sind auf Java und / oder verschachtelte Klassen

Verschachtelte Klassen können entweder:
1. Statische verschachtelte Klassen.
2. Nicht Statische verschachtelte Klassen. (Auch bekannt als Innere Klassen ) => Bitte beachten Sie diese

1.Inner Klassen
Beispiel:

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

Innere Klassen sind Untergruppen von verschachtelten Klassen:

innere Klasse ist eine bestimmte Art von verschachtelter Klasse
innere Klassen sind Untergruppen von verschachtelten Klassen
Sie kann sagen, dass eine innere Klasse ist auch eine verschachtelte Klasse, aber Sie können nicht sagen, dass eine verschachtelte Klasse ist auch eine innere Klasse .

Spezialität von Inner Klasse:

Instanz einer inneren Klasse hat Zugriff auf alle der Mitglieder der äußeren Klasse, auch solche, die mit „privat“ sind

2.Static Verschachtelte Klassen:
Beispiel:

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

Fall 1: Instanziieren eine statische verschachtelte Klasse von einer nicht-einschließenden Klasse

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

Fall 2: eine statische verschachtelte Klasse von einer umschließenden Klasse Instanziierungsanwendung

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

}

Spezialität von statischen Klassen:

Statische innere Klasse würde nur Zugriff auf die statischen Mitglieder der äußeren Klasse hat, und hat keinen Zugang zu nicht-statischen Mitgliedern.

Fazit:
Frage: Was ist der Hauptunterschied zwischen einer inneren Klasse und einer statischen geschachtelte Klasse in Java
? Antwort:. gehen Sie einfach durch Besonderheiten der jeweiligen Klasse oben genannten

Inner Klasse und verschachtelt statische Klasse in Java sind beide Klassen innerhalb einer anderen Klasse deklariert, als Top-Level-Klasse in Java bekannt. In Java-Terminologie Wenn Sie eine verschachtelte Klasse statisch deklarieren, wird es verschachtelte statische Klasse in Java, während nicht statische geschachtelte Klasse genannt einfach als innere Klasse bezeichnet werden.

Was ist innere Klasse in Java?

Jede Klasse, die keine Top-Level ist oder innerhalb einer anderen Klasse deklariert ist als verschachtelte Klasse bekannt und aus diesen verschachtelten Klassen, Klasse, die nicht statisch deklariert werden, werden als innere Klasse in Java bekannt. gibt es drei Arten von Inner-Klasse in Java:

1) Lokale innere Klasse - ist in einem Codeblock oder Methode deklariert
. 2) Anonym innere Klasse - ist eine Klasse, die an derselben Stelle nicht Namen Bezug hat und initialisiert, wo es wird erstellt
. 3) Das Mitglied innere Klasse -. Als nicht statisches Element der äußeren Klasse deklariert

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

Was statische Klasse in Java verschachtelt ist?

Verschachtelte statische Klasse ist eine andere Klasse, die innerhalb einer Klasse als Mitglied deklariert und gemacht statisch. Verschachtelte statische Klasse ist auch als Mitglied der äußeren Klasse deklariert und privat sein können, öffentlich oder wie jedes andere Mitglied geschützt. Einer des Hauptvorteils von verschachtelter statischer Klasse über innere Klasse ist, dass beispielsweise verschachtelte statische Klasse ist nicht auf irgendeine Instanz der einschließe äußeren Klasse nicht angebracht. Sie brauchen auch keine Instanz von Outer-Klasseninstanz von verschachtelter statischer Klasse in Java erstellen .

1) können Sie Zugriff auf statische Datenelemente der äußeren Klasse einschließlich der privaten.
2) Statische verschachtelte Klasse kann nicht auf nicht-statische (instance) Datenelement oder Methode .

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: Innenklasse und verschachtelte Statische Klasse in Java mit Beispiel

Statische Nest Klasse gerade nur die erste innere Klasse: die

Ich glaube, die Leute hier zu Plakate bemerken sollen. Zum Beispiel:

 public static class A {} //ERROR

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

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

 }

Also, zusammenfassen, statische Klasse hängt nicht, welche Klasse seine enthält. So können sie nicht in der normalen Klasse. (Da normale Klasse braucht eine Instanz).

Wenn wir statische Member Klasse innerhalb einer Klasse deklarieren, wird es als Top-Level-verschachtelte Klasse oder eine statische verschachtelte Klasse bekannt. Es kann, wie unten gezeigt werden:

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

Wenn wir nicht statisch innerhalb einer Klasse Mitglied Klasse deklarieren es als innere Klasse bekannt. Innenklasse, wie unten gezeigt werden kann:

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

Das folgende ist ein Beispiel für static nested class und 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()); 

    }

}

Ich glaube, dass keines der oben genannten Antworten das reale Beispiel für Sie den Unterschied zwischen einer geschachtelten Klasse und einer statischen geschachtelte Klasse in der Bezeichnung des Anwendungsdesigns geben. Und der größte Unterschied zwischen statischer geschachtelten Klasse und innerer Klasse ist die Fähigkeit, die äußeree Klasseninstanz Feld zuzugreifen.

Lassen Sie uns die beiden folgenden Beispiele einen Blick darauf werfen.

Static Nest Klasse: Ein gutes Beispiel für statische verschachtelte Klassen sind Builder-Muster ( https://dzone.com/articles/design-patterns-the-builder-pattern ).

Für Bankkonto verwenden wir eine statische verschachtelte Klasse, vor allem, weil

Static Nest Klasseninstanz vor der äußeren Klasse erstellt werden kann.
In dem Erbauer ist der Erbauer eine Hilfsklasse, die die Bankaccount erstellen verwendet wird.
BankAccount.Builder ist nur mit Bankkonto verbunden. Keine andere Klassen sind BankAccount.Builder bezogen. so ist es besser, sie gemeinsam zu organisieren, ohne Namenskonvention zu verwenden.

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

Inner Klasse: Eine gemeinsame Verwendung von inneren Klassen ist eine Ereignisbehandlungsroutine zu definieren. https://docs.oracle.com/javase/tutorial/uiswing/ events / generalrules.html

Für MyClass, verwenden wir die innere Klasse, vor allem, weil:

Inner Klasse MyAdapter müssen die äußere Klassenmitglied zugreifen zu können.
Im Beispiel wird MyAdapter nur mit MyClass verbunden. Keine andere Klassen sind MyAdapter bezogen. so ist es besser, sie gemeinsam zu organisieren, ohne eine Namenskonvention mit

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

Zu allererst Es gibt keine solche Klassen Static class.The Statische Modifier Verwendung mit innerer Klasse aufgerufen (genannt als Nested-Klasse), sagt, dass es ein statisches Element der äußeren Klasse ist, das bedeutet, dass wir es mit anderen statischen Mitgliedern zugreifen können und ohne eine Instanz von äußeren Klasse aufweist. (Welche ist Nutzen der statischen ursprünglich).

Der Unterschied zwischen Verschachtelte Klasse und regelmäßige Inner-Klasse ist:

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

Zuerst können wir Outerclass instanziiert dann können wir Inner zugreifen zu können.

Aber wenn Klasse Nested ist dann Syntax:

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

, die die statische Syntax als normale Implementierung von statischem Schlüsselwort verwendet.

Die Java-Programmiersprache ermöglicht es Ihnen, eine Klasse in einer anderen Klasse zu definieren. Eine solche Klasse eine verschachtelte Klasse genannt und dargestellt hier:

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

Verschachtelte Klassen sind in zwei Kategorien unterteilt: statisch und nicht statisch. Verschachtelte Klassen, die statisch deklariert werden statische verschachtelte Klassen genannt. Nicht-statische verschachtelte Klassen sind innere Klassen genannt. Eine Sache, die wir im Auge behalten sollen, ist nicht statisch verschachtelte Klassen (innere Klassen) haben Zugang zu anderen Mitgliedern der umgebenden Klasse, auch wenn sie privat deklariert ist. Statische verschachtelte Klassen nur Zugriff auf andere Mitglieder der umgebenden Klasse haben, wenn diejenigen, statisch sind. Es kann nicht nicht statische Mitglieder der äußeren Klasse zugreifen. Wie bei den Klassen-Methoden und Variablen wird eine statische geschachtelte Klasse mit seiner Außen Klasse zugeordnet. Zum Beispiel, ein Objekt für die statische verschachtelte Klasse zu erstellen, verwenden Sie die folgende Syntax:

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

Um eine innere Klasse zu instanziiert, müssen Sie zuerst die äußeren Klasse instanziiert. Erstellen Sie dann das innere Objekt innerhalb des äußeren Objekts mit dieser Syntax:

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

Warum verwenden wir verschachtelte Klassen

Es ist eine Möglichkeit, logisch Klassen gruppieren, die nur an einem Ort verwendet werden.
Es erhöht die Einkapselung.
Es kann besser lesbar und wartbar Code führen.

Quelle: Die Java ™ Tutorials - Verschachtelte Klassen

Der Unterschied besteht darin, dass eine verschachtelte Klassendeklaration, die auch statisch ist, kann außerhalb der umschließenden Klasse instanziiert werden.

Wenn Sie eine verschachtelte Klassendeklaration, die nicht statisch, auch bekannt als eine innere Klasse , Java wird nicht lassen Sie es außer über die umgebende Klasse instanziiert. Das Objekt aus der inneren Klasse erstellt wird mit dem Objekt verknüpft aus der äußeren Klasse erzeugt, so dass die innere Klasse die Felder der äußeren referenzieren.

Aber wenn es statisch ist, dann ist die Verbindung nicht vorhanden ist, können die äußeren Felder nicht (außer über eine gewöhnliche Referenz wie jedes anderes Objekt) zugegriffen werden, und Sie können daher die verschachtelte Klasse für mich instanziiert.

Ich habe verschiedene mögliche korrekte und Fehlerszenario dargestellt, die in Java-Code auftreten können.

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

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow