[JAVA] Tipo statico non deferenziabile

[Mega-X]

Il problema è molto breve et semplice:

Ho un interfaccia Albero parametrizzata rispetto ad un parametro T che estende Comparable<? super T>.
Successivamente ho implementato questa interfaccia creando una classe AlberoAstratto, e, quindi, ho esteso quest'ultima classe in MioAlbero.

Ovviamente ho la necessità di fornire all'utente utilizzatore la possibilità di costruire quest'albero, dunque ho creato un costruttore MioAlbero(String) che, tramite una stringa, si costruisce l'albero.

Per ragioni di comodità ho la necessità di memorizzarmi il nodo padre, dunque scrivo la seguente riga di codice:

private static Albero<T> padre;

Ma il compilatore si arrabbia dicendomi che il parametro T non può essere dereferenziato in modo statico visto che tale classe si riferisce ad un contesto non statico.

Che debbo fare?

Eccovi tutto il codice scritto fino ad ora:

package mio;

public class MioAlbero<T extends Comparable<? super T>> extends AlberoAstratto<T>
{
	
	private T info;
	private static Albero<T> padre;
	//public static <T> Albero<T> boh() { }
	private Albero<T> dx;
	private Albero<T> sx;
	
	private class Navigable
	{
		public Navigator Navigator() { return new Navigator(); }
		
		private class Navigator
		{
			private Albero<T> curr;
			public Navigator() { curr = padre; }
		}
	}
	
	public  MioAlbero(String s) {  }
	private MioAlbero(T t) { info = t; }
	
	public T getInfo() { return info; }
	public void setInfo(T t) { info = t; }
	
	@Override
	public Albero<T> SottoAlberoDx() { return dx; }
	
	@Override
	public Albero<T> SottoAlberoSx() { return sx; }
	
	@Override
	public boolean EVuoto() { return ((info == null) && (dx == null) && (sx == null)); }
	
	@Override
	public void Inserisci(T cosa) { Inserisci(cosa, null); }
	
	@Override
	public void Inserisci(T cosa, Albero<T> dove) {
		if (cosa == null) throw new IllegalArgumentException("Si sta tentando di passare null!");
		Albero<T> nuovo = new MioAlbero<T>(cosa);
		
	}
	
	@Override
	public T Modifica(Albero<T> chi, T cosa) {
		// TODO Auto-generated method stub
		return null;
	}
	
	@Override
	public T Modifica(T chi, T cosa) {
		// TODO Auto-generated method stub
		return null;
	}
	
	@Override
	public T Rimuovi(Albero<T> cosa) {
		// TODO Auto-generated method stub
		return null;
	}
	
	@Override
	public T[] Rimuovi(T cosa) {
		// TODO Auto-generated method stub
		return null;
	}
	
}

(Non fate caso alle imperfezioni che ci sono qua e là, al di fuori della definizione di padre )

[andbin]

Originariamente inviato da Mega-X

private static Albero<T> padre;

Ma il compilatore si arrabbia dicendomi che il parametro T non può essere dereferenziato in modo statico visto che tale classe si riferisce ad un contesto non statico.

Vuoi la risposta breve? I tipi parametrici della classe non possono essere usati in membri statici (variabili/metodi) della classe.

La risposta lunga è: i generics sono implementati tramite "erasure". Ovvero MioAlbero<String>, MioAlbero<Integer> o MioAlbero<QualunqueAltro> condividono un unico bytecode implementato in una unica classe MioAlbero.class.
I membri statici sono condivisi da tutte le possibili istanze della classe. Quindi è ovvio che un membro statico non saprebbe (e infatti non può) come usare il tipo parametrico di una istanziazione specifica.

Questo tra l'altro è rimarcato quando si chiede il class "literal", dove non è sintatticamente corretto fornire un tipo parametrico.

Class<?> k = MioAlbero.class;   // OK
Class<?> k = MioAlbero<String>.class;   // NO, errore!!!

E tornando al tuo problema: perché quel reference al padre dovresti averlo "static"?? Io non ne vedo il motivo.

[Mega-X]

Ups, mi son totalmente scordato della type erasure. Il mio professore m'avrebbe ucciso se m'avesse sentito!

Per quanto riguarda la questione di dichiarare padre come static è stata una mia dimenticanza del fatto che la classe MioAlbero l'avevo creata in modo ricorsivo.

Grazie per il tempo dedicatomi.