Wildcards

[Neptune]

Stavo cercando di comprendere il seguente esempio di wildcards:

package Pack;

import java.util.ArrayList;

class Fruit{}
class Apple extends Fruit{}
class Orange extends Fruit{}

public class older<T> {
	private T value;
	public older(){}
	public older(T val){value = val;}
	public T get(){return value;}
	public void set(T val){value = val;}
	
	static public void main(String[] args)
	{
		older<? extends Fruit> fruit = new older<Apple>();
		Fruit p = fruit.get();
		
		//Non si può fare, perchè?
		//fruit.set(new Apple());
	}

}

Quello che mi sfugge è perchè il get non da problemi mentre il set si?

L'unica motivazione che mi è venuta in mente è che in caso di get tu fai un assegnazione ad una variabile di tipo Fruit, quindi sei sicuro che qualsiasi oggetto contenuto in older sarà una sua sottoclasse.

Riguardo al set invece il problema potrebbe essere che tu sostanzialmente potresti istanziarlo come qualsiasi sotto tipo di fruit. Ad esempio potresti istanziarlo come new older<GreenApple> dove magari GreenApple estende apple. A quel punto tu non sai con cosa hai istanziato older e se passi ad esempio un Apple sarà sottoclasse di Fruit (e quindi vale il polimorfismo) ma non sottoclasse di GreenApple (bensì superlcasse) e genererebbe errore. E' cosi?

Ovvero il compilatore in un metodo che ritorna un qualcosa con questo tipo di wildcards non ha problemi, perchè tanto guarda il tipo della variabile su cui effettui l'assegnazione. Se invece viene passata come parametro non saprebbe identificarla e quindi non te lo fa fare.

E' questo il succo del discorso oppure ho fatto solo una gran confusione?

[VincenzoTheBest]

Originariamente inviato da Neptune
Stavo cercando di comprendere il seguente esempio di wildcards:

package Pack;

import java.util.ArrayList;

class Fruit{}
class Apple extends Fruit{}
class Orange extends Fruit{}

public class older<T> {
	private T value;
	public older(){}
	public older(T val){value = val;}
	public T get(){return value;}
	public void set(T val){value = val;}
	
	static public void main(String[] args)
	{
		older<? extends Fruit> fruit = new older<Apple>();
		Fruit p = fruit.get();
		
		//Non si può fare, perchè?
		//fruit.set(new Apple());
	}

}

Qui è spiegato bene il motivo. La cosa vale per i wildcards in generale.

[Neptune]

Originariamente inviato da VincenzoTheBest
Qui è spiegato bene il motivo. La cosa vale per i wildcards in generale.

Sinceramente non mastico bene l'inglese e benchè l'ho letto con attenzione non sono riuscito a comprendere molto bene la pagina.

Ma quindi mi puoi confermare che quello che ho scritto è giusto?

Cioè dal link ho capito che "? extends Fruit" può essere qualsiasi sottoclasse di Fruit, quindi se effetuiamo in get() credo che alla fin fine possiamo far fede al tipo dell'oggetto a cui lo stiamo assegnando, basta che sia un Fruit e tutto va bene tanto saranno tutte sottoclassi.

Se invece facciamo un set non so se posso passargli un Fruit, o un Apple, ed ecco che non mi ci fa passare proprio nulla.

Invece quando noi facciamo "? super Fruit" noi dobbiamo a forza creare un new old<Fruit>, non possiamo creare un new old<Apple> come per l'extends, e quindi per il set() non abbiamo più problemi perchè sappiamo per certo che avremo inizializzato il nostro old con un tipo Fruit e non una sua sottoclasse, giusto?

[VincenzoTheBest]

Originariamente inviato da Neptune
Sinceramente non mastico bene l'inglese e benchè l'ho letto con attenzione non sono riuscito a comprendere molto bene la pagina.

In pratica, dal momento che scrivi

older<? extends Fruit>

devi assumere che ? è un sottotipo/sottoclasse di Fruit non noto al compilatore;
quindi a run-time non si può avere alcuna garanzia riguardo gli oggetti passati al metodo set.
Cioè, di ? si sa solo che è un sottotipo di Fruit, ma questa informazione non basta per stabilire ad esempio se viene passato un suo sottotipo, proprio perchè non è noto.

[Neptune]

Originariamente inviato da VincenzoTheBest
In pratica, dal momento che scrivi

older<? extends Fruit>

devi assumere che ? è un sottotipo/sottoclasse di Fruit non noto al compilatore;
quindi a run-time non si può avere alcuna garanzia riguardo gli oggetti passati al metodo set.
Cioè, di ? si sa solo che è un sottotipo di Fruit, ma questa informazione non basta per stabilire ad esempio se viene passato un suo sottotipo, proprio perchè non è noto.

Mentre con "? super" sai che al run-time è esattamente un Fruit, e non una sua sottoclasse e quindi puoi assegnarli tranquillamente una qualsiasi sottoclasse?

[VincenzoTheBest]

Originariamente inviato da Neptune
Mentre con "? super" sai che al run-time è esattamente un Fruit, e non una sua sottoclasse e quindi puoi assegnarli tranquillamente una qualsiasi sottoclasse?

No, super è una limitazione inferiore.
Quindi, se scrivi

? super X

allora come parametro di tipo verrà richiesto X oppure un suo supertipo.