如何动态转换/确保具有不同泛型的集合的类型安全

Question

我决定在我的设计中使用泛型，效果很好。只有当我达到抽象时，我才陷入困境。我正在收集使用不同泛型实现相同接口的不同实例。据我所知，为了将它们保存在列表中，我需要使用通配符。所以我当前的代码是这样的：

import java.util.List;
import java.util.ArrayList;


public class Main {
    private List<IView<?>> views = new ArrayList<IView<?>>();


    public void addView(IView<?> view)
    {
        this.views.add(view);
    }

    public void handle()
    {
        for (IView<?> view : this.views)
        {       
            // ## ERROR ##
            view.render(
                    view.cast(new Object())
                );
        }
    }
}

public interface IView<T> { 
    public T cast(Object entity);
    public void render(T entity);
}

public class FirstView implements IView<One> {  
    // .. Added to Main-collection views
}

public class SecondView implements IView<Two> { 
    // .. Added to Main-collection views
}

我还尝试了另一种方法，从 IView 返回一个类，然后用它来调用 class.cast。同样的问题。

编译器不接受这一点 - IView(Capture#2-of ?) 类型中的 Render(Capture#2-of ?) 方法不适用于参数 (Capture#3-of ?)。

我部分地想理解这个问题，但我看不出有什么办法解决它。如果有人能帮助我重新开始，我将非常感激。

Answer 1

我不相信您可以为 ? “类型化”变量赋值。一个无限的“？”意味着“变量的原始类型未知”，这意味着没有已知类型可以安全地分配给它。这并不意味着在运行时检索类型参数的实际值。

使用泛型方法进行强制转换的整个想法在 Java 泛型中没有意义。以类型安全的方式对未知类型对象进行强制转换的唯一方法是使用实​​际强制转换。

唯一的解决方案是摆脱cast()方法，并使用原始类型：

public void handle()
{
    for (IView view : this.views)
    {
        view.render(new Object());
    }
}

假设cast()方法只进行强制转换，而不进行类型转换。如果最终调用的实现方法是 FirstView.render(One object)，我相信 Java 实际上会将参数强制转换为 One。 （这也可能导致有趣的错误，即在没有强制转换的代码行上抛出 ClassCastException。）

如果 cast() 可以进行类型转换（在这种情况下，“cast”是一个坏名字对于操作），这意味着每个 IView必须能够接受对象，在这种情况下，将 render() 的参数设置为没有多大意义首先是泛型类型。我将使用的设计如下：

interface IView<T> {
    void renderObject(Object o);
    void render(T);
    T coerce(Object o);
}

abstract class ViewBase<T> implements IView<T> {
    void renderObject(Object o) {
        render(coerce(o));
    }
}

class FirstView extends ViewBase<One> {
    // …
}

封装“cast”操作。

没有静态类型安全的方法来处理不同类型的对象集合 - 在 Java 中，IView 和 IView 的类型与 一样不同>String 和 Integer 并且两者之间不存在安全转换。

Answer 2

由于我想知道代码 view.render(view.cast(new Object()); 中的两个捕获，
我阅读了Angelika Langer 的泛型常见问题解答中的相应部分。它指出：

我们不能通过无界通配符参数化来调用方法
接受“未知”类型参数的类型。

时期。

因此，使用通配符声明可以防止使用参数化参数，即使类型推断很简单，就像您的情况一样:( 因此 view.cast(new Object(); 是允许的，但 view .render(view.cast(new Object()); 不是。

---

为了通过示例进行说明，Angelika 给出了以下内容：

Box<?> box = new Box<String>("abc");

box.contains("abc");    // error 

其中 contains 将 Box 的参数化类型作为参数她说：

如果通过引用变量执行该调用是非法的
输入 Box 。 [将 contains 方法定义为采用以下参数
输入 Object 而不是 T 可以避免这种效果。在这种情况下
contains 方法不会采用“未知”的对象，而是采用
“任何”类型的对象，并且允许通过
Box 类型的引用变量 .]

因此，她建议返回到 Object （类似于我其他答案中的建议）。顺便说一句，她不鼓励使用原始类型，正如 Josh Bloch 在 Effective Java's 项目中所做的那样23、“不要在新代码中使用原始类型”。

Answer 3

我不明白编译器错误，即为什么 view.render(view.cast(new Object()); 生成两个捕获。（我已经用 view 是最终的，并且显示相同的错误消息）。

但是由于 IView 和 IView 仅将 Object 作为通用类型。 ，解决的方法是使用列表>。

Answer 4

我通过返回一个类型化的对象来替换了转换（并且我通过用 IEntity 替换新的 Object 稍微改变了示例）；

public class Main {
    public static List<IView<? extends IEntity<?>>> views = new ArrayList<IView<? extends IEntity<?>>>();

    public static <T extends IEntity<T>> void register(IView<T> view)
    {
        Main.views.add(view);
    }


    public static void handle()
    {
        for (IView<? extends IEntity<?>> view : Main.views)
        {
        // ## Error ##
        /* Bound mismatch: The generic method view(IView<T>) of the type Main 
         * is not applicable for the arguments (IView<capture#1-of ? extends IEntity<?>>). 
         * The inferred type capture#1-of ? extends IEntity<?> is not a valid 
         * substitute for the bounded parameter <T extends IEntity<T>> 
         */             
            Main.view(view);
        }
    }

    public static <T extends IEntity<T>> void view(IView<T> view)
    {
        IKey<T> key = view.getKey(/* Some arg */);
        T entity = key.getEntity();

        view.render(entity);
    }

}

public interface IView<T> {
    public IKey<T> getKey(/* Some args */);
    public void render(T entity);
}

public interface IKey<T> {
    public T getEntity();
}

通配符在某种程度上是有界的，但它会产生另一个问题（实际上可能是相同的）：有没有办法检查两个通配符是否匹配，即：

for (IView<? extends IEntity<?>> view : Main.views)

Where？只能是一种（=相同）（通用）类型？