Statico rispetto a non statico in Java in termini di stato della memoria

I dati statici (campi e membri) vengono caricati in memoria sul caricamento della classe e rimangono fino a quando la classe non viene scaricata dalla memoria (in genere sulla terminazione JVM).

I dati regolari vengono creati durante l'istanziazione di un'istanza di oggetto e diventano idonei per la garbage collection quando l'istanza non è inclusa nell'ambito. Quando viene rilasciato dalla memoria non può essere previsto in quanto ciò dipende dal garbage collector che potrebbe decidere di non rimuovere nulla finché la memoria non raggiunge un certo limite che può essere raggiunto o meno prima che la JVM termini.

Il modo in cui la JVM gestisce la memoria dipende dalla versione e dal creatore della JVM (ad esempio una JVM Oracle potrebbe differire da quella di IBM) e, naturalmente, dal sistema operativo di destinazione.

Ecco un esempio che dimostra i casi menzionati nella tua domanda:

public class Example {
    // each instance of Example has its own:
    String instanceField;
    // only one of these exists (per classloader):
    static String classField;

    String instanceMethod() {
        // Here we can access both members.
        // tmp is located in stack so each invocation of this method
        // has its own:
        String tmp = instanceField + classField;
        return tmp;
    }

    static String classMethod() {
        // Here we cannot access instanceField.
        // tmp is located in stack so each invocation of this method
        // has its own:
        String tmp = classField + ".";
        return tmp;
    }
}

La variabile tmp come reference è nello stack, ma ovviamente l'oggetto String si trova nell'heap. Forse è fuori portata qui, ed è sufficiente dire che i metodi non hanno "membri", hanno solo un'area allocata localmente nello stack.

... the concept of static vs non-static variable ...

La variabile parola di solito si riferisce a una variabile locale in un metodo, che viene istanziata durante l'attivazione del metodo, nella pila di thread. Questi non possono essere dichiarati statici in Java (alcuni linguaggi come C lo consentono, ma questa è un'altra questione).

In Java, solo i membri della classe, che sono campi e amp; metodi, possono essere dichiarati statici (cioè non variabili locali).

I campi statici appartengono direttamente alla classe e sono inizializzati quando la classe viene caricata e persistono la durata della classe; c'è solo al massimo uno di ogni campo statico nell'intero programma. (Dico al più perché prima che la classe sia caricata, allora ci sono zero dei suoi campi statici.)

I campi dell'istanza (non statici) vengono inizializzati quando un'istanza (un oggetto della classe) viene creata e mantenuta per la durata dell'istanza. Ogni istanza ha i propri campi (di istanza) (non statici).

When an object in[sic] created (without static keyword), each object will have its own member variables.

Vero che ogni oggetto avrà la propria copia dei campi di istanza. Ma per essere chiari, gli oggetti vengono creati usando la parola chiave new , non c'è alcun concetto di static qui - non è possibile creare un oggetto statico in Java, solo i campi statici possono essere dichiarati, sebbene questi possano essere riferimenti all'istanza oggetti (non statici)!

Also in terms of memory ... But how about methods, do they have they own member methods in memory space?

I metodi hanno due cose: codice e attivazioni. Un'attivazione rappresenta l'istanziazione del metodo; questo viene fatto in fase di esecuzione eseguendo un costrutto di richiamo del metodo; i metodi vengono attivati anziché creati.

Quando viene invocato un metodo, il metodo viene attivato creando un frame (un frame stack) sullo stack del thread corrente. Questa attivazione contiene, tra le altre cose, i valori dei parametri passati dall'invocatore (insieme alla conoscenza di cosa eseguire successivamente quando il metodo ritorna e il relativo frame di attivazione associato viene rimosso dallo stack di thread).

Il codice esiste come bytecode (e concettualmente) solo una volta per classe, indipendentemente dall'istanza statica rispetto a quella (non statica).

La differenza è che i metodi di istanza devono essere invocati con quello che a volte viene chiamato oggetto destinatario e avere accesso a questa istanza (oggetto) tramite la parola chiave this , mentre i metodi statici non possono essere richiamati tramite un ricevitore e quindi non hanno una parola chiave this a loro disposizione.

Ciò significa che i metodi bytecode per istanza forniscono l'uso della parola chiave this e un frame di attivazione per un metodo di istanza contiene una variabile locale che viene utilizzata per il parametro this . Indipendentemente da chi sta eseguendo l'invocazione di un metodo di istanza, durante tale chiamata è necessario fornire alcuni oggetti destinatario.

In termini di spazio di memoria, i metodi di istanza sono effettivamente dati / prendono un parametro extra "nascosto", quindi lo spazio di memoria si presenta sullo stack di attivazione come variabile locale di riferimento aggiuntiva. (Per tua informazione, questo è considerato un uso relativamente limitato dello spazio.)

Static methods can’t use non-static(regular) methods in terms of memory space.

I metodi statici non vengono mai richiamati utilizzando un oggetto destinatario e pertanto non dispongono della parola chiave this a loro disposizione. Fondamentalmente, questa è l'unica differenza: possono altrimenti fare qualsiasi cosa che altri metodi possono fare, incluso il richiamo dei metodi di istanza, purché non utilizzino la parola chiave this .

I metodi statici possono invocare metodi di istanza se ottengono in altro modo un riferimento a un'istanza. Questo potrebbe essere passando loro un riferimento istanza esplicito come parametro, oppure potrebbero localizzare un'istanza in qualche altro modo, ad es. seguendo una struttura dati ad un'istanza, o come valore di ritorno da qualche altro metodo. Ovviamente, possono invocare metodi di istanza di qualsiasi tipo per i quali hanno riferimenti, a condizione che i modificatori di accesso pubblici / privati appropriati lo supportino, proprio come gli altri metodi. Pertanto, possono invocare metodi utilizzando variabili locali (ad esempio x.ToString() ) L'unica limitazione è che non possono utilizzare la parola chiave this (ad esempio this.ToString() ).

(Dal punto di vista dello stile, tuttavia, i campi e i metodi statici sono disapprovati, anche se dal momento che questa non è la tua domanda, ti permetterò di effettuare una ricerca su quello.)