Frage zu Interfaces (Beispiel: Comparable)

[Marcel_Handball]

Hi,
ich habe zwei Verständisfragen zu Interfaces.

Wieso ist eine Konstruktion wie die folgende nicht möglich?

Comparable<String>[] c = {"eins","zwei"};
bzw.: Comparable<String>[] c = new Comparable<String>[5];

Andererseits funktioniert folgendes:

Comparable[] objects = new Comparable[2];
objects[0] = "String";
objects[1] = "String2";

System.out.println( (String) getSmallest(objects) );

--------------

public static Object getSmallest(Comparable[] objects){
     Object smallest = objects[0];
     for(int i = 1; i < objects.length; i++){
          if(objects[i].compareTo(objects[i+1]) > 0){
               smallest = objects[i];
          }
     }
}

Wieso ist es möglich Objekte vom Typ Comparable<String> einem Comparable-Objekt zuzuweisen, sodass anschließend in der Methode getSmallest() auf das ursprüngliche Comparable<String>-Objekt die Methoden compareTo(Object) aufrufen kann, obwohl die Klasse String nur compareTo(String) definiert?

 

[SlaterB]

1.
Arrays kann man generell nicht generisch erzeugen, da ist eine Barriere in Java
> new Comparable<String>[5];
gibts also nicht,

> Comparable<String>[] c = {"eins","zwei"};
könnte dagegen funktionieren, kann es grad nicht testen, was ist denn die Fehlermeldung?

-----

2.
das Interface Comparable benutzt nur einen generischen Parameter T, die Methode lautet
compareTo(T o)

zur Laufzeit existierten in Java die generischen Informationen weitgehend nicht mehr, alle Ts werden zu Object,

edit:
ich glaube mir gerade selber gar nicht mehr, muss ich doch noch mal nachschauen einen Moment

edit2:
nun mit Java-Zugang:

public class Test extends Random {

	public static void main(String[] args) {

		Comparable a = 4;
		Comparable b = "";
		System.out.println(a.compareTo(b));
	}
}

die Methoden sind doch eingeschränkt:

Exception in thread "main" java.lang.ClassCastException: java.lang.String cannot be cast to java.lang.Integer
	at java.lang.Integer.compareTo(Integer.java:35)
	at testmain.Test.main(Test.java:16)

bei String zu String klappte es dank gleichen Typ

hier trifft man also auf das 'weitgehend' aus 'zur Laufzeit existierten in Java die generischen Informationen weitgehend nicht mehr, alle Ts werden zu Object,'
bzw. das Problem ist gar nicht mehr generisch, die Methode ist fest implementiert, nur erfüllt diese feste Implementierung die generische Anforderung,
tja, ganz schön wirr, sorry

public class Test {

	public static void main(String[] args) {
		Comparable a = new ComparableTest1<String>();
		a.compareTo(4); // geht

		Comparable b = new ComparableTest2<List>();
		b.compareTo(4); // ClassCastException
	}
}

class ComparableTest1<T> implements Comparable<T> {

	public int compareTo(T o) {
		return 0;
	}
}

class ComparableTest2<T> implements Comparable<String> {

	public int compareTo(String o) {
		return 0;
	}
}

 

[Marcel_Handball]

Hey SlaterB,

erst einmal danke für deine ausführliche Antwort. Ich hab mir deinen Code sicherlich jetzt 5min angeschaut und überlegt, wieso dies so gilt.
Da ich gerade erst angefangen habe, meine Java-Kenntnisse wieder aufzuarbeiten, bin ich zu Generics nicht auf der Höhe.

Es ist also möglich einem "unbestimmten generischen" Objekt einem bestimmtes zuzuordnen:

Comparable a = new ComparableTest1<String>();

Doch setzt der Compiler dadurch, wenn ich dich richtig verstanden habe, die Methode compareTo(T o) von ComparableTest1 nicht auf compareTo(String o). (Sondern auf Object?)

Wie verhält es sich wenn ich das Object ohne Typangabe initialisiere?

Comparable a = new ComparableTest1();

Wie sieht dann die Methode intern aus?


Würde die Zeile: a.compareTo(4); auch funktionieren, wenn man den Vergleich tatsächlich vornehmen würde (denn dann würde man doch versuchen auf Eigenschaften von T zuzugreifen, die das übergebenen Objekt unter Umständen gar nicht besitzt, da man den Typ des Objekts nicht kennt)

 

[SlaterB]

> Doch setzt der Compiler dadurch, wenn ich dich richtig verstanden habe, die Methode compareTo(T o) von ComparableTest1 nicht auf compareTo(String o). (Sondern auf Object?)

new ComparableTest1<String>(); hat nur eine Methode compareTo(Object), ja,
das liegt an der Definition dieser Klasse, nicht an dem Speichern in der Comparable-Variable, wie dein Satzbau vermuten läßt

> Wie verhält es sich wenn ich das Object ohne Typangabe initialisiere?

intern zur Laufzeit ist es in beiden Fällen Object,
ohne Typangabe wird auch der Compiler von Object ausgehen

> Würde die Zeile: a.compareTo(4); auch funktionieren, wenn man den Vergleich tatsächlich vornehmen würde (denn dann würde man doch versuchen auf Eigenschaften von T zuzugreifen, die das übergebenen Objekt unter Umständen gar nicht besitzt, da man den Typ des Objekts nicht kennt)

für a, also ComparableTest1, ist im Quellcode der Klasse der Typ ja gar nicht bekannt, daher kann auf keine spezielle Eigenschaft zugegriffen werden,

anders sieht es in ComparableTest2 aus, da wird dann mit String gearbeitet, man könnte String-Methoden aufrufen, ClassCastException ist möglich,
bzw. erfolgt ja jetzt schon durch den Cast auf den Parameter-Typ

 

[Marcel_Handball]

Heißt das, dass eine Objektvariable wie [T o], [Object o] und eine Funktion wie compareTo(T o), compareTo(Object o) entspricht?

Wenn alle T's zu Objects umgewandelt werden, wozu gibt man einem Objekt bei seiner Initialisierung einen Generic mit?
Welcher Unterschied besteht zwischen einem direkten Initisilisierung von compareTo(Object) und compareTo(T)?

 

[SlaterB]

nur der Compiler beachtet T statt Object und wird meckern, falls man nicht den richtigen Typ übergibt,
eine Hilfe zur Bearbeitung des Quellcodes, für die Programmausführung weitgehend unerheblich und auch in der Programmierung durch das Casten teilweise zu verschleiern:

Comparable a = new ComparableTest1<String>();
oder
Comparable a = new ComparableTest1<MondRakete>();
macht niemals nirgendwo im Programm einen Unterschied, der TypParameter ist völlig nutzlos

------

Comparable<String> a = new ComparableTest1<String>();
oder
Comparable<MondRakete> a = new ComparableTest1<MondRakete>();
bringt im weiteren Quellcode den Vorteil, dass der Compiler anmerken kann, dass ein compareTo-Aufruf mit Typ Integer eher sinnlos ist,
zur Lauftzeit wird daraus aber in allen Fällen:
Comparable a = new ComparableTest1(); mit compareTo(Object)

nicht so bei ComparableTest2 oder der Klasse String, deinem ursprünglichen Beispiel, da ist compareTo(String) fest implementiert, relativ unabhängig von Generics

 

[Marcel_Handball]

Alles klar, also ist T immer vom Typ Object und nur zur Fehlerprevention beim Programmieren gedacht (Anmerkender Compiler).

Man kann also nicht davon ausgehen, dass der Parameter von compareTo vom Typ des Generics (des Objektes) ist, sodass eine Überprüfung wie (this instanceof paramter) nötig ist für einen fehlerlosen Vergleich.

 

[SlaterB]

wenn der Parameter generisch ist, dann ist auch keine instanceof-Prüfung möglich

überhaupt ist auch ein Vergleich, ob fehlerlos oder nicht, quasi ausgeschlossen, falls man nicht Methoden von Object wie hashCode() heranzieht,
viel kann man mit generischen Parametern nicht machen,
am besten sind da noch die Collections, Objekte einlagern und wieder zurückgeben, ohne sie sich genau anzuschauen


interessant wird es noch, wenn man die Basisklasse des generischen Parameter festlegt:

public class Test {

	public static void main(String[] args) {
		Comparable a = new ComparableTest1<Double>();
		a.compareTo(Integer.valueOf(4)); // geht, Integer ist Number
		a.compareTo(""); // ClassCastException
	}
}

class ComparableTest1<T extends Number> implements Comparable<T> {

	public int compareTo(T o) {
		return o.shortValue(); // Number-Methoden können aufgerufen werden
	}
}

hier wird im Programm T nicht zu Object, sondern zu Number, dann können auch Number-Methoden aufgerufen werden

 

[Marcel_Handball]

Die Klasse String implementiert Comparable<String>, muss also die compareTo-Methode überschreiben (aufgrund des Generics mit einem String-Parameter).
Ein Aufruf der Methode mit einem Object-Objekt ist nicht möglich.

Also wird T immer nur durch Object ersetzt wenn keine Angabe zum Typ von T gemacht wird?

Der Versuch instanceof auf einen Generic anzuwenden funktioniert allerdings bei mir.

class ComparableTest1<T> implements Comparable<T> {
 
    public int compareTo(T o) {
        System.out.println(o instanceof Integer);
        System.out.println((Integer) o);
    	return 0;
    }
}

 

[SlaterB]

> Also wird T immer nur durch Object ersetzt wenn keine Angabe zum Typ von T gemacht wird?

so in etwa

> Der Versuch instanceof auf einen Generic anzuwenden funktioniert allerdings bei mir.

nun gut, das geht,
aber bei allgemeinem Parameter T ist es recht sinnfrei, auf Integer zu prüfen,

noch was denkbares ist, am Anfang im Konstruktor ein Class<T>-Objekt zu übergeben,
dann könnte man später
class.isInstance(o)
testen

ComparableTest1<String> x = new ComparableTest1<String>(String.class) // Integer.class ginge nicht, passt nicht zum generischen Parameter

 

[Marcel_Handball]

Alles klar, dank dir.

Mit deinen Erklärungen meine ich mein vorliegendes Listing vollkommen verstanden zu haben

 

[Marcel_Handball]

Gibt es eine Möglichkeit die Implementierung der Klasse compareTo von String irgendwo einzusehen?

 

[SlaterB]

in jedem Windows-JDK-Verzeichnis sollte eine Datei src.zip dabei sein (unter Ubuntu Extra-Paket)

 

[maki]

Gibt es eine Möglichkeit die Implementierung der Klasse compareTo von String irgendwo einzusehen?

compareTo ist keine Klasse, sondern eine Methode, die vom Interface Comparable vorgeschrieben ist.
Die sourcen sind im JDK (unter Linux als extra Packet nachzuinstallieren) oder im inet.