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

Question

我需要在 java 中实现一个枚举到枚举的转换器：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(""));
    }
}

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

Answer 2

作为一般规则，应处理所有与泛型相关的警告以获得更安全的代码并避免警告链（可见警告是由依赖链的非常远的警告引起的）。

但在你的情况下，你没有警告链问题，因为在外部，LabelAware 是安全的。
LabelAware 只有一个内部警告（在其实现中），因为 extends Enum 中的 Enum 是原始声明的。

这里，一个缺少的泛型声明解释了为什么 Converter.map() 方法中的强制转换不安全：Converter class 声明没有为 LabelAware 指定泛型.

您声明 Converter class 为：

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(LabelAware::getObject) 时的 map() 方法中，您检索了一个 Enum 类型。

而且 Enum 类型不一定是 D 类型，反之亦然。

因此，如果您想避免 map() 中的强制转换（和相关警告），您应该指定 getObject() 返回的泛型类型是 D 的实例通过输入 LabelAware 和 D generic :

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

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

Why this converter needs casting?

java

generics

enums

vavr