Generic Problem

[andre111]

Hallo,

hab gerade ein Problem mit Generics, und zwar hab ich folgenden Code:

[highlight=Java]public interface A {}

public class AImpl implements A {
public void onlyInAImpl() {
System.out.println("Test");
}
}

public interface B<T extends A> {
public void foo(T param);
}

public class BImpl implements B<AImpl> {
public void foo(AImpl param) {
param.onlyInAImpl();
}
}


public class Test
{
private List<A> objects;
private Map<Class<? extends A>, B<? extends A>> map;


public Test()
{
objects = new ArrayList<A>();
objects.put(new AImpl());
map = new HashMap<Class<? extends A>, B<? extends A>>();
map.put(AImpl.class, new BImpl());
}


public void fooTest()
{
for(A a : objects)
{
map.get(a.getClass()).foo(a);
}
}
}[/highlight]

In Zeile 39 bekomme ich nun folgende Fehlermeldung:

The method foo(capture#2-of ? extends A) in the type B<capture#2-of ? extends A) is not applicable for the arguments (A).

Allerdings weis ich nicht was ich dagegen machen kann, ich vermute dass es an den definierten Generics der Map liegt. Die Generic-Struktur der Interfaces A und B möchte/muss ich allerdings so beibehalten.

Bitte um Hilfe.
Danke im Voraus

Gruß André

 

[andre111]

Wenn ich folgendes schreib:

[highlight=Java]public void fooTest()
{
for(A a : objects)
{
B b = map.get(a.getClass());
b.foo(a);
}
}[/highlight]

Dann funktioniert es, allerdings ist das ziemlich unsauber, weil dadurch die Typsicherheit verloren geht.

 

[andre111]

Keiner ne Idee?:noe:

 

[SlaterB]

das Interface B verlangt irgeneinen Typ T extends A, genau dieser Typ T muss als Parameter übergeben werden, nicht A selber,
für BImpl ist das beispielsweise AImpl, ein anderes A bringt gar nix, führt zur ClassCastException, es muss schon genau AImpl sein,

wenn du den Typ T nicht kennst, dann kannst du die Methode eben nicht sinnvoll aufrufen,
falls es noch eine andere Methode wie T get() gibt, dann hilft dir das weiter, dann kannst du das zurückgegebene Objekt auf A casten,
aber die genaue Klasse kennst du ebenso nicht

du kannst entweder die Map auf
Map<Class<? extends A>, B<AImpl>> umbiegen, dann kannst du BImpl einfügen, diesem aber keine A-Objekte, sondern nur AImpl-Objekte übergeben

oder du verwendest eine Map
Map<Class<? extends A>, B<A>>
dann wirst du aber BImpl nicht einfügen können

 

[0x7F800000]

nun ja, deine methode "foo(AImpl)" aus der Klasse "BImpl implements B<AImpl>" verlangt eben ein sehr spezielles "AImpl", also kannst du natürlich kein allgemeines "A" aus dieser "List<A> objects" an diese "foo(AImpl)" methode verfüttern, was will man denn da machen? :bahnhof:

Allgemein sieht für mich das ziemlich suspekt aus, könntest du vielleicht kurz an einem konkreten Beispiel skizzieren, was du mit dieser abgefahrenen Map von Klassen vorhattest?

 

[andre111]

Ich arbeite grad an nem Projekt bei dem sich einzelne Shapes mit der Maus bewegen, drehen, vergrößern, verkleinern lassen. Dabei gibt es für jeden ShapeTyp (z.B. ein Rechteck) eine Klasse Shape die die Position, Farbe usw speichert, und einen "ShapeManager" der sich um das verschieben usw. kümmert.

Jetzt hat jedes Shape einen ShapeManager, da sich jedes Objekt in gewisser Weise anders verhält.

In der Map hab ich nun zum jeweiligen Shape den zugehörigen ShapeManager abgespeichert und in der List die einzelnen Shapes selber.

In gewisser Weise weis man ja dann welcher Manager zu welchem Shape gehört, da ich ja mit shape.getClass() den passenden Manager aus der Map "hole".

(A entsprach dem Shape, B dem Manager und Test dem gesamten "Bild" in dem alles stattfindet).

 

[SlaterB]

tja, zu solcher Dynamik hat Generics glaube ich nicht das beste Verhältnis,

man kann sicher nicht garantieren, dass beim Einfügen in
Map<Class<? extends A>, B<? extends A>>
das Class-Objekt des Keys zum Value passt, die beiden Angaben sind nicht verknüpft,

generell könntest du an dieser Stelle auf Generics verzichten und alles passend casten und darauf vertrauen, dass alles nur korrekt definiert ist,
oder zumindest diese Ungenauigkeit auf genau zwei Methoden beschränken:

class SpecialMap {
private Map<Class<? extends A>, B<? extends A>> map 
      = new HashMap<Class<? extends A>, B<? extends A>>();


public <T extends A> B<T> get(Class<T> c) {
   return map.get(c);
}

public <T extends A> B<T> get(T t) {
   return map.get(t.getClass());
}

public <T extends A> void put(Class<T> c, B<T> b) {
      map.put(c, b);
}

}

so in der Tat, ungetestet, vielleicht mit abweichender Syntax,
eine der beiden get-Methoden wird sicher reichen

bei beiden get() wird immer noch die generische Unsicherheit auftreten,
da man da sowieso Warnings unterdrücken und/ oder Casten muss, könnte man vielleicht genauso gut
private Map map = new HashMap();
verwenden

die put()-Methode garantiert hier, dass es keinen Ärger geben wird

 

[andre111]

Im Prinzip besteht keine Unsicherheit, da ich beim einfügen in die Map überprüfe ob das Shape zum Manager passt.
Also danke
André

 

[0x7F800000]

Ääähm, und wieso dann der umweg über die Map, warum weist du jeder Shape nicht einfach den passenden ShapeManager zu?

Irgendwiesowas würde mir da spontan einfallen:
[HIGHLIGHT="Java"]
interface ShapeManager<X extends Shape<X>>{
void move(X x);
void rotate(X x);
}

interface Shape<X>{
ShapeManager<X> getShapeManager();
}

class Rectangle implements Shape<Rectangle>{
int x, y;

private static final ShapeManager<Rectangle> rectShapeManager=
new ShapeManager<Rectangle>{
@Override
public void move(Rectangle rect){
rect.x+=23;
rect.y+=32;
}
...
}
};

@Override
public ShapeManager<Rectangle> getShapeManager(){
return rectShapeManager;
}
}
[/HIGHLIGHT]
ich weiß jetzt nicht, ob das auch nur annähernd optimal ist, was ich aber sagen will: lass diese komischen class-maps weg, und gebe den passenden shapeManager lieber direkt von der dazugehörigen shape zurück.

 

[andre111]

*mich selber umbringen will* xD
Macht irgendwie echt mehr Sinn.
thx

 

[0x7F800000]

*mich selber umbringen will* xD
Macht irgendwie echt mehr Sinn.

Natürlich macht Suizid mehr Sinn, das ist die schnellste und kostengünstigste Lösung für praktisch jedes erdenkliche Problem. :autsch:

 

[andre111]

Macht irgendwie echt mehr Sinn war auf deine Lösung bezogen^^

 

[0x7F800000]

das hoffe ich doch

ne, schon klar, just kidding^^

 

[andre111]

[highlight="Java"]
interface ShapeManager<X extends Shape<X>>{
void move(X x);
void rotate(X x);
}

interface Shape<X>{
ShapeManager<X> getShapeManager();
}

class Rectangle implements Shape<Rectangle>{
int x, y;

private static final ShapeManager<Rectangle> rectShapeManager=
new ShapeManager<Rectangle>{
@Override
public void move(Rectangle rect){
rect.x+=23;
rect.y+=32;
}
...
}
};

@Override
public ShapeManager<Rectangle> getShapeManager(){
return rectShapeManager;
}
}
[/highlight]

Das funktioniert so noch nicht ganz, weil:

interface Shape<X>{
ShapeManager<X> getShapeManager();
}

Allerdings müsste auch X Unterklasse von Shape sein, da der ShapeManager ja auch ein X extends Shape will. Ich habs jetzt so:

[highlight=Java]interface ShapeManager<T extends Shape<T>> {}

interface Shape<T>
{
public ShapeManager<Shape<T>> getShapeManager();
}

class Rectangle extends Shape<Rectangle>
{
public ShapeManager<Rectangle> getShapeManager()
{
return ...;
}
}[/highlight]

 

[andre111]

Doppelpost, hab auf Zitieren statt Editieren gedrückt

 

[0x7F800000]

Hm Hm Hm, warnings sind schlecht.
Ich habe durch ein wenig rumfummeln an generics festgestellt, dass auch bei größeren aufeinandergestapelten generics-Konstrukten Warnings fast immer vermeidbar sind ???:L

Hast du die jetzt wegbekommen?

 

[andre111]

Ne noch nicht, wenn dann wären es wahrscheinlich aber nur ein paar Zeilen.