Java “的正确用法”&书信电报；T扩展超类>&引用；

我不熟悉“泛型”。是否正确使用了“

”？你同意使用泛型后的代码更好吗

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

}

在使用泛型之前
=================================================
公共抽象类超样本{
public void getSomething（布尔值isProcessA）{
doProcessX（）；
if（isProcessA）{
doProcess（新的子样本（））；
}否则{
doProcess（新的SubBSample（））；
}
}
受保护的抽象void doProcessX（）；
受保护的无效数据处理（子采样子采样）{
//无事可做
}
受保护的无效数据处理（SubBSample SubBSample）{
//无事可做
}
}
公共类子样本扩展了超级样本{
@凌驾
受保护的void doProcessX（）{
System.out.println（“子样本中的doProcessX”）；
}
@凌驾
受保护的无效数据处理（子采样子采样）{
System.out.println（“子样本中的数据处理”）；
}
}
公共类样本{
公共静态void main（字符串[]args）{
SubASample SubASample=新SubASample（）；
subsample.getSomething（true）；
}
}
使用泛型之后
=================================================
公共抽象类超样本{
public void getSomething（布尔值isProcessA）{
doProcessX（）；
if（isProcessA）{
doProcess（新的子样本（））；
}否则{
doProcess（新的SubBSample（））；
}
}
受保护的抽象void doProcessX（）；
受保护的抽象空数据处理（T子样本）；
}
公共类子样本扩展了超级样本{
@凌驾
受保护的void doProcessX（）{
System.out.println（“子样本中的doProcessX”）；
}
@凌驾
受保护的无效数据处理（T子样本）{
System.out.println（“子样本中的数据处理”）；
}
}
公共类样本{
公共静态void main（字符串[]args）{
SubASample SubASample=新SubASample（）；
subsample.getSomething（true）；
}
}

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

抽象类Super{
抽象空洞过程；
}
类SubA扩展了Super{
无效进程（子进程）{/*做某事*/}
}
类SubB扩展了Super{
无效进程（SubB s）{/*做某事*/}
}

---

请注意，此模式强制子类的通用签名，例如，

类SubA extends Super

不会编译

顺便说一句，Java本身在

Java.lang.Enum

中使用了这种技巧

---

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

使用它是正确的。这意味着您将类型T限制为超级样本的子类。对于第二个答案，是的，我认为使用generecis的代码更好，因为它可以防止错误地转换类，例如使用容器（列表…）。但事实上，Java中的泛型只是语法提示，因此它们在运行时会被删除。

确切地说，如果我使用它，我必须在所有子类中实现该方法。。我会处理好各种情况。和CRTP技巧。。我从来不知道。谢谢，我会查出来。

class SubA extensed Super

编译，因为

class SubB extensed Super

“它可以防止类的错误转换，例如使用容器（列表…）。非常感谢，我开始知道什么时候应该使用泛型。

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 */ }
}