"<T扩展SuperClass>“的正确用法

Question

我不熟悉“泛型”。这是"<T extends SuperClass>“的正确用法吗？您是否同意使用泛型后的代码更好？

Before using Generics
=================================================

public abstract class SuperSample {

    public void getSomething(boolean isProcessA) {
        doProcessX();
        if(isProcessA){
            doProcessY(new SubASample());
        }else{
            doProcessY(new SubBSample());
        }
    }

    protected abstract void doProcessX();

    protected void doProcessY(SubASample subASample) {
        // Nothing to do
    }

    protected void doProcessY(SubBSample subBSample) {
        // Nothing to do
    }

}

public class SubASample extends SuperSample {

    @Override
    protected void doProcessX() {
        System.out.println("doProcessX in SubASample");
    }

    @Override
    protected void doProcessY(SubASample subASample) {
        System.out.println("doProcessY in SubASample");
    }

}

public class Sample {

    public static void main(String[] args) {
        SubASample subASample = new SubASample();
        subASample.getSomething(true);
    }

}

After using Generics
=================================================

public abstract class SuperSample {

    public void getSomething(boolean isProcessA) {
        doProcessX();
        if(isProcessA){
            doProcessY(new SubASample());
        }else{
            doProcessY(new SubBSample());
        }
    }

    protected abstract void doProcessX();

    protected abstract <T extends SuperSample> void doProcessY(T subSample);

}

public class SubASample extends SuperSample {

    @Override
    protected void doProcessX() {
        System.out.println("doProcessX in SubASample");
    }

    @Override
    protected <T extends SuperSample> void doProcessY(T subSample) {
        System.out.println("doProcessY in SubASample");
    }

}

public class Sample {

    public static void main(String[] args) {
        SubASample subASample = new SubASample();
        subASample.getSomething(true);
    }

}

Answer 1

如果你想做我认为你想做的事情，我不认为这是正确的方式(*)。如果你希望每个子类都需要实现一个方法来处理它自己的类型，那么你可以使用CRTP技巧：

abstract class Super<S extends Super<S>> {
   abstract void process(S s);
}

class SubA extends Super<SubA> {
   void process(SubA s){ /* do something */ }
}

class SubB extends Super<SubB> {
   void process(SubB s){ /* do something */ }
}

请注意，此模式强制执行子类的泛型签名，例如class SubA extends Super<SubB>不会编译。

顺便说一句，Java本身在java.lang.Enum中使用了这种技巧。

(*)如果这不是您想要强制执行的行为，请澄清。

Answer 2

使用它是正确的。这意味着您将类型T限制为SuperSample的子类。对于第二个答案，是的，我认为使用generecis的代码更好，因为它可以防止您错误地转换类，例如使用容器(List ...)。但实际上，Java中的泛型只是语法糖，所以它们在运行时就会被删除。