mit abstrakten Klasse Methode

Question

Ich möchte so etwas wie dies in Java erreichen, aber immer kompilieren Zeitfehler:

The method onMessage(TextMessage, Class) in the type AbstractTestLoader is not applicable for the arguments (TextMessage, Class)

ich den Grund des Fehlers zu verstehen, aber ich fühle mich auch sollte es sein eine Möglichkeit, dies mit Casting zu erreichen oder auf andere Weise.

Answer 1

Endlich, nach ein paar Versuchen bekomme ich einfach einfache und funktionierende Lösung, aber ich bin offen für andere beste Antworten, wenn möglich. Dank

public abstract class AbstractTestLoader<T extends AbstractEntity<T>> { 

    abstract Class<T> getEntityType(); 

    public void onMessage(TextMessage message) throws Exception { 
     onMessage(message, getEntityType()); 
    } 

    public void onMessage(TextMessage message, Class<T> clazz) throws Exception { 
     //here my original logic will go 
    } 
} 

Answer 2

Java implements generics via type erasure, was bedeutet, dass es nur ein Kompilierung-Konzept ist. Wenn das Programm läuft, gibt es keinen Unterschied zwischen AbstractTestLoader<Foo> und AbstractTestLoader<Bar>.

Es gibt einige Problemumgehungen, wie die, die Sie entdeckt haben, bei denen eine Klasse, die den Typ T zur Kompilierzeit kennt, einen tatsächlichen Klassentyp bereitstellen kann. Aber es gibt keine Möglichkeit, reine Generika zu verwenden, um zu ermitteln, was der generische Typ zur Laufzeit ist.

Answer 3

Es sollte beachtet werden, dass während Java Generic zur Laufzeit gelöscht wurde, es begrenzte Reflektionsapis gibt, um sie abzurufen, wenn sie in der Klassendatei vorhanden sind.

Hier ist eine schnelle Lösung mit dieser Annahme:

1. AbstractTestLoader die direkte Superklasse ist.
2. Unterklassen verwenden keinen Wildcardtyp, wenn eine Superklasse deklariert wird, z. Sub-Klassen wie diese class GenericLoader<T extends SubclassAbstractEntity<T>> extends AbstractTestLoader<T> existiert nicht. Hier

ist der Code:

public class AbstractTestLoader<T extends AbstractEntity<T>> { 

    private static final ClassValue<Class<?>> TYPE_PARAMETER_CACHE = new ClassValue<Class<?>>() { 
     @Override 
     protected Class<?> computeValue(Class<?> type) { 
      assert AbstractTestLoader.class.isAssignableFrom(type); 
      assert type.getSuperclass() == AbstractTestLoader.class; 
      Type genericSuperclass = type.getGenericSuperclass(); 
      assert genericSuperclass instanceof ParameterizedType; 
      Type entityType = ((ParameterizedType) genericSuperclass).getActualTypeArguments()[0]; 
      assert entityType instanceof Class<?>; 
      return (Class<?>) entityType; 
     } 
    }; 

    @SuppressWarnings("unchecked") 
    protected Class<T> getEntityType() { 
     return (Class<T>) TYPE_PARAMETER_CACHE.get(this.getClass()); 
    } 

    public void onMessage(Object message) throws Exception { 
     onMessage(message, getEntityType()); // getting compile time error here 
    } 

    public void onMessage(Object message, Class<T> clazz) throws Exception { 
     //here my original logic will go 
    } 
} 

Die getEntityType kann in Unterklassen außer Kraft gesetzt werden, in denen diese beiden Annahmen scheitern.