Generics

[tarzan]

Hallo,

ich habe eine Klassen erstellt die Objekte eines bestimmten (aber festen) Typs aufnehmen soll, die mindestens Comparable sein müssen. Ich dachte mir, dass das Klassen-Template eigentlich so aussehen müsste.

public class Klasse<T extends Comparable<T>> {
...

   public void add(T a) {
      ...
   }
}

Als nächstes wollte ich eine Instanz erstellen wobei erst zur Laufzeit bekannt ist welchen Typ T nun hat. Das heißt es müssen Wildcards zum Einsatz kommen.

public void test() {

   Klasse<? extends Comparable<?>> a;

   if (Bedingung1)
      a = new Klasse<Integer>();
   else
      a = new Klasse<Float>();


   if (Bedingung1)
      a.add(new Integer(0));
   else
      a.add(new Float(0));
}

Bis zu dem Punkt an dem ich Objekte zu a hinzügen möchte gibt der Code Assistent von Eclipse keine Fehlermeldungen aus. Aber beim Hinzufügen gibt es die Methoden-Signatur in der Klasse angeblich nicht. Wie schreibt man das richtig hin? Ich schätze mal das Problem liegt bei den Wildcards oder? Ich muss wahrscheinlich dem Compiler irgendwie mitteilen, dass die beiden Fragezeichen vom selben Typ sein sollen oder?

Danke im Voraus

 

[SlaterB]

du kannst in a nur dann Integer oder Float einfügen, wenn a als TypParameter Integer oder Float angegeben hat,

mit ? ist fast nix angegeben, du und der Compiler wissen damit, dass in a Comparable Objekte drin sind,
beim get könnte man diese also auf Comparable casten,

zum Einfügen ist so ein Konstrukt aber nicht hilfreich,
das heißt, dass du gar nix einfügen kannst, weil keine Typsicherheit gewährleistet ist

oder wie sollte der Compiler

Klasse<? extends Comparable<?>> a;
+
a = new Klasse<Integer>();
+
a.add(new Float(0));

verhindern? Code analysieren?

 

[tarzan]

du kannst in a nur dann Integer oder Float einfügen, wenn a als TypParameter Integer oder Float angegeben hat,

Genau das mache (versuche) ich bei der Initialisierung .

das heißt, dass du gar nix einfügen kannst, weil keine Typsicherheit gewährleistet ist

Genau die will ich ja erreichen. Wenn a einmal initialisiert ist soll der Typ fest sein.

mit ? ist fast nix angegeben, du und der Compiler wissen damit, dass in a Comparable Objekte drin sind,

Ich weiß, meine frage war ja auch wie ich das nun erreichen kann (den Typ zur Laufzeit festzulegen).

 

[SlaterB]

z.B.

Klasse<? extends Comparable<?>> a;
Klasse<Integer> b;
Klasse<Float> c;


if (Bedingung1) {
b = new Klasse<Integer>();
a = b;
}else {
c = new Klasse<Float>();
a = c;
}

if (Bedingung1)
b.add(new Integer(0));
else
c.add(new Float(0));

aber nicht mit nur einer Variablen a

 

[tarzan]

Schade ich dachte es geht irgendwie eleganter. Jetzt muss ich für jeden Typ den selben Code schreiben. Danke dir

 

[Marco13]

Vielleicht geht es eleganter. Evtl. würde es helfen, wenn du genauer beschreiben würdest, was in der Methode gemacht werden soll, die jetzt "test" heißt. Sowas hier würde zwar funktionieren, ist jetzt in bezug auf das Ziel natürlich... nur hingekrampft

public class Klasse<T extends Comparable<T>>
{

    public static void main(String args[])
    {
       Klasse<? extends Comparable<?>> a = new Klasse<Integer>();
       a.test();
    }


    public void add(T a)
    {
    }

    public void test()
    {
       Klasse<? extends Comparable<?>> a = null;

       if (true)
       {
           a = createAndAdd(new Integer(0));
       }
       else
       {
           a = createAndAdd(new Float(0));
       }
    }


    <Type extends Comparable<Type>> Klasse<Type> createAndAdd(Type element)
    {
        Klasse<Type> klasse = new Klasse<Type>();
        klasse.add(element);
        return klasse;
    }
}

 

[SlaterB]

wie habe ich es doch vor kurzem irgendwo so schön gelesen?:
ein Generischer Parameter sollte IMMER nur aus einem Großbuchstaben bestehen, damit er nicht mit einem echten Typ verwechselt wird

 

[tarzan]

Wichtig für mich ist, dass die add-Methode von Klasse funktioniert. Ich will nachdem ich a initialisiert habe typsicher Objekte dazufügen können. Also derart:

public static void main(String args[]) 
{ 
       Klasse<? extends Comparable<?>> a = new Klasse<Integer>(); 
       a.add(new Integer(0));
       a.add(new Integer(1));
       a.add(new Float(4));   // Fehler!

}

 

[SlaterB]

du kannst add(new Integer(0)); ausschließlich an einem Objekt Klasse<Integer> sicher aufrufen,
einfache Regel

 

[L-ectron-X]

Noch am Rande:

Es sollte besser nicht new Integer() oder new Float() verwendet werden, weil das etwas mehr Speicher verbraucht und nicht ganz so performant ist.
Besser und richtig ist es, die jeweilige valueOf()-Methode der entsprechenden Wrapper-Klasse zu benutzen.

 

[Der Müde Joe]

Zu den wilcards noch:

If the user of a class has to think about wildcard types, there is probably something wrong with the class's API

J.Bloch, Effective Java SE, Item 28

 

[tarzan]

@SlaterB Einleuchtend.

@L-ectron-B Weißt du ob Integer.valueOf() auch beim autoboxing zum Einsatz kommt?

 

[SlaterB]

du weißt es selber, nachdem du es ausprobiert hast

 

[Marco13]

wie habe ich es doch vor kurzem irgendwo so schön gelesen?:
ein Generischer Parameter sollte IMMER nur aus einem Großbuchstaben bestehen, damit er nicht mit einem echten Typ verwechselt wird

War mir nicht bekannt. Weißt du noch, WO du das gelesen hast?

 

[SlaterB]

http://www.tutego.com/java/java-buch-rezensionen.html

zum Buch

Hardcore Java
Robert Simmons. O'Reilly.

Typvariablen sollten immer nur aus einzelnen Großbuchstaben bestehen. Bei einer Deklaration wie Type getValue() sieht sonst Type wie ein ordinären Java-Typ aus.

-------

aber ist doch egal wer das wo geschrieben hat,
der Satz macht für sich schon Sinn

 

[tarzan]

@SlaterB

Habe einen Vector mit Integern gefüllt und bekomme gleiche Zeiten für Autoboxing, new Integer() und Integer.valueOf() (jeweils 1 s und rund 100 ms für 3.000.000 Werte)

 

[SlaterB]

naja, nicht gerade Zeiten messen,

ich meinte, Integer k = 1; mit Integer.valueOf(1) auf == zu testen,

Autoboxing verwendet jedenfalls valueOf, richtig

 

[Marco13]

Hm. Das Argument leuchtet mir einerseits ein, andererseits finde ich, dass man Typparameter, die mit dem Suffix "...Type" aufhören, leicht als solche erkennt. Sowas wie

class MyContainer<E,L,S> { ... }

ist eben IMHO nicht so ... "sprechend" und selbsterklärend wie sowas wie

class MyContainer<ElementType,ListenerType,SourceType> { ... }

oder so... (Und schließlich hintert einen ja niemand dran, eine Klasse Names "E" zu erstellen :wink: ) Aber nachdem ich mal gewebsucht habe, und das mit den "Ein-Buchstaben-Parameternamen" auch auf http://java.sun.com/docs/books/tutorial/java/generics/gentypes.html steht, werde ich mich da vielleicht in Zukunft eher dran halten.

 

[SlaterB]

kommt ganz auf die jeweilige Benennung an, ich z.B. habe viele Enum-Klassen, die auf -Type enden

edit: in der Java-API anscheinend auch so:
java.lang.annotation.ElementType

oder auch Interface
java.lang.reflect.Type