Generics - W.card unter Nutzung von Annotationsklasse?

[Guest]

Hallo liebes Java-Forum,
ich stehe vor folgendem Problem: Bestimmte Klassen sind durch eine Annotation gekennzeichnet. Jetzt wollte ich zum Ausdruck bringen, dass in einer Liste nur Objekte von Klassen enthalten sein dürfen, die durch diese Annotation markiert sind.

@Annotation
public class X {

}

public class Y {
...
//innerhalb einer methode
List<...> meineListe;
...
}

In dem Fall sollten also Objekte vom Typ X in der Liste gespeichert werden dürfen. Falls eine Klasse nicht durch die Annotation gekennzeichnet ist dürfen die Objekte dieser Klasse nicht in der Liste gespeichert werden.

Ist das überhaupt möglich? Also kann ich die Generics wie beschrieben mit Annotationen verbinden und das so machen?

 

[0x7F800000]

öööhm... Ob das mit Annotationen in der Form möglich ist bezweifle ich, allerdings denke ich mal, dass das was du brauchst eher Generics der form

<X extends Y>
oder
<? extends Y>

sind. Ist hier vielleicht was?

 

[Guest]

Danke für die Antwort.

Also in dem Fall kann ich nicht mit extends arbeiten, das funktioniert nicht.

Dann muss ich wohl meine gesamte Klassenstruktur über den Haufen werfen, da ich dann keine Annotationen verwenden kann.

Falls einer doch noch was dazu weiss wäre ich für eine Antwort dankbar.

 

[fjord]

Wie wäre es mit einem leeren Interface, das von den Klassen implementiert wird und du machst die Liste dann von dem Typ des Interfaces?

 

[Landei]

Oder ein Holder-Objekt?

class X{...}
class Y{...}

public abstract class Holder<T> {
   private final T t;
   private final Class<T> clazz;
   public Holder(T t, Class<T> clazz) {
      this.t = t;
      this.clazz = clazz;
   } 
   T get() {
      return t; 
   }
   Class<T> getClazz() {
      return clazz;
   }
}

class XHolder extends Holder<X> {
   public XHolder(X x) {
      super(x, X.class);
   }
}
class YHolder extends Holder<Y> {
   public YHolder(Y y) {
      super(y, Y.class);
   }
}

List<Holder<?>> list = new ArrayList<Holder<?>>();
X x = getX(); 
list.add(new XHolder(x));
Y y = new Y();
list.add(new YHolder(y));

 

[Gast]

An fjord: Ja, das wäre natürlich möglich. Aber ich fand das schon bei Serializable etc. immer unschön, weil das Interface dann eigentlich keinen richtigen Sinn macht.

Das mit dem Holder-Objekt muss ich mir nochmal anschauen.

Danke auf jeden Fall.

 

[Landei]

Der Vorteil der Holder-Vorgehensweise ist, dass du an den "listbar" zu machenden Klassen nichts verändern musst.

Beim Auslesen von den Holder-Objekten muss natürlich wieder gecastet werden. Das mit der clazz-Variable fand ich hin und wieder nützlich, aber das kann man auch weglassen (instanceof-Tests auf den konkreten Holder-Typ tun es natürlich auch).