reference cannot - In parole povere, cosa significa "statico" in Java?




make to (6)

statico indica che la variabile o il metodo contrassegnato come tale è disponibile a livello di classe. In altre parole, non è necessario creare un'istanza della classe per accedervi.

public class Foo {
    public static void doStuff(){
        // does stuff
    }
}

Quindi, invece di creare un'istanza di Foo e quindi chiamare doStuff questo modo:

Foo f = new Foo();
f.doStuff();

Basta chiamare il metodo direttamente contro la classe, in questo modo:

Foo.doStuff();

Questa domanda ha già una risposta qui:

Mi è stato detto diverse definizioni per questo, ho guardato su Wikipedia, ma come principiante di Java non sono ancora sicuro di cosa significhi. Qualcuno che parla fluentemente Java e idiota?


I punti sopra sono corretti e voglio aggiungere alcuni punti più importanti sulla parola chiave statica.

Internamente ciò che accade quando si utilizza la parola chiave statica è che verrà memorizzato nella memoria permanente (cioè nella memoria heap ), sappiamo che ci sono due tipi di memoria che sono memoria di stack (memoria temporanea) e memoria heap (memoria permanente), quindi se non si utilizza la parola chiave statica, la memoria temporanea verrà archiviata nella memoria di stack (oppure è possibile chiamarla memoria volatile ).

quindi avrai un dubbio che a che serve questo diritto ???

esempio : static int a = 10; (1 programma)

solo ora ho detto se si usa la parola chiave statica per variabili o per il metodo che verrà memorizzato nella memoria permanente a destra.

quindi ho dichiarato la stessa variabile con la parola chiave static in un altro programma con un valore diverso.

esempio : static int a = 20; (2 programma)

la variabile 'a' è memorizzata nella memoria heap dal programma 1. la stessa variabile statica 'a' si trova nel programma 2 in quel momento non creerà ancora una variabile 'a' nella memoria heap invece che sostituirà solo il valore di un da 10 a 20 .

In generale creerà ancora una variabile 'a' nella memoria dello stack (memoria temporanea) se non dichiarerai 'a' come variabile statica.

nel complesso posso dire che, se usiamo la parola chiave statica
1. possiamo risparmiare memoria
2. possiamo evitare duplicati
3. Non c'è bisogno di creare oggetti per accedere alla variabile statica con l'aiuto del nome della classe, è possibile accedervi.


La parola chiave static può essere utilizzata in molti modi diversi in Java e in quasi tutti i casi è un modificatore che significa che la cosa che sta modificando è utilizzabile senza un'istanza di oggetto che lo racchiude .

Java è un linguaggio orientato agli oggetti e per impostazione predefinita gran parte del codice che scrivi richiede un'istanza dell'oggetto da utilizzare.

public class SomeObject {
    public int someField;
    public void someMethod() { };
    public Class SomeInnerClass { };
}

Per utilizzare alcuni campi, alcuni metodi o SomeInnerClass devo prima creare un'istanza di SomeObject .

public class SomeOtherObject {
    public void doSomeStuff() {
        SomeObject anInstance = new SomeObject();
        anInstance.someField = 7;
        anInstance.someMethod();
        //Non-static inner classes are usually not created outside of the
        //class instance so you don't normally see this syntax
        SomeInnerClass blah = anInstance.new SomeInnerClass();
    }
}

Se dichiaro quelle cose statiche, esse non richiedono un'istanza che le racchiude .

public class SomeObjectWithStaticStuff {
    public static int someField;
    public static void someMethod() { };
    public static Class SomeInnerClass { };
}

public class SomeOtherObject {
    public void doSomeStuff() {
        SomeObjectWithStaticStuff.someField = 7;
        SomeObjectWithStaticStuff.someMethod();
        SomeObjectWithStaticStuff.SomeInnerClass blah = new SomeObjectWithStaticStuff.SomeInnerClass();
        //Or you can also do this if your imports are correct
        SomeInnerClass blah2 = new SomeInnerClass();
    }
}

Dichiarare qualcosa di statico ha diverse implicazioni.

Innanzitutto, è possibile sempre un solo valore di un campo statico nell'intera applicazione .

public class SomeOtherObject {
    public void doSomeStuff() {
        //Two objects, two different values
        SomeObject instanceOne = new SomeObject();
        SomeObject instanceTwo = new SomeObject();
        instanceOne.someField = 7;
        instanceTwo.someField = 10;
        //Static object, only ever one value
        SomeObjectWithStaticStuff.someField = 7;
        SomeObjectWithStaticStuff.someField = 10; //Redefines the above set
    }
}

Il secondo problema è che i metodi statici e le classi interne non possono accedere ai campi nell'oggetto che lo racchiude (poiché non ce n'è uno).

public class SomeObjectWithStaticStuff {
    private int nonStaticField;
    private void nonStaticMethod() { };

    public static void someStaticMethod() {
        nonStaticField = 7; //Not allowed
        this.nonStaticField = 7; //Not allowed, can never use *this* in static
        nonStaticMethod(); //Not allowed
        super.someSuperMethod(); //Not allowed, can never use *super* in static
    }

    public static class SomeStaticInnerClass {

        public void doStuff() {
            someStaticField = 7; //Not allowed
            nonStaticMethod(); //Not allowed
            someStaticMethod(); //This is ok
        }

    }
}

La parola chiave statica può anche essere applicata a interfacce interne, annotazioni ed enumerazioni.

public class SomeObject {public static interface SomeInterface {}; public static @interface SomeAnnotation {}; public static enum SomeEnum {}; }

In tutti questi casi la parola chiave è ridondante e non ha alcun effetto. Interfacce, annotazioni ed enumerazioni sono statiche di default perché non hanno mai una relazione con una classe interna.

Questo descrive solo cosa fa la parola chiave. Non descrive se l'uso della parola chiave sia una cattiva idea o meno. Questo può essere trattato in modo più dettagliato in altre domande, ad esempio l' utilizzo di molti metodi statici come una cosa negativa?

Ci sono anche alcuni usi meno comuni della parola chiave static. Esistono importazioni statiche che consentono di utilizzare i tipi statici (comprese le interfacce, le annotazioni e le enumerazioni non contrassegnate in modo ridondante statico) non qualificate.

//SomeStaticThing.java
public class SomeStaticThing {
    public static int StaticCounterOne = 0;
}

//SomeOtherStaticThing.java
public class SomeOtherStaticThing {
    public static int StaticCounterTwo = 0;
}

//SomeOtherClass.java
import static some.package.SomeStaticThing.*;
import some.package.SomeOtherStaticThing.*;

public class SomeOtherClass {
    public void doStuff() {
        StaticCounterOne++; //Ok
        StaticCounterTwo++; //Not ok
        SomeOtherStaticThing.StaticCounterTwo++; //Ok
    }
}

Infine, esistono inizializzatori statici che sono blocchi di codice che vengono eseguiti quando la classe viene caricata per la prima volta (che di solito è appena prima che una classe venga istanziata per la prima volta in un'applicazione) e (come i metodi statici) non possono accedere ai campi non statici o metodi.

public class SomeObject {

    private static int x;

    static {
        x = 7;
    }
}

Mi scuso se questo va più nel dettaglio del necessario, mi è stato chiesto di spostare questa risposta qui da un'altra domanda dove il dettaglio era un po 'più appropriato.


Oltre a ciò che @inkedmn ha sottolineato, un membro statico è a livello di classe. Pertanto, il suddetto membro viene caricato in memoria dalla JVM una volta per quella classe (quando la classe viene caricata). Cioè, non ci sono n istanze di un membro statico caricato per n istanze della classe a cui appartiene.


In termini molto laici la classe è uno stampo e l'oggetto è la copia realizzata con quella muffa. Statico appartiene allo stampo e può essere consultato direttamente senza fare alcuna copia, da qui l'esempio sopra


In Java, quando a volte esegui JVM dalla riga di comando utilizzando l'eseguibile java e stai provando ad avviare un programma da un file di classe con public static void main (PSVM), potresti eseguire l'errore seguente anche se il parametro classpath la JVM è accurata e il file di classe è presente sul classpath:

Error: main class not found or loaded

Questo succede se non è possibile caricare il file di classe con PSVM. Una possibile ragione è che la classe stia implementando un'interfaccia o estendendo un'altra classe che non si trova sul classpath. Normalmente se una classe non è sul classpath, l'errore lanciato indica come tale. Ma, se la classe in uso è estesa o implementata, java non è in grado di caricare la classe stessa.

Riferimento: https://www.computingnotes.net/java/error-main-class-not-found-or-loaded/





java static reference