Reflection objekt mit generics erzeugen

[Guest]

Ich hab mittlerweile schon einige Zeit zu Reflection herumgelesen, doch hänge einfach an einer stelle. Ich weiß wie ich dynamisch Objekte erzeugen kann, wie ich Konstruktoren finde und so weiter. Aber wie gehts das ich ein Objekt welches Generics verwendet dynamisch erzeuge?

ArrayList<Integer> list = new ArrayList<Integer>();

Bin wirklich ratlos. Für hinweise wäre ich dankbar.

 

[Wildcard]

Zur Laufzeit gibt es gar keine Generics, die sind nur für den Compiler.

 

[Gast]

Das heisst wenn ich über Reflection eine ArrayList erzeuge ist die immer "typunsicher" und ich kann sie keiner getypten liste zuweisen?

 

[Wildcard]

Richtig. Dir ist sicherlich auch aufgefallen das es nicht keine Exception gibt wenn du ein falsches Element in eine typisierte Collection packst, sondern einen Compiler Error. Zur Laufzeit ist diese Information einfach nicht vorhanden.

 

[Murray]

Sieh dir mal dieses Beispiel an:

import java.util.*;

public class G {

	public static void main( String[] args) {
		try {
			List<Integer> lstInt = new ArrayList<Integer>();
			List<String> lstStr = new ArrayList<String>();
			Class clsLstInt = lstInt.getClass();
			Class clsLstStr = lstStr.getClass();			
			
			//--- neue Instanz der Klasse von lstInt bilden -> da das Objekt lstInt
			//--- vom Typ ArrayList<Integer> ist, müssten wir also gefahrlos casten 
			//--- können
			List<Integer> lstInt2 = (List<Integer>)(clsLstInt.newInstance());
			lstInt2.add( new Integer( 1));
			
			//--- jetzt kommt eine neue Instanz der Klasse von lstStr -> da lstStr 
			//--- vom Typ ArrayList<String> ist, müsste der Cast auf List<Integer> 
			//--- doch eigentlich schiefgehen, wenn das Class-Objekt wirklich relevante 
			//--- Information über den generischen Type enthalten würde. Das klappt 
			//--- aber ganz problemlos; obwohl die Liste als Instanz der Klasse ArrayList<String>
			//--- erzeugt wurde, lässt sie sich als List<Integer> verwenden
			List<Integer> lstInt3 = (List<Integer>)(clsLstStr.newInstance());
			lstInt3.add( new Integer( 1));
			
			System.out.println( "lstInt.class: " + clsLstInt.getName());
			System.out.println( "lstStr.class: " + clsLstStr.getName());
			System.out.println( "equal( clsLstStr, clsLstInt):" + clsLstStr.equals( clsLstInt));
			System.out.println( "identical( clsLstStr, clsLstInt):" + clsLstStr == clsLstInt);

		} catch ( Exception e) {
			e.printStackTrace();
		}
	}
}

Wie man der Ausgabe entnimmt, sind die beiden Class-Objects nicht nur gleich, sondern sogar objekt-identisch.

 

[Thomas Darimont]

Hallo,

Zur Laufzeit gibt es gar keine Generics, die sind nur für den Compiler.

Das stimmt nicht ganz, siehe:

/**
 * 
 */
package de.tutorials;

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

/**
 * @author Thomas.Darimont
 * 
 */
public class GenericTypeDetection {
	public static void main(String[] args) {
		System.out.println(new Foo<String>(){}.getType());
	}

	static abstract class Foo<T>{
		Type type;
		
		/**
		 * @return the type
		 */
		public Type getType() {
			return type;
		}

		/**
		 * @param type the type to set
		 */
		public void setType(Type type) {
			this.type = type;
		}

		public Foo(){
			this.type = ((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
		}
	}
}

Gruß Tom