[Java] Stack - Heap

[ragnonerodocet]

Mi sto preparando per un esame: dunque chiedo

in un'operazione del genere:

String a = new String ("Adriano");

cosa viene memorizzato nella stack e cosa nell'heap?

[andbin]

Originariamente inviato da ragnonerodocet
Mi sto preparando per un esame: dunque chiedo

in un'operazione del genere:

String a = new String ("Adriano");

cosa viene memorizzato nella stack e cosa nell'heap?

Ammesso che quella variabile 'a' sia locale allora essa risiede sullo stack. Sul heap invece ci sarà l'oggetto String istanziato.

[ragnonerodocet]

Allora faccio diversi esempi:

mettiamo di avere un metodo simile:

1-

public int example ( int a ) [

int t = 0;
return t += a;

]

Se non sbaglio, le variabili a e t vengono poste nello stack, nel quale si genera un frame in esecuzione una volta chiamato il metodo (per esempio, example (5))con 2 campi, uno inizializzato a 5 e uno contenente il risultato. Una volta restituito il tutto col return TUTTO IL FRAME VIENE DISTRUTTO.

E' vero tutto ciò?


2 -
E se invece di un int restituivo un tipo di dato non primitivo, quale un oggetto da me creato?

public Persona example ( Persona a ) [

return a;

]

Poi poi poi...

3 - Se dichiaro qualsiasi cosa static va nell'heap?

4 - E i parametri passati al costruttore dove vanno?

[ragnonerodocet]

5 - e se qualsiasi dei 2 metodi dichiarati prima fosse stato dichiarato static?

6 - Nel caso di creazione di un'istanza

Persona p = new Persona ("Adriano", "Fannullone");

dove vanno a finire p e i due parametri?

7 - C'è differenza nel caso in cui p venga dichiarata in un metodo o fuori da un metodo?

[andbin]

Le variabili locali (e vale anche per i parametri di metodi/costruttori) sono sempre sullo stack, indipendentemente dal tipo (primitivo o reference).

Gli oggetti, gli array e le variabili di istanza (che ovviamente sono nell'oggetto) sono sempre sul heap.

Anche le variabili static ("di classe") sono sempre sul heap.

[ragnonerodocet]

A questo punto vi chiedo una cosa:

ho questo pezzo di codice:

Class MiaClasse [

private int a;
private int b = 1;
private static String c = "BABBA";
private AltraClasse d = new AltraClasse ( 10, 20, "CIAO");

public int getSomma ( int a, int b) [
return a + b;
]

]

Vorrei sapere, se possibile, cosa viene allocato in memoria a compile time e cosa viene allopcato in memoria nel run time.

E per esempio, nel caso sopra, è la variabile "c" che va nell'heap (essendo statica) o il valore "BABBA", oppure cosa???

[andbin]

Originariamente inviato da ragnonerodocet
Vorrei sapere, se possibile, cosa viene allocato in memoria a compile time

Il compile time non centra ... genera solo il bytecode.

Originariamente inviato da ragnonerodocet
E per esempio, nel caso sopra, è la variabile "c" che va nell'heap (essendo statica) o il valore "BABBA", oppure cosa???

La variabile 'c' è statica, quindi è allocata sul heap. Le variabili 'a', 'b' e 'd' sono di istanza, quindi quando viene istanziato un oggetto MiaClasse esse fanno parte dell'oggetto che è allocato sul heap. Inoltre a 'd' viene assegnato il reference ad un altro oggetto anch'esso allocato sul heap.

Le stringhe literal "BABBA" e "CIAO" sono degli oggetti che vengono messi nel "constant pool". Stando alla documentazione Runtime Data Areas un constant pool è allocato nella "method area" che tecnicamente fa parte del heap ma viene trattato in modo particolare (generalmente, ma poi dipende dalla implementazione specifica, gli oggetti nel constant pool non sono mai collezionati dal gc).

Spero di aver detto tutto giusto, comunque basta leggere la Java Virtual Machine Specification che spiega in modo dettagliato queste cose.

[ragnonerodocet]

Allora faccio una domanda per vedere se ho capito di cosa si sta parlando.

Nello heap c'è tutto ciò che preesiste all'esecuzione del programma: tutto ciò che è statico per esempio.

Nell'esempio precedente, a, b e d, essendo variabili d'istanza, vengono salvate sullo stack nel momento in cui viene creato mediante new un oggetto di tipo MiaClasse.
Ovvero, se sto nel main, con l'istruzione

MiaClasse myClass = new MiaClasse ();

creo nello stack una variabile di tipo reference chiamata myClass che punta ad un oggetto di tipo MiaClasse.

Sbaglio?

[andbin]

Originariamente inviato da ragnonerodocet
Nello heap c'è tutto ciò che preesiste all'esecuzione del programma: tutto ciò che è statico per esempio.

Dalla documetazione:

The Java virtual machine has a heap that is shared among all Java virtual machine threads. The heap is the runtime data area from which memory for all class instances and arrays is allocated.

Il heap è quindi l'area in cui si possono allocare oggetti (anche gli array sono oggetti). Non si può allocare sul heap es. un tipo primitivo ... solo oggetti.

Originariamente inviato da ragnonerodocet
Nell'esempio precedente, a, b e d, essendo variabili d'istanza, vengono salvate sullo stack

No, a/b/c/d sono variabili messe sul heap. a/b/d poi sono di istanza e fanno parte di ogni oggetto MiaClasse allocato sul heap.

Originariamente inviato da ragnonerodocet
Ovvero, se sto nel main, con l'istruzione

MiaClasse myClass = new MiaClasse ();

creo nello stack una variabile di tipo reference chiamata myClass che punta ad un oggetto di tipo MiaClasse.

Ok.

[ragnonerodocet]

Vediamo se ho capito il tutto...

Quando scrivo:

MiaClasse myClass = new MiaClasse ();

succede questo:

la variabile reference è creata DINAMICAMENTE nello stack del programma, che terrà conto di tale variabile finchè il programma in run time avrà bisogno di essa.

Tale variabile punta ad un oggetto di tipo MiaClasse allocato (STATICAMENTE???) nell'heap.

E come fa tale oggetto a puntare a sua volta ai campi a, b, c e d?