esempio - static class java




Classe interna Java e classe nidificata statica (16)

Differenza tra classe nidificata statica e non statica in Java

1) La classe statica nidificata non ha bisogno di riferimenti di classe Outer ma una classe nidificata non statica o una classe Inner richiede un riferimento di classe Outer. Non è possibile creare un'istanza della classe Inner senza creare un'istanza della classe Outer. Questa è di gran lunga la cosa più importante da considerare mentre si effettua una classe nidificata statica o non statica.

2) la classe statica è in realtà un membro statico di classe e può essere utilizzata in un contesto statico, ad esempio metodo statico o blocco statico di classe Outer.

3) Un'altra differenza tra classe nidificata statica e non statica è che non è possibile accedere direttamente ai membri non statici, ad esempio metodo e campo, nella classe statica nidificata. Se lo fai otterrai un errore come "membro non statico non può essere usato nel contesto statico". Mentre la classe Inner può accedere sia ai membri statici che non statici della classe Outer.

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

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

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

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

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

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

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

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


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

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

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

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

Produzione:

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

Questo è tutto su Differenza tra classi annidate statiche e non statiche in Java. Finora abbiamo solo toccato la classe Inner membro e non abbiamo discusso altri due tipi sulla classe Inner, ad esempio la classe Local e la classe Inner Anonymous. In questo tutorial di Java abbiamo visto Qual è la classe statica nidificata in Java e Come creare istanze di entrambe le classi statiche e non statiche nidificate in Java.

In sintesi, è facile creare istanze di classi statiche nidificate in quanto non richiede un'istanza di classe Outer mentre una classe nidificata non statica, ad es. La classe Inner avrà sempre bisogno di un'istanza di classe Outer e non può esistere senza la classe Outer. Se devi scegliere tra la classe statica e quella non statica, preferisci la classe nidificata statica se puoi usarla.

Qual è la principale differenza tra una classe interna e una classe nidificata statica in Java? La progettazione / realizzazione ha un ruolo nella scelta di uno di questi?


Classe annidata: classe in classe

tipi:

  1. Classe nidificata statica
  2. Classe annidata non statica [Classe interna]

Differenza:

Classe annidata non statica [Classe interna]

Nell'oggetto di classe nidificato non statico della classe interna esiste all'interno dell'oggetto della classe esterna. In modo che il membro dei dati della classe esterna sia accessibile alla classe interna. Quindi per creare l'oggetto della classe interiore dobbiamo prima creare l'oggetto della classe esterna.

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

Classe nidificata statica

Nell'oggetto di classe nidificato statico di classe interna non è necessario l'oggetto di classe esterna, poiché la parola "statico" non indica la necessità di creare oggetti.

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

Se si desidera accedere a x, quindi scrivere il seguente metodo interno

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

Ecco le principali differenze e somiglianze tra la classe interna Java e la classe nidificata statica.

Spero che sia d'aiuto!

Classe interiore

  • Può accedere alla classe esterna sia per istanza che per metodi e campi statici
  • Associato con l'istanza di allegare la classe in modo da creare un'istanza, prima necessita di un'istanza di classe esterna (nota il nuovo posto per la parola chiave):

    Outerclass.InnerClass innerObject = outerObject.new Innerclass();
    
  • Non è possibile definire alcun membro statico

  • Non può avere una dichiarazione di classe o interfaccia

Classe nidificata statica

  • Impossibile accedere ai metodi o ai campi dell'istanza di classe esterna

  • Non associato a nessuna istanza di classe di chiusura Quindi, per istanziarlo:

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

Analogie

  • Entrambe le classi interne possono accedere anche a campi e metodi privati di classe esterna
  • Anche la classe Outer ha accesso a campi privati ​​e metodi di classi interne
  • Entrambe le classi possono avere un modificatore privato, protetto o di accesso pubblico

Perché usare le classi annidate?

Secondo la documentazione di Oracle ci sono diversi motivi ( documentazione completa ):

  • È un modo di raggruppare logicamente le classi che vengono utilizzate solo in un posto: se una classe è utile solo per un'altra classe, è logico incorporarla in quella classe e mantenerla insieme. Annidare queste "classi di supporto" rende il loro pacchetto più snello.

  • Aumenta l'incapsulamento: considera due classi di primo livello, A e B, dove B ha bisogno di accedere ai membri di A che altrimenti sarebbero dichiarati privati. Nascondendo la classe B all'interno della classe A, i membri di A possono essere dichiarati privati ​​e B può accedervi. Inoltre, la stessa B può essere nascosta dal mondo esterno.

  • Può portare a un codice più leggibile e gestibile : l' inserimento di classi di piccole dimensioni all'interno delle classi di alto livello avvicina il codice a dove viene utilizzato.


Esiste una sottigliezza sull'uso di classi statiche nidificate che potrebbero essere utili in determinate situazioni.

Mentre gli attributi statici vengono istanziati prima che la classe venga istanziata tramite il suo costruttore, gli attributi statici all'interno delle classi statiche nidificate non sembrano essere istanziati fino a quando il costruttore della classe non viene richiamato, o almeno non fino a dopo che gli attributi sono stati referenziati, anche se sono contrassegnati come "finali".

Considera questo esempio:

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

Anche se "nested" e "innerItem" sono entrambi dichiarati come "statici finali". l'impostazione di nested.innerItem non ha luogo fino a dopo la creazione dell'istanza della classe (o almeno non fino a dopo il riferimento dell'elemento statico nidificato), come puoi vedere da solo commentando e decommentando le righe a cui mi riferisco, sopra. Lo stesso non vale per 'outerItem'.

Almeno questo è quello che vedo in Java 6.0.


Il tutorial di Java dice :

Terminologia: le classi annidate sono divise in due categorie: statiche e non statiche. Le classi annidate dichiarate statiche sono semplicemente chiamate classi nidificate statiche. Le classi nidificate non statiche sono chiamate classi interne.

Nel linguaggio comune, i termini "annidato" e "interno" sono usati in modo intercambiabile dalla maggior parte dei programmatori, ma userò il termine corretto "classe nidificata" che copre sia l'interno che l'statico.

Le classi possono essere annidate all'infinito , ad esempio la classe A può contenere la classe B che contiene la classe C che contiene la classe D, ecc. Tuttavia, più di un livello di nidificazione delle classi è raro, in quanto è in genere una cattiva progettazione.

Ci sono tre motivi per cui potresti creare una classe annidata:

  • organizzazione: a volte sembra più sensato ordinare una classe nello spazio dei nomi di un'altra classe, specialmente quando non sarà usata in nessun altro contesto
  • accesso: le classi nidificate hanno accesso speciale alle variabili / campi delle loro classi contenenti (precisamente quali variabili / campi dipendono dal tipo di classe annidata, sia essa interna o statica).
  • convenienza: dover creare un nuovo file per ogni nuovo tipo è fastidioso, anche in questo caso, specialmente quando il tipo verrà utilizzato solo in un contesto

Esistono quattro tipi di classi nidificate in Java . In breve, sono:

  • classe statica : dichiarata come membro statico di un'altra classe
  • inner class : dichiarato come membro di un'istanza di un'altra classe
  • locale inner class : dichiarato all'interno di un metodo di istanza di un'altra classe
  • classe interiore anonima : come una classe interiore locale, ma scritta come espressione che restituisce un oggetto one-off

Lasciatemi elaborare più dettagli.


Classi statiche

Le classi statiche sono il tipo più facile da capire perché non hanno nulla a che fare con le istanze della classe contenente.

Una classe statica è una classe dichiarata come membro statico di un'altra classe. Proprio come gli altri membri statici, una classe di questo tipo è in realtà solo un gancio che utilizza la classe contenente come spazio dei nomi, ad esempio la classe Goat dichiarata come membro statico della classe Rhino nel pacchetto pizza è conosciuta con il nome pizza.Rhino.Goat .

package pizza;

public class Rhino {

    ...

    public static class Goat {
        ...
    }
}

Francamente, le classi statiche sono una caratteristica piuttosto inutile perché le classi sono già suddivise in spazi dei nomi per pacchetti. L'unica vera ragione plausibile per creare una classe statica è che tale classe abbia accesso ai membri statici privati ​​della sua classe contentente, ma trovo che questa sia una giustificazione piuttosto debole per la presenza della funzione di classe statica.


Classi interiori

Una classe interna è una classe dichiarata come membro non statico di un'altra classe:

package pizza;

public class Rhino {

    public class Goat {
        ...
    }

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

Come con una classe statica, la classe interna è conosciuta come qualificata dal suo nome di classe contenente, pizza.Rhino.Goat , ma all'interno della classe contenente, può essere conosciuta con il suo nome semplice. Tuttavia, ogni istanza di una classe interna è legata a una particolare istanza della sua classe contenente: sopra, la Capra creata in jerry , è implicitamente legata all'istanza di Rhino questa in jerry . Altrimenti, rendiamo esplicita l'istanza di Rhino associata quando istanziamo Goat :

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

(Si noti che si fa riferimento al tipo interno come solo capra nella nuova sintassi strana: Java deduce il tipo di contenuto dalla parte del rinoceronte e, sì, anche il nuovo rhino.Goat () avrebbe avuto più senso per me).

Quindi cosa ci guadagna? Bene, l'istanza della classe interna ha accesso ai membri dell'istanza dell'istanza della classe contenente. Questi membri dell'istanza che racchiudono sono riferiti all'interno della classe interna tramite solo i loro nomi semplici, non tramite questo ( questo nella classe interna si riferisce all'istanza della classe interna, non all'istanza della classe contenente associata):

public class Rhino {

    private String barry;

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

Nella classe interna, puoi fare riferimento a questa della classe contenente Rhino.questo , e puoi usare questo per fare riferimento ai suoi membri, ad esempio Rhino.this.barry .


Classi interne locali

Una classe interna locale è una classe dichiarata nel corpo di un metodo. Tale classe è conosciuta solo all'interno del suo metodo di contenimento, quindi può essere istanziata e i suoi membri possono accedere al suo metodo di contenimento. Il guadagno è che un'istanza di classe interna locale è legata e può accedere alle variabili locali finali del suo metodo di contenimento. Quando l'istanza utilizza un locale finale del suo metodo di contenimento, la variabile conserva il valore che aveva al momento della creazione dell'istanza, anche se la variabile è uscita dal campo di applicazione (questa è effettivamente la grezza versione limitata di chiusure di Java).

Poiché una classe interna locale non è né membro di una classe o di un pacchetto, non è dichiarata con un livello di accesso. (Sii chiaro, tuttavia, che i suoi membri hanno livelli di accesso come in una classe normale).

Se una classe interna locale è dichiarata in un metodo di istanza, un'istanza della classe interna è legata all'istanza posseduta dal metodo di contenimento al momento della creazione dell'istanza, quindi i membri dell'istanza della classe contenente sono accessibili come in un'istanza classe interiore. Una classe interna locale viene istanziata semplicemente tramite il suo nome, ad esempio la classe interna locale Cat viene istanziata come nuova Cat () , non nuova this.Cat () come ci si potrebbe aspettare.


Classi interiori anonime

Una classe interiore anonima è un modo sintatticamente conveniente di scrivere una classe interiore locale. Più comunemente, una classe interna locale viene istanziata al massimo una sola volta ogni volta che viene eseguito il suo metodo di contenimento. Sarebbe bello, quindi, se potessimo combinare la definizione della classe interna locale e la sua singola istanziazione in una comoda forma di sintassi, e sarebbe anche bello se non dovessimo pensare a un nome per la classe (il meno scomodo nomi contiene il tuo codice, meglio è). Una classe interiore anonima consente entrambe queste cose:

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

Questa è un'espressione che restituisce una nuova istanza di una classe senza nome che estende ParentClassName . Non puoi fornire il tuo costruttore; piuttosto, ne viene fornito implicitamente uno che chiama semplicemente il super costruttore, quindi gli argomenti forniti devono adattarsi al super costruttore. (Se il genitore contiene più costruttori, il "più semplice" è chiamato "il più semplice" come determinato da un insieme piuttosto complesso di regole che non vale la pena di apprendere in dettaglio - basta fare attenzione a ciò che NetBeans o Eclipse dicono).

In alternativa, puoi specificare un'interfaccia da implementare:

new *InterfaceName*() {*members*}

Tale dichiarazione crea una nuova istanza di una classe senza nome che estende Object e implementa InterfaceName . Di nuovo, non puoi fornire il tuo costruttore; in questo caso, Java fornisce implicitamente un costruttore no-arg, do-nothing (quindi in questo caso non ci saranno mai argomenti del costruttore).

Anche se non è possibile assegnare a una classe interna anonimo un costruttore, è comunque possibile eseguire qualsiasi configurazione desiderata utilizzando un blocco di inizializzazione (un blocco {} posto all'esterno di qualsiasi metodo).

Sii chiaro che una classe interiore anonima è semplicemente un modo meno flessibile di creare una classe interna locale con un'istanza. Se si desidera una classe interna locale che implementa interfacce multiple o che implementa interfacce estendendo una classe diversa da Object o che specifica il proprio costruttore, si è bloccati nella creazione di una classe interna locale con nome regolare.


In termini semplici, abbiamo bisogno di classi nidificate principalmente perché Java non fornisce chiusure.

Le classi annidate sono classi definite all'interno del corpo di un'altra classe che racchiude. Sono di due tipi: statici e non statici.

Vengono considerati membri della classe che li include, quindi è possibile specificare uno qualsiasi dei quattro specificatori di accesso: private, package, protected, public . Non abbiamo questo lusso con le classi di alto livello, che possono essere dichiarate public o private di pacchetti.

Classi interne alias Le classi non stack hanno accesso ad altri membri della classe superiore, anche se sono dichiarate private mentre le classi nidificate statiche non hanno accesso ad altri membri della classe superiore.

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

Inner1 è la nostra classe interna statica e Inner2 è la nostra classe interiore che non è statica. La differenza fondamentale tra di loro, non è possibile creare un'istanza Inner2 senza un Esterno dove è possibile creare un oggetto Inner1 indipendente.

Quando useresti la classe Inner?

Pensa a una situazione in cui la Class A e la Class B sono correlate, la Class B deve accedere ai membri della Class A e la Class B è relativa solo alla Class A Le classi interne entrano in scena.

Per creare un'istanza di inner class, devi creare un'istanza della tua classe esterna.

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

o

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

Quando useresti la classe Inner static?

Si definirà una classe interna statica quando si sa che non ha alcuna relazione con l'istanza della classe / classe principale che la contiene. Se la tua classe interiore non usa metodi o campi della classe esterna, è solo uno spreco di spazio, quindi rendilo statico.

Ad esempio, per creare un oggetto per la classe nidificata statica, utilizzare questa sintassi:

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

Il vantaggio di una classe nidificata statica è che non ha bisogno di un oggetto della classe contenente / classe superiore per funzionare. Questo può aiutarti a ridurre il numero di oggetti creati dall'applicazione in fase di runtime.


Nel caso della creazione di un'istanza, l'istanza della classe interna non statica viene creata con il riferimento dell'oggetto della classe esterna in cui è definita. Ciò significa che ha un'istanza inclusiva. Ma l'istanza della classe interna statica viene creata con il riferimento della classe Outer, non con il riferimento dell'oggetto della classe esterna. Questo significa che non ha istanza inclusiva.

Per esempio:

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

Non penso che ci sia molto da aggiungere qui, la maggior parte delle risposte spiegano perfettamente le differenze tra classi nidificate statiche e classi interne. Tuttavia, si consideri il seguente problema quando si utilizzano classi nidificate e classi interne. Come menzionato in un paio di risposte le classi interne non possono essere istanziate senza e istanza della loro classe che racchiude il che significa che TENGONO un puntatore all'istanza della loro classe che acclude che può portare all'overflow della memoria o all'eccezione di overflow dello stack dovuta al fatto che il GC non sarà in grado di raccogliere i dati relativi alle classi che li contengono anche se non sono più utilizzati. Per chiarire questo, controlla il seguente codice:

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

}

Se rimuovi il commento su // inner = null; Il programma uscirà con " I am destroyed! ", Ma tenendo presente che non lo farà.
Il motivo è che l'istanza interna bianca è ancora referenziata. GC non può raccoglierla e perché fa riferimento (ha un puntatore a) all'istanza esterna che non viene raccolta. Avere abbastanza di questi oggetti nel progetto e può esaurire la memoria.
Rispetto alle classi interne statiche che non tengono conto dell'istanza della classe interna perché non è correlata all'istanza ma alla classe. Il programma di cui sopra può stampare " I am destroyed! " Se rendi la classe Inner statica e istanziata con Outer.Inner i = new Outer.Inner();


Penso che la convenzione generalmente seguita sia questa:

  • la classe statica all'interno di una classe di primo livello è una classe nidificata
  • la classe non statica all'interno di una classe di primo livello è una classe interna , che ha anche altre due forme:
    • classe locale : classi denominate dichiarate all'interno di un blocco come un metodo o un corpo del costruttore
    • classe anonima - classi senza nome le cui istanze sono create in espressioni e istruzioni

Tuttavia, pochi altri punti da ricordare sono:

  • Le classi di livello superiore e le classi nidificate statiche sono semanticamente uguali, tranne che nel caso di classi nidificate statiche può fare riferimento statico a campi / metodi statici privati ​​della classe Outer [parent] e viceversa.

  • Le classi interne hanno accesso alle variabili di istanza dell'istanza allegata della classe Outer [genitore]. Tuttavia, non tutte le classi interne hanno istanze che racchiudono, per esempio classi interne in contesti statici, come una classe anonima usata in un blocco di inizializzazione statico, no.

  • La classe anonima di default estende la classe genitore o implementa l'interfaccia genitore e non ci sono ulteriori clausole per estendere qualsiasi altra classe o implementare altre interfacce. Così,

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

Sento che la domanda più grande che rimane aperta quale usare e quando? Beh, questo dipende in gran parte da quale scenario hai a che fare, ma leggere la risposta fornita da @jrudolph può aiutarti a prendere una decisione.


Penso che nessuna delle risposte precedenti spieghi la reale differenza tra una classe nidificata e una classe nidificata statica in termini di design dell'applicazione:

OverView

Una classe nidificata potrebbe essere non statica o statica e in ogni caso è una classe definita all'interno di un'altra classe . Una classe nidificata dovrebbe esistere solo per servire è racchiudere la classe , se una classe nidificata è utile da altre classi (non solo l'inclusione), dovrebbe essere dichiarata come una classe di livello superiore.

Differenza

Classe nidificata nonstatica : è implicitamente associata all'istanza di inclusione della classe contenitore, ciò significa che è possibile richiamare metodi e accedere alle variabili dell'istanza acclusa. Un uso comune di una classe nidificata nonstatica è definire una classe Adapter.

Classe nidificata statica : impossibile accedere all'enclosure della classe che racchiude e invocare metodi su di essa, quindi deve essere utilizzata quando la classe nidificata non richiede l'accesso a un'istanza della classe che la include. Un uso comune della classe nidificata statica consiste nell'implementare un componente dell'oggetto esterno.

Conclusione

Quindi la principale differenza tra i due dal punto di vista del design è la seguente: la classe nidificata non statica può accedere all'istanza della classe contenitore, mentre la statica non può .


Le classi interne e le classi statiche nidificate in Java sono entrambe classi dichiarate all'interno di un'altra classe, nota come classe di primo livello in Java. Nella terminologia Java, se dichiari una classe nidificata statica, chiamerà la classe statica nidificata in Java mentre la classe nidificata non statica viene semplicemente chiamata Classe interna.

Che cos'è Inner Class in Java?

Qualsiasi classe che non è un livello superiore o dichiarata all'interno di un'altra classe è nota come classe nidificata e da quelle classi nidificate, la classe che è dichiarata non statica è nota come classe Inner in Java. ci sono tre tipi di classe Inner in Java:

1) La classe interna locale - è dichiarata all'interno di un blocco di codice o di un metodo.
2) Classe interna anonima - è una classe che non ha nome da referenziare e inizializzare nello stesso luogo in cui viene creata.
3) La classe interna del membro - è dichiarata come membro non statico della classe esterna.

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

Qual è la classe statica nidificata in Java?

La classe statica annidata è un'altra classe dichiarata all'interno di una classe come membro e resa statica. La classe statica nidificata viene anche dichiarata come membro di una classe esterna e può essere privata, pubblica o protetta come qualsiasi altro membro. Uno dei principali vantaggi della classe statica nidificata rispetto alla classe interna è che l'istanza della classe statica nidificata non è collegata a nessuna istanza che racchiude la classe Outer. Non è inoltre necessaria alcuna istanza della classe Outer per creare un'istanza di classe statica nidificata in Java .

1) Può accedere a membri di dati statici di classe esterna incluso privato.
2) La classe nidificata statica non può accedere a membri o metodi dati non statici (di istanza) .

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

Rif: classe interna e classe statica nidificata in Java con esempio


Ho illustrato vari possibili scenari corretti e di errore che possono verificarsi nel codice 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);
                        }*/
                    //}
                }
    }

Penso che le persone qui dovrebbero notare che Poster: Static Nest Class solo solo la prima classe interna. Per esempio:

 public static class A {} //ERROR

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

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

 }

Quindi, riepilogare, la classe statica non dipende dalla classe che contiene. Quindi, non possono nella classe normale. (perché la classe normale ha bisogno di un'istanza).


Ummm ... una classe interiore È una classe annidata ... intendi classe anonima e classe interiore?

Modifica: se in realtà intendevi interiore vs anonimo ... una classe interiore è solo una classe definita all'interno di una classe come:

public class A {
    public class B {
    }
}

Mentre una classe anonima è un'estensione di una classe definita in modo anonimo, quindi nessuna "classe" viene definita, come in:

public class A {
}

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

Ulteriori modifica:

Wikipedia afferma che c'è una differenza in Java, ma ho lavorato con Java per 8 anni, ed è il primo che ho sentito una distinzione del genere ... per non parlare del fatto che non ci sono riferimenti per fare il backup del claim ... bottom linea, una classe interna è una classe definita all'interno di una classe (statica o meno) e nidificata è solo un altro termine per indicare la stessa cosa.

C'è una sottile differenza tra classi nidificate statiche e non statiche ... le classi interne fondamentalmente non statiche hanno accesso implicito ai campi di istanza e ai metodi della classe che li include (quindi non possono essere costruiti in un contesto statico, sarà un compilatore errore). Le classi nidificate statiche, d'altra parte, non hanno accesso implicito ai campi e ai metodi dell'istanza e possono essere costruite in un contesto statico.


Prima di tutto Non esiste una classe chiamata classe statica. Il modificatore statico usa con la classe interna (chiamata classe nidificata) dice che è un membro statico di classe esterna, il che significa che possiamo accedervi come con altri membri statici e senza averne istanza di classe Outer. (Quale è il vantaggio di statico in origine.)

La differenza tra l'uso della classe annidata e della classe interna normale è:

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

Per prima cosa possiamo creare un'istanza di OutClass, quindi possiamo accedere a Inner.

Ma se la classe è annidata, la sintassi è:

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

Che utilizza la sintassi statica come normale implementazione della parola chiave statica.


Quando dichiariamo una classe membro statica all'interno di una classe, è conosciuta come classe nidificata di primo livello o classe nidificata statica. Può essere dimostrato come di seguito:

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

Quando dichiariamo una classe membro non statica all'interno di una classe è conosciuta come classe interna. La classe interiore può essere dimostrata come segue:

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






inner-classes