Generic

[saladin100]

Servus Leute,

Ich zieh mich grad bisschen Generics rein... und ein Beispiel aus einer Literatur verwirrt mich total.

public class Test {

public <T> T zufall(T m, T n) {
	return Math.random() > 0.5 ? m : n;
}

public static void main(String[] args) {
	Test t = new Test();
	System.out.println(t.zufall("hallo", 65));
	}
}

Also der Code last sich kompilieren.... aber sollte der Compiler nicht heulen? etwa an der Stelle

t.zufall("hallo", 65)

Der Compiler sollte doch was sagen wie: Hier kannst du nur zwei Objekte vom selben Typ reinstecken... aber irgendwie geht des auch Oo?!

mfg saladin

 

[Gast2]

Nein, du sagst dem Compiler ja nicht explizit was T sein soll.

System.out.println(t.<String>zufall("hallo", 65));

Hier würde der Compiler dann tatsächlich meckern, weil er zwei Parameter vom Typ String erwartet.

PS:
Und es heißt weder "Generice" noch "Generis", sondern generic

 

[saladin100]

stimmt.. danke für die schnelle Antwort =)

 

[nillehammer]

Hätte jetzt auch gedacht, dass das einen Kompilierfehler gibt. Aber wahrscheinlich behandelt bei dem Konstrukt der Compiler einfach beide Parameter als vom Typ Object. Dann sind die Typen ja gleich. String ist sowieso schon ein Object und die 65 wird wohl zu einem Integer autogeboxed.

P.S. Wär doch ne schöne Frage für die Java-Quizecke

 

[xehpuk]

Der Compiler sucht für den Rückgabetyp dann einen gemeinsamen Nenner.

Krachen wird es dann bei solchen Aufrufen:

// Type mismatch: cannot convert from Object&Serializable&Comparable<?> to ...
String s = t.zufall("hallo", 65);
int i = t.zufall("hallo", 65);

An der Fehlermeldung siehst du dann aber, was wiederum gehen würde:

Object o = t.zufall("hallo", 65);
Serializable s = t.zufall("hallo", 65);
Comparable<?> c = t.zufall("hallo", 65);

PS: Die Methode sollte eher

Math.random() < 0.5 ? m : n

bzw.

Math.random() >= 0.5 ? m : n

zurückgeben.

 

[saladin100]

Halli hallo,

ich hab zu dem Thema nochmal ne Frage^^..

Also.. folgender Code.

public class Test {
	
	public <T> void zufall(T m, ArrayList<T> list) {	
	}
	
	public static void main(String[] args) {
		Test t = new Test();
		String s = "hallo";
		ArrayList<String> listOfStrings = new ArrayList<String>();
		t.zufall(s, listOfStrings);
                t.zufall(65,listOfStrings); //Geht nicht
	}
}

in diesem Fall is es jetzt völlig wurst, ob ich <String>zufall() oder zufall() schreibe. Der Compiler schreibt mit in beiden Fällen vor, für "s" einen String einzusetzen.
Liegt das jetzt daran, das die Methode zufall() einen Parameter mit einem generischen Typ erwartet
(in diesem Fall eben ArrayList) und dadurch dann gleich weis, was T für ein Typ ist?

lg saladin

 

[saladin100]

...

 

[Marco13]

Hmja, eine ArrayList<String> und eine ArrayList<Object> haben eben nichts miteinander zu tun (letzteres würde wohl gehen). Man kann da mit extends/super noch ein bißchen dran feilen, aber ggf. solltest du genauer sagen, was du erreichen willst.

 

[saladin100]

ich will nichts erreichen.. ich will einfach nur verstehen... und ihr sollt mir sagen ob ich des richtig verstehe

 

[Illuvatar]

Hmja, eine ArrayList<String> und eine ArrayList<Object> haben eben nichts miteinander zu tun (letzteres würde wohl gehen). Man kann da mit extends/super noch ein bißchen dran feilen

Um etwas spezifischer zu sein, z.B. so:

public class Test {
    public <T> T zufall(T m, ArrayList<? extends T> list) {
           return null;
    }

    public static void main(String[] args) {
        Test t = new Test();
        String s = "hallo";
        ArrayList<String> listOfStrings = new ArrayList<String>();
        
        String str = t.zufall(s, listOfStrings); // Geht
        Comparable<? extends Serializable> cmp = t.zufall(65,listOfStrings); // Geht
        String str2 = t.zufall(65, listOfStrings); // Geht nicht
    }
}