除了用 Java 实现 Clone 之外，还有其他选择吗？

Question

在我的 Java 项目中，我有一个由各种类型的交易者组成的向量。 这些不同类型的交易者是 Trader 类的子类。 现在，我有一个方法，它将 Trader 作为参数并将其存储在向量中 50 次左右。 我遇到了问题，因为存储同一个对象 50 次只是存储同一个对象的 50 个引用。 我需要存储该对象的 50 个副本。 我研究过如何实现 Clone，但我不希望程序员定义一种必须担心其类可克隆的交易者类型。 另外，正如 此页面 所指出的，实现克隆会创建各种类型的问题。 我认为复制构造函数也不起作用，因为如果我在 Trader 类中定义一个复制构造函数，它就不会知道它正在复制的 Trader 的类型，而只是创建一个通用的 Trader。 我能做些什么？

编辑：我并不是真的想制作某个对象的精确副本。 我真正想做的是将一定数量的交易者添加到向量中。 问题是用户需要在参数中指定他想要添加哪种类型的交易者。 这是我想做的一个例子：（虽然我的语法完全是虚构的）

public void addTraders(*traderType*)
{
    tradervect.add(new *traderType*())
}

我怎样才能在Java中实现这样的事情？

Answer 1

只需添加一个抽象复制方法即可。 您可以使用协变返回类型，以便指定派生类型返回派生实例，这可能很重要，也可能不重要。

public interface Trader {
    Trader copyTrader();
    ...
}


public final class MyTrader implements Trader {
    MyTrader copyTrader() {
        return new MyTrader(this);
    }
    ...
}

有时您可能想要一般性地处理 Trader 的派生类型集合，需要克隆然后返回正确类型的集合。 为此，您可以以惯用的方式使用泛型：

public interface Trader<THIS extends Trader> {
    THIS copyTrader();
    ...
}


public final class MyTrader implements Trader<MyTrader> {
    public MyTrader copyTrader() {
        return new MyTrader(this);
    }
    ...
}

Answer 2

我有点不清楚为什么你想要存储同一个对象的 50 个左右的克隆，除非它们是原始交易者作为后来交易者的原型（参见模式）。

如果你想制作一个对象的精确副本，你就必须考虑到多态性的问题。 如果允许对给定类进行子类化的人添加状态成员，那么您已经对 equals 和compareTo 之类的函数感到非常头痛，该克隆只是您需要特殊处理的另一种情况。

我不同意克隆总是邪恶的，有时这是必要的。 然而，在子类化的情况下，很多事情变得很棘手。

我建议您（当有机会时）阅读 Bloch 的“Effective Java”，其中涵盖了他的很多主题。 布拉查的观点是，让其他人扩展你的课程并不是一个好主意，如果你这样做，你需要很好地记录他们必须做什么，并希望他们遵循你的指示。 确实没有办法绕过它。 您可能还想让您的交易者不可变。

正常地继续实现克隆，并在类头中非常清楚地表明任何从您的 Trader 继承并添加状态成员的人都必须实现 X 方法（指定哪个方法）。

寻找绕过实际 Cloneable 和 Clone 的技巧并不能解决继承问题。 这里没有灵丹妙药。

Answer 3

Uri 是对的，状态多态性带来了一大堆蠕虫。

我认为子类化 Cloneable 并重写 clone() 可能是最简单的方法。 我相信，您可以使返回类型协变。

Answer 4

一种选择：如果可以使对象可序列化，则可以序列化然后反序列化它以创建副本，类似于通过 RMI 传递对象时发生的情况。

快速复制方法：

public MyObject copy() {
    ObjectOutputStream oos = null;
    ObjectInputStream ois = null;
    try {
        ByteArrayOutputStream bos =  new ByteArrayOutputStream();
        oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        oos.flush();
        ByteArrayInputStream bin =
            new ByteArrayInputStream(bos.toByteArray());
        ois = new ObjectInputStream(bin);
        return (MyObject)ois.readObject();
    } catch(Exception e) {
        return null;
    } finally {
        try {
            oos.close();
            ois.close();
        } catch (Exception e) {
            return null;
        }
    }
}

Answer 5

一种方法是使其成为像 Java 自己的 String 一样的最终类，这将对 Trader 类的对象进行任何更改以在内存中创建新副本，但这将使其无法子类化。

另一种（更好的）方法是使用工厂方法来创建和复制 Trader 对象扩展，这意味着您不得允许使用默认构造函数，即使其成为私有构造函数。 通过这种方式，您可以控制类拥有的实例数量。
请参阅 http://en.wikipedia.org/wiki/Factory_method

public class Trader {

    /* prevent constructor so new cant be used outside the factory method */
    private Trader() {
    }

    /* the factory method */
    public static Trader createTrader(int whatKindOfTrader) {

        switch (whatKindOfTrader) {
        case 0:
            return new Trader1(); // extends Trader
        case 1:
        default:
            return new Trader2(); // extends Trader
        }
        return new Trader3(); // or throw exception
    }
}

您甚至可以指定另一个重载方法，或第二个参数，它采用一个交易者并将其复制到一个新的交易者中，从而取代克隆。
顺便说一句，您可能想要重写clone()方法并抛出CloneNotSupportedException，以防止默认的对象克隆。