Ciao,
posto parte dell'esercitazione trovata sul sito della mia proff circa le liste concatenate in Java. Tale esercitazione prevede di implementare una lista concatenata tramite l'uso di 2 classi: una che rappresenta oggetti nodo ed una che rappresenta la lista vera e propria e che usa la classe nodo.

Ho qualche dubbio sulla correttezza del mio materiale didattico e spero che possiate illuminarmi

La classe NodoInt è:
codice:
/** Classe che rappresenta e gestisce singoli nodi di una lista concatenata; Gli oggetti sono MUTABILI */

public class NodoInt{
	private int valore;				// Valore di tipo intero contenuto nel nodo (è il campo informazione del nodo)
	private NodoInt successivo;		// Contiene il riferimento ad un oggetto di tipo NodoInt che contiene l'elemento successivo
	
	/** COSTRUTTORE :crea un nodo il cui valore è quello del parametro e che non è concatenato ad alcun altro nodo */

	public NodoInt(int n){
		valore = n;						// Nel campo valore del nuovo nodo creato viene messo il valore del parametro
		successivo = null;				// Nel campo successivo viene messo il valore null: il nuovo nodo non punta a niente
	}
	
	/** Accede in lettura al valore del nodo oggetto ricevente */
	
	public int getValore(){
		return valore;				// Ritorna il valore contenuto nel nodo oggetto ricevente
	}
	
	/** Accede in lettura al riferimento al nodo che segue il nodo oggetto ricevente. *NB: Espone l'oggetto ricevente a
	    possibili effetti collaterali */
	
	public NodoInt getSuccessivo(){
		return successivo;
	}
	
	/** Configura l'oggetto ricevente in modo tale da avere il parametro come successore. *NB: Modifica l'oggetto ricevente */
	
	public void setSuccessivo(NodoInt altro){
		this.successivo = altro;
	}
	
	/** Fornisce una rappresentazione in forma di stringa dell'oggetto ricevente */
	
	public String toString(){
		String s = " " + valore + "";
		
		if(successivo != null) s+= "->":
		
		return s;
	}
}
La casse ListaDiInteri (per ora ho messo solo i 2 metodi che a mio avviso potrebbeo essere sbagliati) è:

codice:
/** Classe che rappresenta e gestisce una lista concatenata di nodi che contengono valori interi; Gli oggetti sono MUTABILI */

public class ListaDiInteri{
	
	private NodoInt N;			// Primo nodo della lista
	
	/** COSTRUTTORE: Crea un nuovo oggetto ListaDiInteri che inizialmente è una lista vuota*/
	
	public ListaDiInteri(){
		N = null;				// Il primo nodo è inizialmente un elemento nullo
	}
	
	/** Se il nodo parametro non ha successori lo aggiunge in testa alla lista alla lista, altrimenti crea un nodo il cui
	    valore coincide con quello del parametro e lo aggiunge in testa alla lista. *NB: Modifica l'oggetto ricevente */
	  
	public void aggiungiInTesta(NodoInt altro){
		NodoInt T = new NodoInt(altro.getValore());	// Costruisce un nuovo nodo T avente il valore di altro
		T.setSuccessivo(N);			// Il nodo T è diventatola la nuova testa della lista e punta alla vecchia testa
		N = altro;
	}
	
	/** Crea un nodo il cui valore coincide con il parametro di tipo intero e lo aggiunge in testa alla lista.
	    *NB: Modifica l'oggetto ricevente */
	  
	public void aggiungiInTesta(int n){
		NodoInt T = new NodoInt(n);
		T.setSuccessivo(N);
		N = altro;
	}
}
Secondo me i due metodi aggiungiInTesta che appunto aggiungono in testa un nuovo nodo sono concettualmente sbagliati perchè:

1) Il primo dei due metodi prende come parametro un oggetto NodoInt di nome altro (per semplicità consideriamolo senza successori) e modifica l'oggetto ricevente (una lista) mettendolo in testa alla lista.

Per fare ciò crea un nodo T copia dell'oggetto altro ricevuto (copia il valore di altro nel campo valore del nuovo nodo T).
Poi modifica il campo successivo del nodo T appena creato e lo fà puntare alla lista N (praticamente lo fà puntare alla vecchia testa della lista N). Ok...fino quì tutto bene credo...la cosa che mi turba è l'istruzione:
N = altro;
Perchè?!?! altro era il parametro che era stato copiato in T...non dovrebbe essere:
N = T; ?!?!
Cioè ho creato un nuovo nodo T che contiene la copia di altro, ho fatto puntare T alla vecchia testa della lista N ed ora devo modificare N e dire che la nuova testa è T...

Anche nel secondo metodo mi impiccio su questa cosa...ha sbagliato la poff o sono io che non vedo qualcosa?

Grazie
Andrea