Liste mit verschiedenden Objekten

[SmartGuy]

Hallo Leute,

hab folgendes Problem in Bezug auf Listen und Typen der Listen:

List<List<List<? extends Number>>> liste = null;

List<List<? extends Number>> liste_mit_integerwerten = (List<List<? extends Number>>) getInput("input_integerListe");
liste.add(liste_mit_integerwerten);

List<List<? extends Number>> liste_mit_doublewerten = (List<List<? extends Number>>) getInput("input_doubleListe");
liste.add(liste_mit_doublewerten);

usw...

Nun kann ich aber nicht auf die Methoden von Integer bzw. Double zugreifen. Ist das so, weil ich die auf Number parse?

Wenn ich

List<List<Integer>> liste_mit_integerwerten = (List<List<Integer>>) getInput("input_integerListe");
liste.add(liste_mit_integerwerten);

Machen würde, kommt bei liste.add(liste_mit_integerwerten) folgender Fehler:

The method add(List<List<? extends Number>>) in the type List<List<List<? extends Number>>> is not applicable for the arguments (List<List<Integer>>)

Wie krieg ich Listen mit verschiedenen Typen in eine gemeinsame Liste und kann immernoch auf die Typenmethoden zugreifen????:L

 

[Der Müde Joe]

>Wie krieg ich Listen mit verschiedenen Typen in eine gemeinsame Liste und kann immernoch auf die Typenmethoden zugreifen?

Gar nicht mit generics. Ausser du machst beim raushohlen eine instanceof und ein cast (hässlich)

 

[bygones]

auch hier frage ich mich [c]List<List<List<? extends Number>>> liste[/c] was ist der sinn einer Liste einer Liste einer Liste ?

Java ist OO... warum nutzt das keiner ?

 

[SlaterB]

> Wie krieg ich Listen mit verschiedenen Typen in eine gemeinsame Liste und kann immernoch auf die Typenmethoden zugreifen?

gar nicht, außer die enthaltenen Objekte wieder auf ihren Typ zu casten,
eine Liste kann nur eine Art Objekt enthalten, wie sollte man auch je nach Index unterscheiden
-----

(List<List<Integer>>) getInput("input_integerListe");

ein Cast brauch nie generisch sein, das bringt gar nix, das wird zur Laufzeit eh nicht mehr geprüft, schreibe
(List) getInput("input_integerListe");
das macht exakt dasselbe

--------

> kommt bei liste.add(liste_mit_integerwerten) folgender Fehler:

das ist ein wichtiger Fehler, den man an einem etwas einfacheren Beispiel besser sieht:

public class Test {

	public static void main(String[] args) {
		List<Double> x = new ArrayList<Double>();

		List<? extends Number> l = x;

		Integer i = Integer.valueOf(4);
//		l.add(i);  zum Glück typsicher verboten
		List ll = l;
		ll.add(i); // hier nicht mehr vom Compiler verhindert

		Double d = x.get(0); 
		// -> ClassCastException, ein böser Integer ist in die Liste gekommen
		System.out.println(d);
	}
}

? extends Number heißt, dass irgendein unbestimmter Typ X vorhanden ist,
get() funktioniert bei so einer Liste, get liefert Number, denn egal welcher Typ X ist, die Objekte werden auf Number castbar sein,

add() muss aber ausgeschlossen sein, weder Double, noch Integer noch Number selber als Parameter ist erlaubt,
denn X kann immer irgendein Typ sein, der mit irgendeinem Paramterer nicht hinhaut, add() ist stillgelegt

 

[Marco13]

Ein paar Einträge über und unter diesem Eintrag liefern einen Haufen Information dazu.
AngelikaLanger.com - Java Generics FAQs - Under The Hood Of The Compiler - Angelika Langer Training/Consulting
Sollte man sich mal durchlesen. Hab' ich inzwischen schon ein paar mal, muss aber zugeben, dass ich, wenn es um solche Fragen geht (speziell bei so ... grenzwertig .. tief verschachtelten Generics) meistens dazu übergehe, so lange "? extends" an verschiedenen Stellen einzufügen, bis der Compiler sich nicht mehr beschwert.

So auch in diesem Fall: Mit einer [c]List<List<? extends List<? extends Number>>> liste[/c] geht's.

Die Antwort auf die Frage, warum sowas wie das andere nicht geht, ist in erster Näherung praktisch IMMER die gleiche: Weil es nicht Typsicher ist. Wenn nötig kann ich mal versuchen, den Fall rauzufiltern, bei dem es mit einer [c]List<List<List<? extends Number>>> liste[/c] irgendwann krachen könnte...

 

[SmartGuy]

auch hier frage ich mich [c]List<List<List<? extends Number>>> liste[/c] was ist der sinn einer Liste einer Liste einer Liste ?

Java ist OO... warum nutzt das keiner ?

Vielleicht weil nicht jeder die Möglichkeiten in einer bestimmten Entwicklungsumgebung für ein bestimmtes Projekt hat. Leider ist das bei meiner Aufgabe mit den vorgegebenen Bedingungen nicht möglich.
Kann weder Klassen erstellen, noch von welchen Erben. Kann nur in einer Klasse den SourceCode in einer Methode ändern und da muss man sich nunmal beschränken und es so hässlich machen.


@SlaterB:
Danke für die konstruktive Antwort.
Hatte es auch zunächst so gelöst, dass ich jedes Objekt wieder zurück caste. Das kam mir dann allerdings ein bisschen zu umständlich für Java vor und hab gehofft, da gibts nen Trick.

Also gehts nur auf die "Dirty"-Weise ??

 

[SlaterB]

was du genau haben willst ist eh nicht ganz klar,
schreibe doch mal dein Programm so wie du es willst

Liste l = ..;
l.add(x);
l.add(y);
X x = l.get(0);
Y y = l.get(1);

wird aber garantiert nicht gehen, weder in Java noch sonst einer allgemeinen Programmiersprache (falls man nicht auf Typprüfung ganz verzichtet),
jedenfalls nicht mit einem so allgemeinen Ding wie einer Liste in einem beliebigen Programmfluss,
eine Code-Zeile wie
X x = l.get(0);
muss da für sich betrachtet werden, der Inhalt von l kann ganz beliebig sein,
auf keine Weise kann ein Computer garantieren, dass l an Position 0 ein x hat, falls nicht der Typ X für die ganze Liste vorgegeben ist

 

[Nader]

Wie krieg ich Listen mit verschiedenen Typen in eine gemeinsame Liste und kann immernoch auf die Typenmethoden zugreifen????:L

indem du eigene Listenklassen mit bestimmen Boundary implementierst:

class IntegerList implements List<Integer> {
}

class DoubleList implements List<Double> {
}

deine verkettete Liste beinhaltet nur solche typisierte Listen.

 

[Marco13]

Ich hatte das jetzt so verstanden, dass es NUR darum geht, sowas machen zu können wie

List<List<Integer>> liste_mit_integerwerten = (List<List<Integer>>) getInput("input_integerListe");
liste.add(liste_mit_integerwerten);

und DANACH über die schon bekannte Referenz "liste_mit_integerwerten" noch sowas machen zu können wie

Integer i = integerwerten.get(1);

Um das casten bei getInput kommt man nicht drumrum, und um ein Casten, wenn man die Daten am Ende aus der List<List<List<List<List...>>>> rausholt, auch nicht. Aber man kann die List<List<List<List<...>>>> zu einer List<List<List<? extends List<...>>>> machen, und damit warnungsfrei die schon vorhandenen Objekte in die Liste legen...

 

[hdi]

Was du jetzt natürlich machen kannst ist dir da ne eigenen Hierarchie zusammenbasteln, und dann für den Zugriff zB das Strategy Pattern verwenden. Oder falls das ganze nicht so dynamisch sein muss (Typen können sich nicht ändern), dann reichen auch abstrakte Klassen, oder besser noch ein Interface:

interface MySuperType{
   public void doStuff();
}

class MyInteger extends Integer implements MySuperType{
  @Override public void doStuff(){
         System.out.println("doing stuff on an integer, perhaps using my inherited class Integer");
  }
}

class MyDouble extends Double implements MySuperType{
   @Override public void doStuff(){
         System.out.println("doing stuff on a double, perhaps using my inherited class Double");
  }
}

// main()
List<MySuperType> list = new ArrayList<MySuperType>();
list.add(new MyInteger());
list.add(new MyDouble());

for(MySuperType s : list){  
   s.doStuff();
}

edit: Also zur Erklärung:

Wie krieg ich Listen mit verschiedenen Typen in eine gemeinsame Liste und kann immernoch auf die Typenmethoden zugreifen?

In dem du ihnen eine Pseudo-Gemeinsamkeit schaffst, hier durch das Interface. Du kannst jetzt im Interface alle möglichen Methoden definieren, du die evtl auf deinen Objekten aufrufen willst.
D.h. du könntest im Interface jetzt alle Methoden der Klasse Double und Integer definieren, und die Klasse MyDouble implementiert all die Double-Methoden durch Delegation:

// vom Interface:
@Override
public void aDoubleMethod(){ 
   super.aDoubleMethod(); // führt den Code der geerbten Klasse Double aus
}

und alle Integer-Klassen einfach als No-Ops:

// vom Interface:
@Override
public void anIntegerMethod(){ 
   ; // do nothing
}

Bei MyInteger dann halt andersrum.. Die Frage ist inwiefern du das wirklich bei deinem Vorhaben anweden kannst, denn du kannst jetzt nicht sicher sein ob irgendwas "funktioniert" hat, wenn du zB eine Integer-Methode auf eines deiner SuperType-Objekte aufrufst. Evtl war es ein MyDouble und hat damit nix getan. Du kannst natürlich statt den No-Ops eine Exception werfen, und dann darauf reagieren. Aber das ähnelt auch schon wieder einer instanceof Prüfung oder einem if-else.

 

[SmartGuy]

Nochmal zum Verständnis:
In einer Liste "gesamt" sind Listen mit Objekte verschiedener Typen. Also eine Liste "i" vom Typ Integer und eine Liste "d" vom Typ Double.

Ich möchte beide Listen (i und d) in die Liste "gesamt" reinpacken, dann aber über die "gesamt"-liste auf die Methoden zugreifen können, die für die jeweiligen Typen definiert sind.

z. B.

List <List<? extends Number>> gesamt = new LinkedList<List<? extends Number>>();
List<Integer> i = new LinkedList<Integer>();
List<Double> d = new LinkedList <Double>();

gesamt.add(i);
gesamt.add(d);
gesamt.get(0).get(0).parseInt(irgendeinString);

ich kann aber nicht auf .parseInt() zugreifen, weil es ja kein Typ mehr vom Integer ist.

 

[SlaterB]

der Computer weiß nur, dass Number in der Liste ist,
wenn du weißt, dass es Integer ist, dann kannst du ja casten, anders gehts nicht,

 

[Marco13]

@hdi: So eine Gemeinsamkeit gibt's schon - die heißt "Number"

@SmartGuy: Ja, das geht nicht. An dem Punkt
[c]gesamt.get(0)....[/c]
weiß man nicht mehr, ob man dort eine List<Integer> oder eine List<Double> bekommt - man weiß nur, dass das, was da drin ist, eine "Number" ist. Was genau willst du denn mit dem Objekten (in den Unterlisten, hier als den Integer- oder Double-Objekten) machen? parseInt ist ja ohnehin statisch, und sowas wie intValue oder doubleValue wird von Number ja angeboten. Es gibt ja kaum (fast keine ???:L ) Methoden, die spezifisch für Integer oder Double sind...

 

[SmartGuy]

Ich hab das nur als Beispiel genommen. Aber ich mein vom Prinzip her dasselbe. Gibt es keine Möglichkeit, herauszufinden, was für eine Number das ist und dann deren Methoden aufzurufen?

 

[Der Müde Joe]

>was für eine Number das ist und dann deren Methoden aufzurufen?

erster Post: instanceof und cast

 

[Nader]

man könnte zwar folgendes machen (trotz Type safety), müsste aber beim Zugriff auf Gesamtliste immer genau wissen, welcher Typ unter welcher Index abgelegt ist.

private void test() {
	List<MyList> gesamt = new ArrayList<MyList>();
	IntegerList iList = new IntegerList();
	DoubleList dList = new DoubleList();
	gesamt.add(iList);
	gesamt.add(dList);

	Integer i = gesamt.get(0).getAt(0);
}

interface MyList {
	<T> T getAt(int index);
}

class IntegerList extends ArrayList<Integer> implements MyList {
	public Integer getAt(int index) {
		return get(index);
	}
}

class DoubleList extends ArrayList<Double> implements MyList {
	public Double getAt(int index) {
		return get(index);
	}
}