Question

我有以下界面：

public interface Result<T extends Serializable> extends Serializable{
    T getResult();
}

使用该界面，我无法定义类型

的变量

Result<List<Integer>>

因为List不可序列化。

但是，如果我将界面更改为：

public interface Result<T> extends Serializable{
    T getResult();
}

现在变得不可能通过编译时间检查来实现，因为不能保证T是可序列化的，并且类的整个点是存储结果以便我可以稍后将其取回，可能在传输之后通过互联网。

我的问题是，有没有办法声明一个变量，以便它有两种类型，或者是否有其他方法可以做到这一点，我没有看到？所以，可能是这样的：

(List<Integer> extends Serializable) value = new ArrayList();

我试图将此问题的重担放在实现上，以便此接口的未来消费者不会意识到这个问题。

感谢您的帮助！

以下是我要做的更详细的示例：我正在调用一个服务器，我希望将结果存储在结果对象中，但我不想处理强制转换。因此，可以在服务器上调用的每个方法都将使用泛型定义结果的类型。此结果对象还将存储有关结果的其他元数据，例如，可能返回的信息太多。在许多情况下，我想使用列表，但List接口不可序列化，尽管许多实现都是。

那么，如何指定所使用的类型必须是Serializable，但是仍然允许使用List（而不是List的特定实现）？

Answer 1

您需要将变量类型声明为Result<? extends List<Integer>>。

类型检查知道List不是serializable，但List的子类型可以是serializable。

以下是一些示例代码。接口实现只是使用匿名内部类完成的。您可以看到getResult将在第二个对象上返回List<Integer>

   Result<Integer> res = new Result<Integer>() {

        Integer myInteger;

        private static final long serialVersionUID = 1L;

        @Override
        public Integer getResult() {
            return myInteger;
        }

        @Override
        public void addResult(Integer input) {
            this.myInteger = input;
        }
    };

    Integer check = res.getResult();


    Result<? extends List<Integer>> res2 = new Result<ArrayList<Integer>>() {

        ArrayList<Integer> myList;

        private static final long serialVersionUID = 1L;

        @Override
        public ArrayList<Integer> getResult() {
            return myList;
        }

        @Override 
        public void addResult(ArrayList<Integer> input) {
            this.myList = input;
        }

    };

    List<Integer> check2 = res2.getResult();

编辑：通过实施void addResult(T input)接口方法

使示例更加完整

Answer 2

虽然List接口没有实现Serializable，但所有内置的Collection实现都可以。这在集合Implementations tutorial中进行了讨论。

收藏集设计常见问题解答有一个问题"Why doesn't Collection extend Cloneable and Serializable?"，它解释了为什么Sun设计它而不扩展Serializable。

Answer 3

您可以简单地将变量声明为Result<ArrayList<Integer>>。只要你仍然编程到List界面，你就没有真正牺牲可替换性。

我还建议创建一个新界面ListResult：

public interface ListResult<T extends Serializable & List<E extends Serializable>>
        implements Result<T> {
    T getResult();
}

但是你仍然需要将变量声明为ListResult<ArrayList<Integer>>。所以我会选择更简单的路线。

Answer 4

如果你打算一般使用结果类型列表，你想要的是确保列表中的元素是可序列化的，你可以这样定义：

public interface Result<T extends List<? extends Serializable>> {}

这样，您可以定义类似的内容：

Result<List<Integer>> r;

但这样的事情无法编译：

Result<List<List>> r;

现在，如果要将结果用于Integer和List，那么类型不需要可序列化，对吧？在那种情况下，我真的不明白你的目标是什么。

Answer 5

我认为你可以：

public class Thing<T extends Serializable> implements Serializable {
    private static class Holder<V extends Serializable> {
        private final V value;
        private Holder(V value) {
            this.value = value;
        }
    }
    private Holder<? extends List<T>> holder;
    private <V extends List<T> & Serializable> void set(V value) {
        holder = new Holder<V>(value);
    }
}

这看起来难看吗？

我是否可以建议您不要尝试使用Java静态类型系统强制实施Serializable？它只是一个界面，因为注释不是当时的。执行它是不切实际的。 OTOH，你可以使用在封闭系统中进行静态分析的类型检查器来强制执行它。

Answer 6

我最终解决这个问题的方法是使用它作为界面：

public interface Result<T> extends Serializable{
    T getResult();
}

然后为每个不同类型的集合创建一个实现，并为任何对象创建一个实现。

所以，例如，这里是ListResult类的样子：

public class ListResult<T> implements Result<List<T>>{
    public List<T> getResult(){
        //return result
    }

    public <V extends List<T> & Serializable> void setResult(V result){
        //store result
    }
}

Answer 7

最初的想法。如果您计划对任何类型的长期数据存储使用序列化，请不要这样做。无法保证序列化在JVM的调用之间起作用。

除非您要添加与对象序列化相关的功能，否则您可能不应该扩展Serializable。相反，实现Result的类也应该实现Serializable。

如何泛化指定可序列化列表

7 个答案: