Java中很有用却很容易被忽略的方法-----clone

 在日常编程中，我们常常遇到这样的问题，我们需要一个已经初始化了所有信息的类的副本，通俗的说也就是要一个和类A一模一样的类B，而且两个类是彼此独立的。以前没学过C++且刚接触Java的人也许会这样做：(Person是我定义的一个类，稍候会给出它的源代码)

                     Person person1=new Person("kenny",23,new Date());
                     Person person2=person1;

    这种方法是最容易想到的，也是大多数Java新手最容易犯的错误，因为Java里没有指针这个概念，而Java很多地方却用到了C++里指针的性质，所以导致很多人对对象是如何在内存里创建的过程不了解。实际上，Java中new 一个对象的过程和C++本质上是一样的，都是在堆上开辟一块内存来存放对象，然后返回指向这块堆内存的地址(即指针)，把这个指针放到栈上，如：

                    Person  *pPerson1=new Person("kenny",23,new Date());   (C++)
                    Person    person1=new Person("kenny",23,new Date());      (Java)

     在C++中pPerson1是指针，而在Java中person1叫做引用，其实也就是指针。所以Person person2=person1，这行代码做的就是新建一个person2指针(Java中叫引用)，然后把person1的地址赋给person2,这样person1和person2指针就指向一块内存，用Java的话说就是两个引用共享一块内存，所以结果可想而知，两个对象是被绑在一起的，任何时候修改其中一个对象，另一对象也会同时被修改，没有实现我们预想的结果。
     那正确的方法应该怎么做呢，一种是比较笨的方法：

                      Person person1=new Person("kenny",23,new Date());
                      Person person2=new Person("kenny",23,new Date());

     直接再创建一个新对象，然后给它初始化和原对象一样的所有属性，这种方法对与属性量很小的类来说还可以，但如果你要复制的对象有成百上千个属性，那么重新创建一个对象并对其初始化的工作量可想而知。那最好的方法是什么呢-----使用clone方法.
     看过C++高级编程的朋友应该很清楚，在C++中为了解决对象副本的问题，C++建议在每一个类中都写一个拷贝构造函数，这个函数就是用来在对象复制的时候自动调用的(这是我觉得C++比Java强大的地方，因为它支持运算符重载，很多时候都可以重载一个符号来代替函数功能),而Java中没有拷贝构造函数，所以在对象拷贝的时候就没有自动生成独立副本的机制，所以需要我们自己重写Object类中的clone方法，然后在需要对象副本的地方显示的调用它。
      下面我以一个实际的例子来说明如何使用clone方法来实现对象的复制：
       首先创建一个Person类：

 package com.ubs.kenny;
 import java.util.Date;

public class Person implements Cloneable {//实现Cloneable接口
    private String name;

    private int age;

    private Date today;

    public Person(String name, int age, Date today) {
        this.name = name;
        this.age = age;
        this.today = today;

    }

    public Object clone() {//重写clone方法
        Person p = null;
        try {
            p = (Person) super.clone();//实现影子复制
            p.today = (Date) today.clone();//实现深度复制
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return p;
    }

    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 Date getToday() {
        return today;
    }

    public void setToday(int year) {
        today.setYear(year);
    }
}
    这里有几处需要说明的。第一，要实现clone的类一定要实现Cloneable接口，其实这个接口中没有任何方法，实现这个接口只是给系统申明：你要开始实现clone这方法了.第二，就是重写Object里的clone方法，这里就是实现对象复制的核心部分，这里又出现两个很重要的概念：影子克隆和深度克隆，对于一个对象，它内部又有很多属性，这些属性也是由不同类型的数据组成，我们可以把这些类型的数据统一划分为两类：基本类型和类类型。在Person类中，name,age就属于基本类型中的String，int,而today就属于类类型，因为它是java.util.Date类的对象。如果在clone方法中只实现对基本类型属性的拷贝，叫做影子克隆；既实现对基本类型属性的拷贝也实现对类类型属性的拷贝，叫做深度克隆。Person的clone方法的这行代码：p = (Person) super.clone() 是调用父类的clone方法，它只实现了对该类中所有基本类型的拷贝，而today属性是属于类类型的，所以要再调用它自身从Object中继承的clone方法来单独拷贝，这就叫做深度克隆。
    下面我写了一个测试类TestClass，在该类中，首先创建并初始化person1对象，然后打印出它的属性。然后用person1调用clone方法生成一个person2对象，接着打印出person2对象的属性。之后改变person2的所有属性，然后再打印出person1和person2对象的属性。

package com.ubs.kenny;
import java.util.Date;

public class TestClass {

    public static void main(String[] args) {
       
        Person person1=new Person("kenny",23,new Date());
        System.out.println("person1 origin:");
        System.out.println("name:"+person1.getName());
        System.out.println("age:"+person1.getAge());
        System.out.println("time:"+person1.getToday());
       
        Person person2=(Person)person1.clone();
        System.out.println("person2 origin:");
        System.out.println("name:"+person2.getName());
        System.out.println("age:"+person2.getAge());
        System.out.println("time:"+person2.getToday());
       
        System.out.println("--------------------------------------------------");
       
        person2.setName("mark");
        person2.setAge(33);
        person2.setToday(8);
       
        System.out.println("person1 current:");
        System.out.println("name:"+person1.getName());
        System.out.println("age:"+person1.getAge());
        System.out.println("time:"+person1.getToday());
       
        System.out.println("person2 current:");
        System.out.println("name:"+person2.getName());
        System.out.println("age:"+person2.getAge());
        System.out.println("time:"+person2.getToday());       
    }
}
      下面是打印出的结果：
person1 origin:
name:kenny
age:23
time:Fri Aug 24 16:12:43 CST 2007
person2 origin:
name:kenny
age:23
time:Fri Aug 24 16:12:43 CST 2007
--------------------------------------------------
person1 current:
name:kenny
age:23
time:Fri Aug 24 16:12:43 CST 2007
person2 current:
name:mark
age:33
time:Mon Aug 24 16:12:43 CST 1908
       我们可以看到，横线以上的输出说明，person2对象确实是由person1对象复制而来，横线以下的输出说明
修改person2对象以后，对象person1并没有同时被修改，所以person1和person2两个对象是彼此对立的，这就实现了由person1到person2的深度克隆。