Java 使用不同的泛型类型重写方法

我有以下课程：

public class A extends Exception {
}

public class B extends Email {

}

我的目标是实施一些能够与这两个类一起工作的策略，如下所示：

例如：

public enum Strategy {
    ACTION_1 {

        @Override
        public void handleAction(Class<? extends Exception > parameterThatShouldAcceptOnlyA) {
            throw parameterThatShouldAcceptOnlyA;
        }
    },
    ACTION_2 {

        @Override
        public void handleAction(Class<? extends Email > parameterThatShouldAcceptOnlyB) {
            parameterThatShouldAcceptOnlyB.send();
        }
    };

    public abstract void handleAction(Class<?> parameterThatShouldAcceptBoth);
}

公共枚举策略{
行动1{
@凌驾
public void handleAction（应同时接受这两个参数的类参数）；
}

这不是通过重写方法中不正确的泛型来编译的

---

你能建议一下如何使这可行吗？

你最好退后一步。你的想法完全违反了法律

基本上，您希望限制可以作为参数传递给方法的子类

这打破了子类可以用来代替超类的想法。因为现在，突然之间，想要调用该方法的代码必须检查它调用的对象的类型，以确保不使用“无效”参数调用该方法

---

换言之：将此编译器错误视为一种症状。即使您以某种方式解决了特定问题；正如所说，您最好后退一步，重新思考您的整个想法。

您最好后退一步。您的想法完全违反了标准

基本上，您希望限制可以作为参数传递给方法的子类

这打破了子类可以用来代替超类的想法。因为现在，突然之间，想要调用该方法的代码必须检查它调用的对象的类型，以确保不使用“无效”参数调用该方法

换句话说：将此编译器错误视为一种症状。即使您以某种方式解决了特定问题；如前所述，您最好退后一步，重新思考您的整个想法。

提示：抛出

类

实例或调用Class

类

提供的方法之外的其他方法都是不可能的，因此首先您需要更改ur参数类型。这也允许您删除通配符

您可以通过泛型定义超类。不幸的是，枚举不支持泛型。但是您可以创建一个泛型接口，如

interface Handler<T> {
    void handleAction(T t);
}

接口处理程序{
孔隙淋滤（T）；
}

并像这样实现您的处理程序

class EmailHandler implements Handler<Email> {
    void handleAction(Email email) {
        email.send();
    }

class ExceptionHandler implements Handler<Exception> {
    void handleAction(Exception e) {
        // Exception is a checked exception
        // so we cannot throw it without 'throws' declaration
        // but we cannt add 'throws Exception'
        if (e instanceof RuntimeException)
            throw (RuntimeException) e;
        else
            throw new RuntimeException("wrapped", e);
    }

类EmailHandler实现处理程序{
作废处理（电子邮件）{
email.send（）；
}
类ExceptionHandler实现处理程序{
无效手动过滤（例外e）{
//异常是已检查的异常
//所以我们不能在没有“抛出”声明的情况下抛出它
//但我们不能添加“抛出异常”
if（运行时异常的实例）
抛出（运行时异常）e；
其他的
抛出新的RuntimeException（“wrapped”，e）；
}

提示：既不能抛出

类

实例，也不能调用类类提供的方法以外的其他方法，因此首先需要更改参数类型。这样还可以删除通配符

您可以通过泛型定义超类。不幸的是，枚举不支持泛型。但是您可以创建一个泛型接口，如

interface Handler<T> {
    void handleAction(T t);
}

接口处理程序{
孔隙淋滤（T）；
}

并像这样实现您的处理程序

class EmailHandler implements Handler<Email> {
    void handleAction(Email email) {
        email.send();
    }

class ExceptionHandler implements Handler<Exception> {
    void handleAction(Exception e) {
        // Exception is a checked exception
        // so we cannot throw it without 'throws' declaration
        // but we cannt add 'throws Exception'
        if (e instanceof RuntimeException)
            throw (RuntimeException) e;
        else
            throw new RuntimeException("wrapped", e);
    }

类EmailHandler实现处理程序{
作废处理（电子邮件）{
email.send（）；
}
类ExceptionHandler实现处理程序{
无效手动过滤（例外e）{
//异常是已检查的异常
//所以我们不能在没有“抛出”声明的情况下抛出它
//但我们不能添加“抛出异常”
if（运行时异常的实例）
抛出（运行时异常）e；
其他的
抛出新的RuntimeException（“wrapped”，e）；
}

您是否计划调用

ACTION\u 1.handleAction（…）

，或

某个DynamicStrategy.handleAction（…）

？显然，问题在于您使用的是

类

类型。此类型不表示类型为

T

的对象，而是表示与Java类相关联的元信息。另一个问题是，您试图泛化

枚举

，这是不可能的。请尝试定义

策略

接口。您打算这样做吗正在调用

操作\u 1.handleAction（…）

，或

某个DynamicStrategy.handleAction（…）

？显然，问题在于您使用的是

类

类型。此类型不表示类型为

T

的对象，而是表示与Java类相关联的元信息。另一个问题是，您试图泛化

枚举

，这是不可能的。请尝试定义

策略

接口。使用de>Class对象作为方法参数是没有用的，如果你需要在它上面调用

T

类型的方法；）OP的参数是

Class

，我不知道用它做了什么。但是你是对的：在大多数情况下都不需要。请更正你的答案并指定

类的使用是没有价值的。使用
类对象作为方法参数是没有用的，如果你需要在它上面调用
T
类型的方法；）OP的参数是
Class
，我不知道用它做了什么。但是你是对的：在大多数情况下都不需要。请更正你的答案，并指定使用
Class
是没有价值的。