Updates

• 22. November 2017

Collections im Zusammenspiel mit Generics erlauben es, ohne Cast auf Elemente gleichen Typs typsicher zuzugreifen - was aber wenn man typsicher auf Elemente unterschiedlicher Typen in einer Collection zugreifen möchte, ohne zu casten? Hier die Vorstellung einer möglichen Antwort

Die Einführung von Generics in Java machte einiges im Quelltext übersichtlicher: Unter anderem Ist es jetzt nicht mehr notwendig, aus Collections entnommene Objekte zu casten, um mit Ihnen weiterarbeiten zu können. Damit wird der Quelltext übersichtlicher und leichter zu verstehen. Viele haben beklagt, daß die Informationen über die Template-Parameter zur Laufzeit nicht zur Verfügung stehen, aber das ist Geschmackssache, beziehungsweise durch einfache Maßnahmen nachrüstbar. Collections im Zusammenspiel mit Generics erlauben es, ohne Cast auf Elemente gleichen Typs zuzugreifen – für den Anwendungsfall, daß Elemente verschiedenen Typs in einer Collection gespeichert werden, hilft das nicht weiter. Als Veranschaulichung sei folgendes Beispiel gegeben:

java.util.Map m=new java.util.HashMap();
m.put("double",java.lang.Double.valueOf(3.1415));
m.put("int",java.lang.Integer.valueOf(1234));
m.put("string","huhu");

Der Zugriff auf die einzelnen Elemente muß normalerweise über einen Cast erfolgen. Man könnte dafür natürlich eine JavaBean erzeugen und verwenden, die in diesem Fall wie folgt aussehen könnte:

public class Bean
{
	private double d;
	private int i;
	private java.lang.String s;
	public  getI()
	{
		return i;
	}
	public void setI(int o)
	{
		i=o;
	}
	public  getD()
	{
		return d;
	}
	public void setD(double o)
	{
		d=o;
	}
	public  getS()
	{
		return s;
	}
	public void setS(String o)
	{
		s=o;
	}
}

Falls es aber aus irgendwelchen Gründen keine Option ist, eine solche Bean-Klasse einzusetzen, ist es extrem hinderlich, deswegen extra jedesmal beim Zugriff auf eines der Elemente einen Cast schreiben zu müssen. Wenn beim Zugriff auf die Elemente über ihren Namen der Typ bekannt ist, lässt sich einfach ein weiteres Generics-Feature zur Lösung heranziehen: eine generische Methode. Diese sähe dann wie folgt aus:

public <T> T fetch(java.lang.String key,Class<T> cls)
{
	Object o;
	o=m.get(key);
	return cls.cast(o);
}

Damit kann man dann zum Beispiel folgende Zugriffe realisieren (das Beispiel oben wird fortgeführt):

java.lang.Double d1=fetch("double", java.lang.Double.class);

Für Fundamentaldatentypen (oder jeden anderen, oft benötigten Klassentyp) kann man noch Abkürzungen wie folgt definieren:

public int fetchInt(java.lang.String key)
{
	return fetch(key, java.lang.Integer.class).intValue();
}

Aktualisierung vom 22. November 2017

public class TypeSafeHashMap<T,V> extends java.util.HashMap<T,V>
{
	public TypeSafeHashMap(int initialCapacity, float loadFactor)
	{
		super(initialCapacity, loadFactor);
	}

	public TypeSafeHashMap(int initialCapacity)
	{
		super(initialCapacity);
	}

	public TypeSafeHashMap()
	{
	}

	public TypeSafeHashMap(Map<? extends T, ? extends V> m)
	{
		super(m);
	}

	public <U extends V> U fetch(T key,Class<U> cls)
	{
		V o;
		o=get(key);
		return cls.cast(o);
	}
/*	public int fetchInt(T key)
	{
		return fetch(key, Integer.class).intValue();
	}
*/
/*	public static void main(java.lang.String[] args)
	{
		TypeSafeHashMap<String,Number> tsmap=new TypeSafeHashMap();
		tsmap.put("1",Integer.valueOf(1));
		tsmap.put("2",Double.valueOf(2));
		Integer a=tsmap.fetch("1", java.lang.Integer.class).intValue();
		JComponent b=tsmap.fetch("1", JPanel.class);
	}
*/}

Artikel, die hierher verlinken