Generische Typen: Frage dazu

[Souljumper]

	public static void main(String [] s)
	{
		List<Number> numberList = new ArrayList<Number>();
		
		List<? extends Number> obenBesch  = numberList;
		List<? super   Number> untenBesch = numberList;
		
		obenBesch.add(new Integer(3)); //Geht nicht, wieso?
		untenBesch.add(new Integer(3)); //Geht, wieso ?
	}

<? extends Number> sagt doch aus, das mein Typ ein Datentyp sein muss der von Number erbt? (also extended). Wieso kann ich dann kein Integer einfügen? da dies doch ein ein Datentyp ist, der von Number geerbt hat?

wenn ich <? super Number> benutze sage ich, dass mein Datentyp Number als seine direkte Oberklasse haben muss.

Wieso ist jetzt die super-Variante ausreichend um ein integer hinzuzufügen und die extends-Variante nicht?

 

[0x7F800000]

[highlight=Java]
public static void main(String [] s)
{
List<Number> numberList = new ArrayList<Number>();

List<? extends Number> obenBesch = numberList; //es wird garantiert, dass alles, was ich aus dieser liste raushole, von Number erbt
List<? super Number> untenBesch = numberList; //es wird garantiert, dass in diese Liste jede Number (und jede Unterklasse) reinpasst

Number x=obenBesch.get(0); // <---- dafür ist es gedacht!!!
untenBesch.add(new Integer(3)); //Geht, wieso ? weil Integer<Number<Jede Oberklasse von Number
}
[/highlight]

Das erste kann nicht gehen, denn:
[highlight=Java]
List<? extends Number> obenBesch=new LinkedList<Double>();
//muss gehen, weil Double<Number.
//Alles, was ich aus dieser Liste rausbekomme _ist_ Number.
//Heißt aber noch lange nicht, dass ich da jede Number reinstopfen kann
//insbeondere kann man da keine Integer reinstopfen:
obenBesch.add(new Integer(3)); //geht nicht
//Doubles darf man da übrigens auch nicht reinstopfen, nur mal nebenbei bemerkt:
obenBesch.add(new Double(3.2)); //geht auch nicht
[/highlight]

 

[SlaterB]

der Variablen obenBesch (euerter Name)
kannst du eine ArrayList<Double> zuweisen, denn Double passt auch zu Number,

da die Liste weiterhin genauso als ArrayList<Double> existiert, würde dort dann nach Einfügen eines Integers beim get() eine ClassPathException auftreten,
also ist es verboten, in einer Liste unbekannten Typs irgendwas einzufügen (außer dem Wert null)

List<Double> x = ArrayList<Double>();
List<? extends Number> obenBesch = x;
obenBesch.add(Integer.valueOf(2));

Double d = x.get(0); // Achtung, Programmabsturz

-------

bei List<? super Number> weiß man, dass der generische Parameter der enthaltenen Liste entweder
Number oder einer dessen Superklassen ist, man kann also garantiert Number einfügen und die
generisch korrekten get-Aufrufe werden funktionieren

aber am besten nachlesen, z.B. :
Generics in Java 1.5

 

[Souljumper]

also
List<? extends Typ_X> li
sagt aus, dass der Wert den ich entnehmen aufjedenfall zu Typ_X kompatible ist, deswegen ist
Typ_X x = li.get(0);
erlaubt.
Dadurch das ich nicht spezifiere was reingetan werden darf, ist nur "null" möglich

während
List<? super Typ_X) li
das gegenteil macht und beschreibt was ich reinschreiben darf? weswegen ich alles reinschreiben darf was Typ_X als Oberwert hat, aber nicht Typ_X selbst.
li.add(new SubTyp_X(wert)); //geht
li.add(new Typ_X(wert)); // geht nicht
Dadurch das ich nicht spezifiere welche eigenschaft die Werte haben die ich raushole, darf ich nur Objects entfernen, weil jeder java-typ als obertyp garantiert Object hat.

is das so richtig? sollte das selbe in grün sein was in Slaters generic-link steht.

 

[0x7F800000]

fast schon richtig, aber:

li.add(new Typ_X(wert)); // geht nicht

wieso nicht?

 

[Souljumper]

hab das mit dem integer und number beispiel probiert

new Number(3) funzt natürlich nicht. mein fehler

mit (Number)(new Integer(3)) gehts.

 

[0x7F800000]

hab das mit dem integer und number beispiel probiert

new Number(3) funzt natürlich nicht. mein fehler

mit (Number)(new Integer(3)) gehts.

verstehe ich nicht. Wofür steht das "s" beim "gehts"? Was geht????:L

 

[Souljumper]

verstehe ich nicht. Wofür steht das "s" beim "gehts"? Was geht????:L

sry, bissle zerhackt.

"damit gehts" war die Aussage. Hab meinen fehler erkannt. Hatte das abstrakte versucht anhand von Number und Integer zu konkretisieren und hab dabei den fehler gemacht ein number objekt mit "new number(3)" zu erzeugen. was nicht geht. ich dachte zeurst das geht nicht weil die generics da nicht passen. aber der aufruf war falsch.

damit gehts es dann schon eher: (number) (new integer(3)).

 

[Gast2]

[HIGHLIGHT="Java"]

public class TestGenerics {

public static void main(String[] args) {

List<Double> doubleList = new ArrayList<Double>();

// das Wildcard sagt aus du kannst alles als Liste übergeben was von Number erb
List<? extends Number> numberList = doubleList;

// hier würdest du AUCH !!!! der doubleList ein Integer hinzufügen
numberList.add(new Integer(3)); // geht nicht ,weil siehe *

for (Double doubleValue : doubleList) {
System.out.println(doubleValue);// *würde es hier eine cast exception geben
// weil Integer != Double
}

}
}
[/HIGHLIGHT]

 

[SlaterB]

während
List<? super Typ_X) li
das gegenteil macht und beschreibt was ich reinschreiben darf? weswegen ich alles reinschreiben darf was Typ_X als Oberwert hat, aber nicht Typ_X selbst.
li.add(new SubTyp_X(wert)); //geht
li.add(new Typ_X(wert)); // geht nicht
Dadurch das ich nicht spezifiere welche eigenschaft die Werte haben die ich raushole, darf ich nur Objects entfernen, weil jeder java-typ als obertyp garantiert Object hat.

is das so richtig? sollte das selbe in grün sein was in Slaters generic-link steht.

li.add(new Typ_X(wert)); geht genauso, warum nicht?

die Liste ist füt Typ_X oder eine seiner Oberklassen spezifiziert,
also sind alle Typ_X und deren Unterelemente ok,

wenn's ne List<Object> war, wird get() Object zurückliefern,
wenn's ne List<Super_Typ_X> war, wird get() Super_Typ_X zurückliefern,
wenn's ne List<Typ_X> war, wird get() Typ_X zurückliefern,
nichts davon kann durch Einfügen von Typ_X oder dessen Unterklassen kaputt gemacht werden

----

Entfernen kann man aus allen Listen zu jeder Zeit, da gibts nie Probleme

 

[Souljumper]

Ok, danke soweit

		List<Double> numberList = new ArrayList<Double>();
		
		List<? super   Number> untenBesch = numberList;

wieso funktioniert das hier nicht?
Weil numberList bereits Double ist, und eine Zuweisung an eine Liste mit einer Begrenzung das der Typ von Number erben oder Number sein muss, in diesem Fall die Bedingung lockern würde?
sehe ich das richtig?

 

[Marco13]

Ich find's hilfreich, sich zu überlegen, was derjenige, der die Referenz bekommt, dann mit ihr anfangen könnte - und man kann fast sicher sein: Wenn eine Zuweisung nicht geht, dann könnte man irgendwas nicht-typsicheres machen. Detailliertere Erklärungen könnten schnell vom 100. ins 1000. kommen, und die überlasse ich mal den anderen - aber den Link auf AngelikaLanger.com - Java Generics FAQs - Under The Hood Of The Compiler - Angelika Langer Training/Consulting wollte ich noch posten....