Typ von geerbter generischer Klasse abfragen

[maho15]

Hallo,

ich hoffe die untere Beschreibung ist verständlich.
Gibt ein eine Möglichkeit abzufragen wie der generische Typ einer geerbten Klasse ist?

Danke im Vorraus!


Genersiche Oberklasse:

public abstract class Generisch<T> {
    private ArrayList<T> list = new ArrayList<T>();
    
    public void addValue(T value)
    {
    	this.list.add(value);
    }
  }

Klasse die von Generisch erbt

public class UnterGenerisch extends Generisch<Integer> {
}

Was ich gerne machen möchte:

public static void main(String[] args) {
           UnterGenerisch test = new UnterGenerisch();
	   test.getClass().istDasDerGenerischeTyp(Integer) //gibt true zurueck

 

[Anime-Otaku]

value.getClass();

Dadurch bekommst du der Datentyp der die Variable zur Laufzeit hat. Dann kann man mit der Methode isInstanceOf(Class) von Class erkennen, ob diese Klasse zur Laufzeit eine Instanz davon ist. Ein normales instanceOf hilft da nichts.


Was für Informationen brauchst du den genau? Um dein Problem vielleicht besser zu verstehen.

 

[Yaslaw]

Du kannst die Klasse einer Variable vom Type T nehmen.
Der Code ist nicht besonders schön, zeigt aber worauf ich hinaus will.

public abstract class Generisch<T> {
    private ArrayList<T> list = new ArrayList<T>();
    private Class<?> valueClass;    

    public void addValue(T value)
    {
        this.list.add(value);
        valueClass= value.getClass();
    }

    public istDasDerGenerischeTyp(Class<?> testClass){
        return valueClass.equals(testClass);
    }
  }

public static void main(String[] args) {
           UnterGenerisch test = new UnterGenerisch();
       test.istDasDerGenerischeTyp(Integer.class) //gibt true zurueck

Hab mal den folgenden Codeschnippel ausgetestet um zu sehen ob der Classenvergleich funktioniert - er funktioniert

    private <T> Boolean isClassOf(T value, Class<?> testClass){
        return value.getClass().equals(testClass);
    }

    public void test1(){
        try {
            Integer value = 1;
            assertTrue(isClassOf(value, Integer.class));
        } catch (Exception e) {
            fail(e.getMessage());
        }
    }

    public void test2(){
        try {
            Integer value = 1;
            assertTrue(! isClassOf(value, String.class));            
        } catch (Exception e) {
            fail(e.getMessage());
        }
    }

 

[maho15]

Du kannst die Klasse einer Variable vom Type T nehmen.
Der Code ist nicht besonders schön, zeigt aber worauf ich hinaus will.

Danke für die Antwort, schaut gut aus.

 

[Thomas Darimont]

Hallo,

schau mal hier:
http://www.tutorials.de/forum/java/310803-java-generics-generischen-typ-ermitteln.html

package de.tutorials;

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

public class GenericTypeDetection {
	public static void main(String[] args) {
		Sub sub = new Sub();
		
		//Basis:
		System.out.println(((ParameterizedType) sub.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);

		//Beispiel Implementierung:
		System.out.println(isInstanceOf(sub, List.class, String.class));
		System.out.println(isInstanceOf(sub, Base.class, String.class));
		System.out.println(isInstanceOf(sub, Base.class, CharSequence.class));
		System.out.println(isInstanceOf(sub, Base.class, Integer.class));

	}

	static class Base<T> {
	}

	static class Sub extends Base<String> {
	}
	
	static boolean isInstanceOf(Object o, Class<?> clazz, Class<?>... typeArguments) {
		boolean result = clazz.isInstance(o);

		if (result && o != null) {
			Object genericSuperClass = o.getClass().getGenericSuperclass();
			if (genericSuperClass instanceof ParameterizedType) {
				/*
				 * flacher Vergleich... keine Unterstützung für GenericTypes á la List<Map<String,String>>
				 */
				ParameterizedType parameterizedType = (ParameterizedType) o.getClass().getGenericSuperclass();
				Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
				for (int i = 0; i < typeArguments.length; i++) {
					result &=    actualTypeArguments[i].equals(typeArguments[i]) 
							  || typeArguments[i].isAssignableFrom((Class<?>)actualTypeArguments[i]);
				}
			}
		}

		return result;
	}
}

Ausgabe:

class java.lang.String
false
true
true
false

Gruß Tom