Perché non sei in grado di dichiarare una classe come statica in Java?

Perché non sei in grado di dichiarare una classe come statica in Java?

Solo le classi nidificate possono essere statiche. In questo modo è possibile utilizzare la classe nidificata senza avere un'istanza della classe esterna.

class OuterClass{
    public static class StaticNestedClass{
    }

    public class InnerClass{
    }

    public InnerClass getAnInnerClass(){
        return new InnerClass();
    }

    //This method doesn't work
    public static InnerClass getAnInnerClassStatically(){
        return new InnerClass();
    }
}

class OtherClass{
    //Use of a static nested class:
    private OuterClass.StaticNestedClass staticNestedClass = new OuterClass.StaticNestedClass();

    //Doesn't work
    private OuterClass.InnerClass innerClass = new OuterClass.InnerClass();

    //Use of an inner class:
    private OuterClass outerclass= new OuterClass();
    private OuterClass.InnerClass innerClass2 = outerclass.getAnInnerClass();
    private OuterClass.InnerClass innerClass3 = outerclass.new InnerClass();
}

Fonti:

• Tutorial Oracle su classi nidificate

Sullo stesso argomento:

• Java: classe interna statica vs non statica
• Classe interna Java e classe nidificata statica

Le classi di livello superiore sono statiche per impostazione predefinita. Le classi interne sono non statiche per impostazione predefinita. È possibile modificare il valore predefinito per le classi interne contrassegnandole esplicitamente statiche. Le classi di livello superiore, in virtù del fatto che sono di livello superiore, non possono avere semantiche non statiche perché non può esserci alcuna classe genitore a cui fare riferimento. Pertanto, non è possibile modificare l'impostazione predefinita per le classi di livello superiore.

Quindi, arrivo tardi alla festa, ma ecco i miei due centesimi, che aggiungono filosoficamente alla risposta di Colin Hebert.

Ad alto livello la tua domanda affronta la differenza tra oggetti e tipi. Mentre ci sono molte macchine (oggetti), c'è solo una classe di auto (tipo). Dichiarare qualcosa come statico significa che stai operando nello spazio "tipo". Ce n'è solo uno. La parola chiave della classe di livello superiore definisce già un tipo nello spazio "type". Di conseguenza "Car di classe statica pubblica" è ridondante.

La classe con costruttore privato è statica.

Dichiara la tua classe in questo modo:

public class eOAuth {

    private eOAuth(){}

    public final static int    ECodeOauthInvalidGrant = 0x1;
    public final static int    ECodeOauthUnknown       = 0x10;
    public static GetSomeStuff(){}

}

e puoi usare senza inizializzazione:

if (value == eOAuth.ECodeOauthInvalidGrant)
    eOAuth.GetSomeStuff();
...

Certo che possono, ma solo classi annidate interne . Qui, significa che le istanze della classe nidificata non richiedono un'istanza chiusa della classe esterna.

Ma per le classi di alto livello, i progettisti del linguaggio non sono riusciti a pensare a qualcosa di utile da fare con la parola chiave, quindi non è permesso.

È possibile creare una classe di utilità (che non può avere istanze create) dichiarando un tipo enum senza istanze. cioè stai specificatamente dichiarando che non ci sono casi.

public enum MyUtilities {;
   public static void myMethod();
}

public class Outer {
   public static class Inner {}
}

... può essere dichiarato statico - purché sia ​​una classe membro.

Dal JLS:

Le classi membri possono essere statiche, nel qual caso non hanno accesso alle variabili di istanza della classe circostante; oppure possono essere classi interne (§8.1.3).

e qui:

La parola chiave statica può modificare la dichiarazione di un membro di tipo C all'interno del corpo di una classe non interna T. Il suo effetto è dichiarare che C non è una classe interna. Proprio come un metodo statico di T non ha un'istanza corrente di T nel suo corpo, anche C non ha un'istanza corrente di T, né ha istanze che si chiudono in modo lessicale.

Una parola chiave statica non avrebbe alcun senso per una classe di livello superiore, solo perché una classe di livello superiore non ha un tipo racchiuso.

Come spiegato sopra, una Classe non può essere statica a meno che non sia un membro di un'altra Classe.

Se stai cercando di progettare una classe "di cui non possono esserci più istanze", potresti voler esaminare il modello di progettazione "Singleton".

Informazioni per principianti Singleton qui .

Avvertimento:

Se stai pensando di usare il modello singleton, resisti con tutte le tue forze. È uno dei DesignPattern più facili da capire, probabilmente il più popolare e sicuramente il più abusato. (fonte: JavaRanch come linkato sopra)

Oltre a come Java definisce le classi interne statiche, esiste un'altra definizione di classi statiche secondo il mondo C # [1] . Una classe statica ha solo metodi (funzioni) statici ed è pensata per supportare la programmazione procedurale. Tali classi non sono realmente classi in quanto l'utente della classe è interessato solo alle funzioni di supporto e non alla creazione di istanze della classe. Mentre le classi statiche sono supportate in C #, in Java non esiste tale supporto diretto. Puoi comunque usare enum per imitare le classi statiche C # in Java in modo che un utente non possa mai creare istanze di una data classe (anche usando reflection) [2] :

public enum StaticClass2 {
    // Empty enum trick to avoid instance creation
    ; // this semi-colon is important

    public static boolean isEmpty(final String s) {
        return s == null || s.isEmpty();
    }
}

Tutto ciò che codifichiamo in Java va in una classe. Ogni volta che eseguiamo una classe JVM crea un'istanza di un oggetto. JVM può creare un numero di oggetti, per definizione Statico significa che hai lo stesso set di copie su tutti gli oggetti.

Quindi, se Java avrebbe consentito alla classe superiore di essere statica ogni volta che avvii un programma, crea un oggetto e continua a sovrascrivere nella stessa posizione di memoria.

Se stai semplicemente sostituendo l'oggetto ogni volta che lo esegui, qual è il punto di crearlo?

Questo è il motivo per cui Java si è sbarazzato dell'elettricità statica per la classe di livello superiore.

Potrebbero esserci ragioni più concrete, ma per me questo ha molto senso logico.

Le uniche classi che possono essere statiche sono le classi interne. Il seguente codice funziona perfettamente:

public class whatever {
    static class innerclass {
    }
}

Il punto delle classi interne statiche è che non hanno un riferimento all'oggetto classe esterno.

Penso che sia possibile facile come bere un bicchiere di caffè !. Dai un'occhiata a questo. Non usiamo esplicitamente parole chiave statiche durante la definizione della classe.

public class StaticClass {

    static private int me = 3;
    public static void printHelloWorld() {
       System.out.println("Hello World");
    }



    public static void main(String[] args) {
        StaticClass.printHelloWorld();
        System.out.println(StaticClass.me);
    }
}

Non è una definizione di classe statica? Usiamo solo una funzione associata solo a una classe. Fai attenzione che in questo caso possiamo usare un'altra classe in quella nidificata. Guarda questo:

class StaticClass1 {

    public static int yum = 4;

    static void  printHowAreYou() {
        System.out.println("How are you?");
    }
}

public class StaticClass {

    static int me = 3; 
    public static void printHelloWorld() {
       System.out.println("Hello World");
       StaticClass1.printHowAreYou();
       System.out.println(StaticClass1.yum);
    }



    public static void main(String[] args) {
        StaticClass.printHelloWorld();
        System.out.println(StaticClass.me);
    }
}

PlatformUIIn Eclipse si può cercare una classe con metodi statici e costruttore privato con se stesso definitivo.

public final class <class name>
{
   //static constants
   //static memebers
}

se il vantaggio dell'uso di una classe statica non era di creare un'istanza di un oggetto e di utilizzare un metodo, dichiarare semplicemente la classe come pubblica e questo metodo come statico.