5

我突然遇到了在 Java 中制作深度多态副本的问题。实现Clonable解决了我的问题，但它通常被称为“坏”技术。

因此，这是我寻找“不可克隆”解决方案的尝试：

public class Parent {
    int x;

    public Parent() {}

    public Parent(int x0) {
        x = x0;
    }

    public Parent copy() {
        Parent b = new Parent();
        b.assign(this);

        return b;
    }

    protected void assign(Parent c) {
        x = c.x;
    }

    @Override
    public String toString() {
        return getClass().getName() + ", " + x;
    }
}

public class Child extends Parent {
    int y;

    protected Child() {}

    public Child(int x0, int y0) {
        super(x0);
        y = y0;
    }

    @Override
    public Child copy() {
        Child b = new Child();
        b.assign(this);

        return b;
    }

    @Override
    protected void assign(Child c) {
        super.assign(c);
        y = c.y;
    }

    @Override
    public String toString() {
        return getClass().getName() + ", " + x + "," + y;
    }
}

public class Test {
    public static void main(String[] args) {
        Parent x = new Parent(5);
        Child y = new Child(10, 20);
        Parent z = x.copy();
        Parent w = y.copy();

        System.out.println(x);
        System.out.println(y);
        System.out.println(z);
        System.out.println(w);
    }
}

输出是：

com.xxx.zzz.Parent, 5
com.xxx.zzz.Child, 10,20
com.xxx.zzz.Parent, 5
com.xxx.zzz.Child, 10,20

还有另一种（更短的）方法（使用反射）：

public class Parent {
    int x;

    public Parent() {}

    public Parent(int x0) {
        x = x0;
    }

    public Parent copy() {
        try {
            Parent b = getClass().newInstance();
            b.assign(this);
            return b;
        } catch (InstantiationException | IllegalAccessException e) {
            e.printStackTrace();
            return null;
        }
    }

    protected void assign(Parent c) {
        x = c.x;
    }

    @Override
    public String toString() {
        return getClass().getName() + ", " + x;
    }
}

public class Child extends Parent {
    int y;

    protected Child() {}

    public Child(int x0, int y0) {
        super(x0);
        y = y0;
    }

    protected void assign(Child c) {
        super.assign(c);
        y = c.y;
    }

    @Override
    public String toString() {
        return getClass().getName() + ", " + x + "," + y;
    }
}

无需在 Child 类中覆盖 copy()。但我不确定使用 getClass().newInstance() 构造一个副本占位符有多“合法”......

上面的解决方案值得使用还是有更常见/强大/简单的方法？

谢谢 ！

4

3 回答 3

2

对于这个特定的用例，您的解决方案对我来说看起来不错。

使用 , 的主要限制newInstance()是：

  • 它仅适用于具有无参数构造函数的对象，并且
  • 它将无法克隆具有最终字段的对象

有一些库支持克隆。看看克里奥。它是一个序列化库，还支持克隆（深和浅），包括没有无参数构造函数或具有最终字段的对象。

于 2012-11-16T00:21:31.110 回答
0

我从来都不是“clone()”方法的忠实粉丝。复制构造函数似乎更优雅 IMO：

public class Parent {
    int x;

    public Parent() {
        super();
    }

    public Parent(Parent other) {
        super();
        this.x = other.x;
    }
}

public class Child extends Parent {
    int y;

    public Child() {
        super();
    }

    public Child(Child other) {
        super(other);
        this.y = other.y;
    }
}

请注意，如果您需要，这还具有额外的好处：

Parent p = new Parent(new Child(...));

您当然可以通过检查参数的具体类类型来防止构造函数中的这种行为，但我不明白为什么在大多数情况下需要这样做。

于 2012-11-16T02:50:20.303 回答
0

作为使用复制构造函数或可克隆的替代方法，您可以使用序列化来执行复制。

http://www.javaworld.com/javaworld/javatips/jw-javatip76.html?page=2

于 2012-11-16T00:20:28.640 回答