Generics

[mouk]

Hi!

Ich finde es etwas komisch wie Generics funktionieren. Wieso ist es notwendig, wenn man eine neue Instanz von zB ArrayList erzeugt, auch bei "new ArrayList<String>()" den Typenparameter anzugeben, würde es nicht ausreichen wenn man das nur bei der Referenz macht?

Bei allen anderen Operationen wird doch auch der Typ der Referenz verwendet, zB:

import java.util.ArrayList;

public class Test {
	
	public static void main(String[] args) {
		
		ArrayList<String> list = new ArrayList<String>();
		list.add("Hallo");
		
		ArrayList list2 = list;
		list2.add(34.324);
		
		ArrayList<Integer> list3 = list2;
		list3.add(643);
	}
}

Bei diesem Code lässt mich der Compiler doch letztendlich wieder jedes Objekt einer beliebigen Klasse der ArrayList hinzufügen, obwohl ich sie bei der Erstellung mit <String> parameterisiert habe.
Also was hat das dann für einen Sinn gehabt?

fg, mouk

 

[SlaterB]

Was meinst du denn mit 'notwendig'?
Bei mir funktioniert
ArrayList<String> list = new ArrayList();
auch ohne Typparameter.

Der Compiler meckert nur dass das dann nicht mehr typsicher ist.
Denn der Compiler weiß nicht, dass new ArrayList(); eine leere Liste ist und damit genau das gleiche wie new ArrayList<String>();

Das zu erkennen fordert halt ein bisschen Nachdenken was im Moment fehlt.

-------
Wenn du das einmal haben willst, dann demnächst vielleicht auch

ArrayList l = new ArrayList();
ArrayList<String> l2 = l;

ohne Fehlermeldung?

Und später gar

ArrayList l = new ArrayList();
// beliebiger Code
ArrayList<String> l2 = l;
?

------------
Das wäre Schritt für Schritt immer schwieriger,
der Compiler macht es sich aber ganz einfach:

ArrayList l = new ArrayList();
l.add(3);
l.add(new Object());
ArrayList<String> l2 = l;

muss auf jeden Fall zu einem Fehler (bzw. Warnung) führen.
Wie kann man das am einfachsten erkennen?
Man schaut einfach, ob das Objekt l bei der Zuweisung zu l2 vom Typ ArrayList<String>() ist.

Das ist zwar strohdumm in Vergleich zu dem was vielleicht toll wäre, klappt dafür fehlerlos.

Hat dabei zur Folge, dass
ArrayList<String> list = new ArrayList();
zu genau dem gleichen Fehler/ Warnung führt.

 

[mouk]

Danke für deine Antwort. Leider konnte ich deinen Erklärungen nicht ganz folgen. Es ist ja nicht so das ich das so machen möchte wie in dem Beispiel. Ich habe eben nur etwas rumprobiert.

Ich verstehe weiterhin nicht was unsicher sein soll wenn ich ArrayList<String> list = new ArrayList(); schreibe.

Ich bekomm auch ohne die Angabe von "new ArrayList<String>()" sämtliche Warnungen, Fehler und Checks die ich sonst auch bekommen würde.

fg, mouk

 

[byte]

Ich verstehe weiterhin nicht was unsicher sein soll wenn ich ArrayList<String> list = new ArrayList(); schreibe.

Ich bekomm auch ohne die Angabe von "new ArrayList<String>()" sämtliche Warnungen, Fehler und Checks die ich sonst auch bekommen würde.

Und ich verstehe nicht, was es da nicht zu verstehen gibt. Alleine die Tatsache, dass es überhaupt Warnungen gibt, sagt doch schon, dass es nicht sicher sein kann. Der Teil links vom = ist quasi die Referenz und der Teil rechts das eigentliche Objekt, das erzeugt wird. Beides muss generisch definiert werden, um Typsicherheit zu gewährleisten.

ArrayList<String> list = new ArrayList(); ist genaus unsicher, wie das hier:

ArrayList<String> list;
		
ArrayList list2 = new ArrayList();
		
list2.add("hallo");
list2.add(17);
list2.add(new Object());
		
list = list2;

 

[mouk]

Was in deinem Beispiel unsicher ist verstehe ich.
Ich habe mal kommentiert so wie ich mir das vorstelle.

ArrayList<String> list;
      
ArrayList list2 = new ArrayList();
      
list2.add("hallo");
list2.add(17);
list2.add(new Object());
      

list = list2; // Der Compiler erkennt hier das die Referenz list das Attribut <String> hat und das die Referenz list2 nicht
                // parameterisiert ist und gibt deshalb eine Warnung aus. Also benötigt er doch die Angabe von 
                // "new ArrayList<String>()" gar nicht um zu erkennen ob das nun Typensicher ist oder nicht

 

[byte]

Also benötigt er doch die Angabe von "new ArrayList<String>()" gar nicht um zu erkennen ob das nun Typensicher ist oder nicht

Ähm doch, genau deswegen benötigt er eben diese Information. :roll:

Eine Liste ist nur dann typsicher, wenn sichergestellt ist, dass nur Objekte eines bestimmten Typs rein können. Wie man Beispiel oben zeigt, kannst Du das nur sicherstellen, wenn auf beiden Seiten vom = diese Typsicherheit generisch festgelegt wird.

new ArrayList<String>() <--- kann ausschließlich Strings beinhalten => typsicher
new ArrayList() <--- kann beliebige Objekte beinhalten => typunsicher

 

[mouk]

new ArrayList<String>() <--- kann ausschließlich Strings beinhalten => typsicher

Aber genauso ist es doch eben nicht. Schau dir folgenden Code an:

ArrayList<String> list = new ArrayList<String>();

list.add("Hallo");
      
ArrayList list2 = list;

list2.add(34.324); // Die mit "new ArrayList<String>()" erzeugte Instanz von ArrayList akzeptiert neuerdings auch 
                          // doubles, nur weil sie mit einer nicht parameterisierten Referenz verbunden wurde.

 

[SlaterB]

list2 ist als ArrayList definiert, da ist es egal was für ein Objekt drin ist,

list2.add(34.324);
gibt keinen Fehler da kein String-Typ benötigt wird


" kann ausschließlich Strings beinhalten => typsicher"
heißt
"der Compiler kann sicherstellen, dass dieses Objekt (SOLANGE ES ALS ArrayList<String> BEHANDELT WIRD) nur Strings enthält,
wenn ein anderes Objekt in dieser Liste wäre, hätte es bereits vorher, beim Hinzufügen dieses Objektes in diese Liste, eine Warnmeldung gegeben",

das ganze gilt nur lokal für eine bestimmten Codebereich,
das ist nur eine Hilfe für den Compiler in diesem Codebereich Warnmeldungen auszugeben (als Hilfe beim Programmieren),
verboten wird dabei nix

-----------
Typsicherheit ist eine Kette von Anforderungen und Erfüllungen,

ArrayList<String> list = new ArrayList<String>(); // ist muss A<String> sein, ist das Objet recht A<String>? jo, kein Fehler
list.add("Hallo"); // nur Strings dürfen rein (list ist ja vom Typ A<String>), ist Objekt ein String?, jo, kein Fehler

ArrayList list2 = list; // list2 muss irgendeine A sein, ist list2 eine A? jo, kein Fehler,
list2.add(34.324); // list2 ist eine GANZ NORMALE A, welches A-Objekt in dieser A-Variable drin ist IST UNBEKANNT (vielleicht gar null -> NullPointerException), in eine A dürfen beliebge Objekte, ist Objekt ein Objekt? selbstverständlich, jedes Objekt darf da rein, kein Fehler

 

[mouk]

Aber wenn man mit einer ArrayList<String> Referenz auf eine ArrayList zugreift, kann man sowieso nur Strings hinzufügen, egal ob man die Instanz mit "new ArrayList<String>()" erzeugt hat oder nicht.

Folgende 2 Codeblöcke sind von der Funktionsweise her völlig identisch:

      ArrayList<String> list = new ArrayList<String>();
		list.add("Hallo");
		
		ArrayList list2 = list;
		list2.add(334.45);
		
		

		
		ArrayList<String> list3 = new ArrayList();
		list3.add("Hallo");
		
		ArrayList list4 = list3;
		list4.add(334.45);

Kann mir vielleicht jemand ein konkretes Codebeispiel geben für einen Fehler der passieren könnte wenn ich "new ArrayList()" verwende, der nicht passiert wäre wenn ich "new ArrayList<String>()" verwendet hätte? Ich habe nämlich schon die ganze Zeit rumprobiert, ich bin aber auf keinen grünen Zweig gekommen. ;-)

 

[SlaterB]

richtig, die Warnmeldung sagt ja auch NICHT, dass du danach die Liste nicht wie eine korrekt definierte ArrayList<String> verwenden kannst,

das klappt nämlich wunderbar,
und wenn du dir sicher sein kannst, das die erste Zuweisung auch korrekt ist, obwohl der Compiler meckert, dann ist alles wunderbar,

so kann man durchaus Generics sinnvoll einsetzen, nach dieser ersten Warnung funktioniert weiterhin alles recht sinnvoll

----------

das einzige was die Warnmeldung dir sage will, ist, dass AN GENAU dieser Stellen eine Gefahr besteht, nämlich dass hier falsche Objekte in die ArrayList kommen,

schlicht und einfach genau die richtige Warnmeldung für eine solche Situation

 

[SlaterB]

der Fehler ist

ArrayList list = new ArrayList();
list.add(2);

ArrayList<String> list2 = list;
String st = list2.get(0); // ClassCastException


über eine solche Exception darf man sich nicht wundern, schließlich hat einen der Compiler extra gewarnt

-----------

wie gesagt kann bei
ArrayList<String> list3 = new ArrayList();
unmöglich ein Fehler auftreten,
aber der Compiler ist zu dumm, um zu erkennen, dass die augenscheinlich typunsichere ArrayList() leer sein muss und damit unmöglich ein Problem darstellen kann,

schlicht nicht sichtbar für den Compiler,
für den ist dieser Einzeiler genauso gefährlich wie


ArrayList list = new ArrayList();
list.add(2);

ArrayList<String> list2 = list;

 

[mouk]

das einzige was die Warnmeldung dir sage will, ist, dass AN GENAU dieser Stellen eine Gefahr besteht, nämlich dass hier falsche Objekte in die ArrayList kommen,

Aber wie kann an dieser Stelle eine Gefahr bestehen das falsche Objekte in die ArrayList kommen, wo sie doch noch nichtmal existiert sondern erst mit new erzeugt wird?

 

[SlaterB]

siehe meine zweite Antwort eben, der Compiler ist eben doof,
so denke ich mir das jedenfalls, sonst sähe ich auch keinen Grund genau wie du

--------

übrigends müsste der Compiler auch prüfen, ob nicht etwa im Konstruktor der ArrayList heimlich schon ein paar Objekte eingefügt werden und ähnliche Späße,
das ganze könnte also nur über eine Positivliste wie 'java.util.ArrayList keine Gefahr' gemacht werden, oder auch 'java.util keine Gefahr',
aber kann man sich bei sowas sicher sein?, will man das für alle Java-Klassen/-Pakete machen?

Generics sollte wohl doch eher selber generisch sein, also keine Unterscheidung zwischen ArrayLists oder selbstdefinierten Klassen machen,
da ist eine solche Überprüfung dann eh nicht mehr möglich

 

[mouk]

siehe meine zweite Antwort eben, der Compiler ist eben doof,
so denke ich mir das jedenfalls, sonst sähe ich auch keinen Grund genau wie du

Ich glaub so langsam kapier ich es.
Nur so nebenbei, was meint der Compiler eigentlich mit "unchecked conversion"? Ja ich kann Englisch, ich versteh aber trotzdem nicht was er da genau meint.. :wink:

Ich hab jetzt auch noch ein Beispiel gefunden, wo es Sinn macht <String> zu schreiben:

public class Test {
	
	public static void main(String[] args) {
		
		NewList<String> list = new NewList<String>(2343);
	}
}

class NewList<T> extends ArrayList<T> {	
	NewList(T t) {
		add(t);
	}
}

Wenn man "new NewList(2343)" schreibt schluckt es der compiler, bei "new NewList<String>(2342) bekommt man allerdings eine schöne Fehlermeldung.

fg, mouk