为什么这个转换器需要铸造

Question

我需要在java中实现enum到enum转换器的实现:Enum_2> Enum_1我想以通用方式实现它.

所以我定义了一个接口:

interface LabelAware<T extends Enum> {
    String getLabel();

    T getObject();
}

并且Enum_1:

enum Enum_1 {
    A, B;

    String getValue() {
        return "whatever";
    }
}

以及Enum_2实现LabelAware和需要转换为Enum_1:

enum Enum_2 implements LabelAware<Enum_1> {
    C("c", Enum_1.A), D("d", Enum_1.B);

    private final String label;
    private final Enum_1 object;

    Enum_2(String label, Enum_1 object) {
        this.label = label;
        this.object = object;
    }

    public String getLabel() {
        return label;
    }

    public Enum_1 getObject() {
        return object;
    }
}

最后,这是一个通用的转换器(List.ofAll()来自javaslang):

class Converter<S extends LabelAware, D extends Enum> {

    private S[] values;

    Converter(S[] values) {
        this.values = values;
    }

    D map(String label) {
        return (D) List.of(values)
                .find(v -> v.getLabel().equals(label))
                .map(LabelAware::getObject)
                .getOrElseThrow(() -> new RuntimeException(""));
    }
}

一个主要方法:

public class Main {        
   public static void main(String[] args) {
      System.out.println(new Converter<Enum_2, Enum_1>(Enum_2.values()).map("c").getValue());
   }
}

它编译并运行良好,但是我不知道为什么我需要将Converter.map方法的结果转换为D,因为我已经声明D要扩展Enum.可以在没有任何警告的情况下以通用方式完成吗？

Answer 1

您已经在多个地方使用了原始类型（不仅仅是 yshavit 在评论中指出的那个）。特别是，

class Converter<S extends LabelAware, D extends Enum> 

必须

class Converter<S extends LabelAware<D>, D extends Enum<D>>

以下内容应在没有警告的情况下进行编译：

import javaslang.collection.List;

interface LabelAware<T extends Enum<?>>
{
    String getLabel();

    T getObject();
}

enum Enum_1
{
    A, B;

    String getValue()
    {
        return "whatever";
    }
}

enum Enum_2 implements LabelAware<Enum_1>
{
        C("c", Enum_1.A), D("d", Enum_1.B);

    private final String label;
    private final Enum_1 object;

    Enum_2(String label, Enum_1 object)
    {
        this.label = label;
        this.object = object;
    }

    public String getLabel()
    {
        return label;
    }

    public Enum_1 getObject()
    {
        return object;
    }
}

class Converter<S extends LabelAware<D>, D extends Enum<D>>
{

    private S[] values;

    Converter(S[] values)
    {
        this.values = values;
    }

    D map(String label)
    {
        return List.of(values)
            .find(v -> v.getLabel().equals(label))
            .map(LabelAware::getObject)
            .getOrElseThrow(() -> new RuntimeException(""));
    }
}

（编辑：这只是告诉您如何务实地解决问题。请参阅davidxxx 的答案，了解有关那里出现问题的详细信息，并且不要忘记在那里留下 +1 :-)）

Answer 2

作为一般规则,应处理与泛型相关的所有警告以获得更安全的代码并避免警告链(可见警告是由依赖链的极远警告引起的).

但在你的情况下,你没有警告链问题,因为外部LabelAware安全.
LabelAware只有一个内部警告(在其实施)为Enum在extends Enum为原始声明.

这里,一个缺失的泛型声明解释了为什么cast in Converter.map()方法不安全:Converter类声明没有指定泛型for LabelAware.

您将Converter类声明为:

class Converter<S extends LabelAware, D extends Enum> {

其value字段类型S:

 private S[] values;

和它的map()方法如下:

 D map(String label) {
        return (D) List.of(values)
                .find(v -> v.getLabel().equals(label))
                .map(LabelAware::getObject)
                .getOrElseThrow(() -> new RuntimeException(""));
    }

在map()这里.find(v -> v.getLabel().equals(label)),您检索了一个S实例并且您声明了它S extends LabelAware.因此,最后,您检索LabelAware或扩展它的实例.

并LabelAware输入Enum通用:

interface LabelAware<T extends Enum> {
    String getLabel();    
    T getObject();
}

因此,在调用map()方法时.map(LabelAware::getObject),您将检索一个Enum类型.

并且Enum类型不一定是D类型,而反之亦然.

因此,如果你想避免中投(以及相关的警告)map(),你应该指明返回的泛型类型getObject()是一个实例D通过键入LabelAware与D通用:

class Converter<S extends LabelAware<D>, D extends Enum> {