对象被克隆，但静态引用仍然存在？

Question

我正在学习对象深度克隆，我有一个带有 getInstance 方法的员工类，它返回一个单例，我正在克隆返回的对象。下面是类和测试类。

public class Employee  implements Serializable , Cloneable {

    public static Employee employee;

    private String name;

    private int age;


    private Employee(){


    }


    public Employee(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }

    protected Object clone() throws CloneNotSupportedException {

        return super.clone();

        }


    public static Employee getInstance(){

        if(employee == null ){
            employee = new Employee();
            return employee;
        }


        return employee;
    }


    public String getName() {
        return name;
    }


    public void setName(String name) {
        this.name = name;
    }


    public int getAge() {
        return age;
    }


    public void setAge(int age) {
        this.age = age;
    }



}

对象深拷贝测试类

public class CopyTest {

    /**
     * @param args
     */
    public static void main(String[] args) {



        try {

            Employee original = Employee.getInstance();

            original.setName("John");
            original.setAge(25);

            Employee cloned = (Employee)copy(original);

            System.out.println("Original -->"+Employee.getInstance().getName());

            cloned.getInstance().setName("Mark");

            System.out.println("Cloned -->"+cloned.getInstance().getName());

            System.out.println("Original -->"+Employee.getInstance().getName());

        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }


    public static Object copy(Object orig) {
        Object obj = null;
        try {
            // Write the object out to a byte array
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream out = new ObjectOutputStream(bos);
            out.writeObject(orig);
            out.flush();
            out.close();

            // Make an input stream from the byte array and read
            // a copy of the object back in.
            ObjectInputStream in = new ObjectInputStream(
                new ByteArrayInputStream(bos.toByteArray()));
            obj = in.readObject();
        }
        catch(IOException e) {
            e.printStackTrace();
        }
        catch(ClassNotFoundException cnfe) {
            cnfe.printStackTrace();
        }
        return obj;
    }
}

输出

Original -->John
Cloned -->Mark
Original -->Mark

问题

尽管我克隆了原始对象以创建它的副本，

Employee cloned = (Employee)copy(original);

我通过调用修改克隆对象的属性

cloned.getInstance().setName("Mark");

正如您从控制台输出中看到的那样，它正在反射到原始对象。 我认为这是因为静态调用？ ，以及如何克服这个问题？我是否违反了我需要通过 getInstance 方法创建对象的单个实例的原则，然后我决定稍后制作该对象的副本。

Answer 1

JAVA Doc 教程页面是这样说的：

在声明中带有 static 修饰符的字段被称为 静态字段或类变量。它们与类相关联， 而不是与任何物体。类的每个实例共享一个 类变量，它位于内存中的一个固定位置。任何物体 可以改变类变量的值，但类变量也可以 在不创建类的实例的情况下进行操作。

克隆的对象cloned 只是该类的另一个对象。它不会更改它没有引用的另一个对象。您的调用cloned.getInstance() 正在返回所有对象都可以访问的静态对象employee，因为静态对象与Class 相关联，而不是与任何特定对象相关联。所以你打电话给cloned.getInstance().setName("Mark");就相当于Employee.employee.setName("Mark");

Answer 2

您正在为static 字段employee 的Employee 实例设置名称

cloned.getInstance().setName("Mark");
      ^ static method call that returns the employee reference

也打印出来

System.out.println("Cloned -->"+cloned.getInstance().getName());
                                      ^ static method call

您可能想要实际更改 cloned 实例

cloned.setName("Mark");
System.out.println("Cloned -->"+cloned.getName());

Answer 3

静态字段大致意味着它将被每个对象共享。无论您创建/克隆了多少对象，您的 getInstance() 调用都将返回相同的 Employee。

因此，只要您将其名称设置为 Mark，您将始终在控制台中获得 Mark。

例如：

Employee me = new Employee();
Employee.getInstance().setName("Mark");
System.out.println("me employee name? " + me.getInstance().getName());

如果您在控制台中看到“Mark”，请不要感到惊讶；）

有关实例和类（使用静态关键字）成员之间区别的更详细信息，请查看tutorial section

Answer 4

您将要序列化对象，然后反序列化它。在java中，反序列化保证创建一个新对象。 （与 Classloader 的工作方式有关）。

当您序列化对象时，它会对对象及其所有依赖项等进行深度复制。序列化可以通过多种方式使用，但一种方法是将对象转换为字节，以便可以将其发送过来线（网络），或存储在磁盘上以保持持久性。您可以使用该行为进行内存中的序列化/反序列化，并每次创建一个新对象，其内容（值）完全相同，但引用与原始对象不同。

这是我在某些应用程序中使用的一种方法：

/**
 * Clones an object creating a brand new
 * object by value of input object. Accomplishes this
 * by serializing the object, then deservializing it.
 * 
 * @param obj Input Object to clone
 * @return a new List<Product> type cloned from original.
 * @throws IOException If IOException
 * @throws ClassNotFoundException If ClassNotFoundException
 */
private static List<Product> cloneProdList(Object obj) throws IOException, ClassNotFoundException {

    java.io.ByteArrayOutputStream bos = new java.io.ByteArrayOutputStream();
    java.io.ObjectOutputStream obj_out = new java.io.ObjectOutputStream(bos);
    obj_out.writeObject(obj);

    java.io.ByteArrayInputStream bis = new java.io.ByteArrayInputStream(bos.toByteArray());
    java.io.ObjectInputStream obj_in = new java.io.ObjectInputStream(bis);

    @SuppressWarnings("unchecked")
    List<Product> newObj = (List<Product>)obj_in.readObject();

    bos.close();
    bis.close();
    obj_out.close();
    obj_in.close();

    return newObj;
}