通用类型 - 访问超类中的当前类

Question

我有两节课。我的第一个叫做“Manager”，依赖于我的第二个类“ManageAble”。这种依赖是通过一个泛型类型实现的，它是一个类参数，您可以在 Manager 的代码中看到：

public class ManageAble {

 private int id;
 private Manager<?> manager;

 protected ManageAble() {
 }

 @SuppressWarnings("unused")
 // used by reflection
 private final <T extends ManageAble> void construct(Manager<T> pManager,
        final Integer pID) {
    manager = pManager;
    id = pID;
 }

 @SuppressWarnings("unused")
 // used by reflection
 private final void deconstruct() {
    manager = null;
    id = -1;
 }

 protected boolean isAttatched() {
    return manager != null;
 }

 public final <T extends ManageAble> Manager<T> getManager() {
    if (manager != null) {
        try {
            @SuppressWarnings("unchecked")
            Manager<T> castedManager = (Manager<T>) manager;
            return castedManager;
        } catch (ClassCastException pCce) {
            // returns null
        }
    }
    return null;
 }

 public final int getID() {
    return id;
 }

 @Override
 public String toString() {
    return "[" + id + "] - " + manager;
 }
}

“Manager”类的“register”方法将在“ManageAble”类的构造函数中调用。但为此我需要弄清楚，如果我当前的对象是一个类的实例，它可以用作方法“register”中的参数“pType”。这是“ManagerAble”的代码：

public class Manager<Type extends ManageAble> {

 private final Map<Integer, Type> managed = new HashMap<Integer, Type>();
 private final Method construct = getManageAbleMethod("construct",
        new Class[] { Manager.class, Integer.class });
 private final Method deconstruct = getManageAbleMethod("deconstruct", null);

 public final boolean isManaging(final ManageAble pEntity) {
    if (pEntity != null) {
        return pEntity.equals(managed.get(pEntity.getID()));
    }
    return false;
 }

 public final boolean detatch(final ManageAble pEntity) {
    if (isManaging(pEntity)) {
        managed.remove(pEntity.getID());
        try {
            Object[] param = null;
            deconstruct.invoke(pEntity, param);
        } catch (IllegalAccessException | IllegalArgumentException
                | InvocationTargetException e) {
            // won't happen
        }
        return true;
    }
    return false;
 }

 public final synchronized boolean attatch(final Type pEntity) {
    if (pEntity != null)
        if (!isManaging(pEntity) && !pEntity.isAttatched()) {
            int id = getFreeID();
            managed.put(id, pEntity);
            try {
                construct.invoke(pEntity, new Object[] { this, id });
            } catch (IllegalAccessException | IllegalArgumentException
                    | InvocationTargetException e) {
                // won't happen
            }
            return true;
        }
    return false;
 }

 private final int getFreeID() {
    int id = 0;
    Set<Integer> idsInUse = managed.keySet();
    while (idsInUse.contains(id))
        id++;
    return id;
 }

 private final Method getManageAbleMethod(final String pMethodName,
        final Class<?>[] pParam) {
    try {
        Method m = ManageAble.class.getDeclaredMethod(pMethodName, pParam);
        m.setAccessible(true);
        return m;
    } catch (NoSuchMethodException | SecurityException e) {
        return null;
    }
 }
}

如您所见，在我插入注释而不是泛型类型参数的地方，我不知道如何强制参数成为定义构造函数的类。

有什么方法可以访问当前类在其超类中的泛型类型？

感谢您的帮助:)

编辑：我将代码更新为到目前为止的内容。我通过丑陋的尝试/捕捉和反思或多或少地解决了我的问题......有更好的想法吗？

Answer 1

我认为为了满足您的要求，您的 ManageAble 类也应该是泛型的。像

public class ManageAble<T>  {

    private final int id;

    protected ManageAble(Manager<? super T> pManager) {
        id = pManager.register((T) this);
    }

    public final int getID() {
        return id;
    }

    @Override
    public String toString() {
        return "[" + id + "]";
    }

}

当然，Manager 会变成：

public class Manager<Type extends ManageAble<Type>> {
...

然后你可以像这样使用它：

class Foo extends ManageAble<Foo> {

    public Foo(Manager<? super Foo> pManager) {
        super(pManager);
    }
}    

和

Manager<Foo> mg = new Manager<>();
Foo f = new Foo(mg);