[JAVA] Piccolo dubbio sugli array

[D4rkAng3l]

Sul compito d'esame la professoressa mette quasi sempre un esercizio dove dato un pezzo di codice di una classe e di un main dobbiamo mostrare cosa succede in memoria (stack ed heap)...ora non mi serve sapere come si fà perchè bene o male me la cavicchio...ho solo un dubbio allucinante sugli array (lo sò è una cosa stupida e credo di sapere la risposta ma il dubbio permane in me)

Se ho il seguente codice:

public class StranoOggetto {
       private int[] A;
    
       /** COSTRUTTORE:
           @param un array di interi
           @return un oggetto istanza della classe StranoOggetto */
       public StranoOggetto (int[] V) {
           int i;
           A = new int[V.length];		// Cosruisci A della stessa lunghezza del parametro ricevuto dal costruttore

           for (i=0; i<A.length; i++) A[i] = V[i]; 	// Copia in A gli elementi di V
       }

       public int[] getArray() {
			return A; 
		}
}

public class Test {
	public static void main(String[] args) {
		int i;
		int[] x={4,5,6};
		StranoOggetto C = new StranoOggetto(x);
		b = “domani”;
		x[0] = 48; // 1
		x = C.getArray()
		x[0]++; // 2
	}
}

dove il primo codice è la classe StranoOggetto e l'altro codice è una classe di test che contiene il metodo main()

Il mio dubbio è riferito a cosa succede in memoria quando viene eseguito il costruttore della classe StranoOggetto

Quanto eseguo l'operazione:
for (i=0; i<A.length; i++) A[i] = V[i]; // Copia in A gli elementi di V

io stò copiando fisicamente tutti i valori interi presenti in V dentro ad A e non i riferimenti a tale valori, giusto? (perchè sono valori primitivi).

Mentre invece se avessi avuto che A e V erano vettor di oggetti, allora facendo A[i] = V[i] avrei copiato nelle celle di memoria di A i riferimenti agli oggetti che erano nelle celle di memoria di V.

Ho capito bene?

Grazie
Andrea

[andbin]

Originariamente inviato da D4rkAng3l
io stò copiando fisicamente tutti i valori interi presenti in V dentro ad A e non i riferimenti a tale valori, giusto? (perchè sono valori primitivi).

Esatto.

Originariamente inviato da D4rkAng3l
Mentre invece se avessi avuto che A e V erano vettor di oggetti, allora facendo A[i] = V[i] avrei copiato nelle celle di memoria di A i riferimenti agli oggetti che erano nelle celle di memoria di V.

Esatto.

[D4rkAng3l]

Ok ti ringrazio,
e tanto per approfondire bene...
un array è un intero, quindi starà nello heap e non nella stack, ogni oggetto punta a sua volta nello heap al record di allocazione della sua classe (che eventualmente contiene le variabili di classe ed il codice dei metodi di classe).

Quindi quando nel main si esegue l'istruzione: int[] x={4,5,6};

nella stack ho la variabile X che è un riferimento all'oggetto array nello heap che a suavolta punta al proprio record di allocazione della sua classe nello heap int[]

Giusto?

[andbin]

Originariamente inviato da D4rkAng3l
un array è un intero, quindi starà nello heap e non nella stack, ogni oggetto punta a sua volta nello heap al record di allocazione della sua classe (che eventualmente contiene le variabili di classe ed il codice dei metodi di classe).

Il contenuto di un array (di qualunque tipo) è sempre sul heap. Il reference ad un array può stare sul heap (es. campo A di StranoOggetto) o sullo stack (es. variabile locale x nel tuo main).

[D4rkAng3l]

No forse mi sono espresso male.
Intendevo che ogni oggetto ha al suo interno un riferimento al proprio record di allocazione della sua classe.
Praticamente quando dichiaro un oggetto (prima di costruirlo) nell'heap si crea il record di attivazione di tale classe. Poi quando costruisco tale oggetto esso viene messo nello heap e c'ha un riferimento al record di allocazione della sua classe (che dovrebbe contenere le variabili di classe ed il codice dei metodi di classe, se non erro...)

Per fare un esempio, nel main ho:

String a; // e nell'heap viene messo il record di allocazione della classe String

a = "Pippo"; // Viene creato l'oggetto nell'heap il cui riferimento è posto in a nella stack. Tale oggetto al suo interno contiene a sua volta un riferimento al record di attivazione della classe String nell'heap