Generic <T extends A> 类使用一个静态字段而不是 T 的一个

Question

这是我的情况

public abstract class Actions {

    public static Actions STAND;
    public static Actions ATTACK;
    public static Actions COLONIZE;
    public static Actions DEFEND;
    public static Actions TURN_CW;
    public static Actions TURN_CCW;
    public static Actions DIE;

    public abstract long[] getFramesDurations();
    public abstract int[] getBaseTiles();
}

public class SimpleActions extends Actions{

    public static Actions STAND = new SimpleActions( new long[]{120,120,120,120,120,120,120}, new int[]{0,1,2,3,4,5,6});
    public static Actions ATTACK = new SimpleActions( new long[]{120,120,120,120,120,120,120,120,120}, new int[]{7,8,9,10,11,12,13,14,15});
    public static Actions COLONIZE = new SimpleActions( new long[]{120,120,120,120,120,120,120}, new int[]{7,8,9,10,11,12,13,14,15});
    public static Actions DEFEND = new SimpleActions(new long[]{1}, new int[]{1});
    public static Actions TURN_CW = new SimpleActions( new long[]{1}, new int[]{1});
    public static Actions TURN_CCW = new SimpleActions( new long[]{1}, new int[]{1});
    public static Actions DIE = new SimpleActions( new long[]{1}, new int[]{1});

    private final long[] mActionFramesDurations;
    private final int[] mActionBaseTiles;

    SimpleActions(long[] pActionFramesDurations, int[] pActionBaseTiles) {
        mActionFramesDurations = pActionFramesDurations;
        mActionBaseTiles = pActionBaseTiles;
    }

    public long[] getFramesDurations()
    {
        return mActionFramesDurations;
    }

    public int[] getBaseTiles()
    {
        return mActionBaseTiles;
    }
}

public abstract class A<T extends Actions> {
    A() {
        doSomething(T.STAND);
    }

    protected void doSomething(Actions action) { use action somewhere}
}

public class B extends A<SimpleActions> {
    B() {
        super();
    }
}

当 A 的构造函数调用 doSomething 时，我总是得到 nullPointerException，因为 action 为 null..

由于 B 扩展了 A，我希望它使用 SimpleActions.STAND，而不是 Actions.STAND。

我做错了什么？我该怎么做？

Answer 1

泛型的类型参数在运行时是未知的。换句话说，在运行时，A<Actions> 和A<SimpleActions> 之间没有区别。因此，jvm 无法判断您想要SimpleActions.STAND，而不是Actions.STAND。如果您需要在运行时知道类型参数，则需要将它们放在一个单独的变量中。

如果不清楚，请阅读“运行时类型擦除”。

根据您的评论进行了编辑 - 如果您只在构造函数中执行此逻辑，则可以使构造函数看起来像

A( Class<? extends Action> actionType ){
    if( SimpleActions.class.isAssignableFrom( actionType )){
        doSomething( SimpleActions.STAND );
    }
    else{
        doSomething( Actions.STAND );
    }
}

如果在构造函数之外需要相同的逻辑，则在A 内创建一个Class<? extends Action> 类型的成员变量来存储actionType。

Answer 2

Java 语言规范writes：

具有绑定 T & I1 ... In 的类型变量 X 的成员是交集类型 (§4.9) T & I1 ... In 的成员，出现在声明类型变量的位置。

这就是为什么表达式 T.STAND 指的是 Actions.STAND，而不是 SimpleActions.STAND。

Actions.STAND 和 SimpleActions.STAND 是不同的字段（与非静态方法不同，字段不能被覆盖。）

这已经强调了一种委托给子类的方法：定义一个子类必须覆盖的访问器方法（getter）：

abstract class Actions {
    abstract Actions stand();
}

class SimpleActions extends Actions {
    private static final Actions STAND = ...;

    @Override Actions stand() { return STAND;}
}

并调用

t.stand();

其中 t 是在构造时提供给A 的 T 实例。或者也许将此方法移动到不同的类型 (MotionRegistry?) 并在构造 A 时提供该方法的实例。

也就是说，您的设计看起来相当复杂，我无法摆脱您的代码可以简化的感觉（如果都描述相同的动作，您需要区分 Actions 和 SimpleActions 吗？）