如何避免在java中使用泛型进行转换[复制]

Question

这个问题在这里已有答案：

• What is a raw type and why shouldn't we use it? 15个答案

我有这种情况

abstract class Notification<C extends Config> {
    private String text;
    private String title;
    private String topic;
    private C configuration;

    public C getConfig() {
        return configuration;
    }

    public void setConfig(C configuration) {
        this.configuration = configuration;
    }

    public String getText() {return text;}
    public void setText(String text) {this.text = text;}

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getTopic() {
        return topic;
    }

    public void setTopic(String topic) {
        this.topic = topic;
    }
}

class NotificationA extends Notification<ConfigA> {
    private Boolean notificationAccepted;

    public Boolean getNotificationAccepted() { 
        return notificationAccepted;
    }

    public void setNotificationAccepted(Boolean notificationAccepted) {
        this.notificationAccepted = notificationAccepted;
    }
}

class NotificationB extends Notification<ConfigB> {
    private LocalDate expirationDate;

    public LocalDate getExpirationDate() { 
        return expirationDate;
    }

    public void setExpirationDate(LocalDate expirationDate) {
        this.expirationDate = expirationDate;
    }
}

class NotificationC extends Notification<ConfigC> {
    private Boolean resend;

    public boolean resend() {return this.resend;}
    public void setResend(Boolean resend) {
        this.resend = resend;
    } 

    public LocalDate getExpirationDate() { 
        return expirationDate;
    }

    public void setExpirationDate(LocalDate expirationDate) {
        this.expirationDate = expirationDate;
    }
}

但这导致了我的问题，因为我必须根据我的配置创建通知，如下所示：

public Notification createNotification(Configuration configuration) {
    if(configuration instanceof ConfigurationA) {
        return new NotificationA();
    } else if (configuration instanceof ConfigurationB) {
        //...
    }
}

但是如果我尝试这样做：

Notification notification = createNotification(configuration);
notification.setConfig(configuration); //Unchecked call to setConfig()!

正如你所看到的，这里的一切都很糟糕，因为我必须再次施放Notification，因此编译器不会抱怨该未经检查的调用。

任何人都可以提供更好的解决方案？我觉得我无法解决这个糟糕的设计。

如果继承在这里不是一个好主意，那么我应该不重复代码？

如果这还不够明确，请告诉我在评论中要修复的内容。这是我关于SO的第一篇文章。

Answer 1

给Configuration一个createNotification<ConfigX>()方法而不是开关。

或者给Notification一个带有配置的构造函数而不是设置它。

或者每个Notification子类中的静态工厂方法。

Answer 2

您可以简单地制作createNotification()通用，如下所示：

public <T> Notification<T> createNotification(T config) {
    // ...
}

然后让它返回正确的Notification泛型类型。