Generic muss zwei Klassen/Interfaces erfüllen

[xZise]

Hallo ich habe das Problem das ich nicht weiß wie ich folgendes lösen kann:

Ich habe eine Liste mit Elementen vom Typ T und eine Methode die ein Element von Typ T zurückgeben kann. Zusätzlich kann diese Liste eine Stringrepräsentation zurückgeben, welche aber aufgrund zwei verschiedener Verfahren erfolgen kann:

1. Die Einträge der Liste implementieren ein bestimmtes Interface (T extends Interface)
2. Es gibt eine Klasse, die den Text für jeden Eintrag der Liste zurückgibt (T darf "alles" sein)

Der zweite Fall ist relativ einfach, weil der Typ T alles sein darf und nur diese Klasse, welche das „übersetzt“ muss eine Liste mit Elementen vom Typ T akzeptieren. Aber beim ersten Fall verzweifle ich gerade, weil ich kann im Konstruktor nicht sagen, dass die Liste vom Typ T und vom Typ „Interface welche den Text zurück gibt“ sein muss.

So sieht aktuell die Implementierung aus:

public class Liste<T> {
	
	private final A<T> namer;

	public static interface NamedListItem {
		String getItemName();
	}

	public static final ListItemNamer<Object> TO_STRING_NAMER = new ListItemNamer<Object>() {
		@Override
		public String getItemName(Object t) {
			return t == null ? "null" : t.toString();
		}
	};

	public static interface ListItemNamer<T> {
		String getItemName(T t);
	}

	public static interface A<T> {
		T getItem(int i);
		String getItemText(int i);
	}

	public static final class NamedListNamer<X extends NamedListItem> implements A<X> {
		private final List<X> namedItemlist;

		public NamedListNamer(final List<X> namedItemlist) {
			this.namedItemlist = namedItemlist;
		}

		public X getItem(int i) {
			return this.namedItemlist.get(i);
		}

		@Override
		public String getItemText(int i) {
			return this.getItem(i).getItemName();
		}
	}

	public static final class ListNamer<T> implements A<T> {
		private final List<? extends T> list;
		private final ListItemNamer<? super T> namer;

		public ListNamer(final List<? extends T> list, final ListItemNamer<? super T> namer) {
			this.list = list;
			this.namer = namer;
		}

		@Override
		public T getItem(int i) {
			return this.list.get(i);
		}

		@Override
		public String getItemText(int i) {
			return this.namer.getItemName(this.getItem(i));
		}
	}

	public String getItemText(int index) {
		return this.namer.getItemText(index);
	}

	public T getItem(int index) {
		return this.namer.getItem(index);
	}

	public <L extends T & NamedListItem> Liste(final List<L> list) {
		this.namer = new NamedListNamer<T>(list);
	}

	public Liste(final List<? extends T> list, ListItemNamer<? super T> namer) {
		this.namer = new ListNamer<T>(list, namer);
	}
}

Der Fehler lautet:

Cannot specify any additional bound Liste.NamedListItem when first bound is a type parameter

Vielleicht hat jemand eine bessere Idee das umzusetzen, nur möchte ich nicht „Object.toString()“ nutzen um den Text für jeden Eintrag zurückzugeben. Und die Namen für die Klassen/Schnittstellen sind auch noch nicht endgültig, aber erstmal will ich das Problem los werden.

Fabian

 

[nillehammer]

Ich würde das ähnlich machen, wie bei den sortierten Collections. Denen kann man eine Instanz eines Comparator-Interfaces bei der Instanzierung mitgeben. An diese wird der Vergleich dann delegiert. Mit der Ausgabe einer Stringrepräsentation könntest Du es genauso machen.

Definiere ein Interface ItemRenderer, welches, die Ausgabe der Stringrepräsentation der Instanz einer best. Klasse übernimmt. Übergebe dieses als Konstruktorparameter an Deine Liste. Code wäre ungefähr so:

public interface ItemRenderer<T> {
  public String render(final T objToRender);
}

public Liste<T> {

  private final ItemRenderer<T> itemRenderer;

  public Liste(final ItemRenderer<T> itemRenderer) {

    this.itemRenderer = itemRenderer;
  }
}

Über die konkreten Implementierungen kannst du dann steuern, was genau ausgegeben wird. Ein PersonRenderer könnte bspw. Vorname Nachname ausgeben.

 

[faetzminator]

Der Fehler lautet:

Cannot specify any additional bound Liste.NamedListItem when first bound is a type parameter

Soviel mir ist, sind nur Interfaces zugelassen. Also weder Klassen noch irgendwelche unklaren Types. D.h. es gibt eigentlich nur zwei Möglichkeiten. Entweder ist T bereits extends XY, oder aber du erstellst eine Kindklasse derer, die dann eben ein T extends XY erwartet.
Edit: Gerade getestet: Es kann auch eine Klasse und Interface(s) sein, wenn man die Klasse als erstes angibt.

 

[andiv]

Der Hinweis auf Comparator ist gut, noch besser wird er wenn du dir gleich noch Comparable dazu anschaust. Pseudocode:

interface Comparable<T> {
    int compareTo(T obj);
}

interface Comparator<T> {
    int compare(T obj1, T obj2);
}

class Collections {
    static <T extends Comparable<T>> void sort(List<T> list) {...}
    static <T> void sort(List<T> list, Comparator<T> comp) {...}
}

Die sort-Methode ohne Comparator kann dann auf die andere sort-Methode zurückgreifen indem einfach ein Comparator erstellt wird der die compareTo-Methode der T-Objekte verwendet.

Dieses Vorgehensschema sollte sich eigentlich ohne weiteres auf deinen Anwendungsfall übertragen lassen.

 

[andiv]

Also ich stell mir das so in der Art vor, printList ohne Printer kann dann wieder auf die andere Methode zurückgreifen indem ein Printer erstellt wird der die print-Methode der Printable-Objekte aufruft.

interface Printable {
    String print();
}

interface Printer<T> {
    String print(T obj);
}

class Utility {
    <T extends Printable> String printList(List<T> list) {...}
    <T> String printList(List<T> list, Printer<T> printer) {...}
}

 

[xZise]

Genau an dieses [c]Comparable[/c] und [c]Comparator[/c] gespann habe ich auch gedacht. Es gibt ja [c]NamedListItem[/c] und [c]ListItemNamer[/c] welche genau das übernehmen. Jetzt wollte ich eine Liste darum packen, wo man entweder eine Liste mit NamedListItem übergibt, oder halt eine einfache Liste und dann mit dem ListItemNamer welcher dann das übernimmt.

Aber wenn ich die Liste mit NamedListItems haben will, dann muss diese ja auch von T erben. Und das kann ich nicht machen: Entweder meckert er rum, dass die Liste nicht unbedingt NamedListItems enthält oder das die Liste nicht unbedingt elemente von T enthält.

Und mir ist schleierhaft, wieso [c]<L extends T & NamedListItem>[/c] nicht geht. Den [c]NamedListItem[/c] ist ja ein Interface.

Fabian