Typ von geerbter generischer Klasse abfragen

maho15

Erfahrenes Mitglied
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:
PHP:
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
PHP:
public class UnterGenerisch extends Generisch<Integer> {
}

Was ich gerne machen möchte:
PHP:
public static void main(String[] args) {
           UnterGenerisch test = new UnterGenerisch();
	   test.getClass().istDasDerGenerischeTyp(Integer) //gibt true zurueck
 

Anime-Otaku

Erfahrenes Mitglied
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.
 
Zuletzt bearbeitet:

Yaslaw

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

Java:
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);
    }
  }

Java:
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
Java:
    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());
        }
    }
 
Zuletzt bearbeitet von einem Moderator:

Thomas Darimont

Erfahrenes Mitglied
Hallo,

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

Java:
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:
Code:
class java.lang.String
false
true
true
false

Gruß Tom