java 浅客隆和深客隆

转载自: http://blog.csdn.net/HANLIPENGHANLIPENG/article/details/52120741

向原作者致敬,没有其他的意思,如果冒犯可联系本人删除即可.

浅克隆：只能克隆对象本身，对于依附于对象的对象则不予克隆对象，只对其地址克隆 
浅克隆需要注意的地方： 
1：被克隆的对象需要实现Cloneable 
2：Cloneable没有方法，是个标志性克隆 
3：如果被克隆的对象维护着另一个，则只克隆了地址

下面给出一个例子： 
一个person类里面维护着一个Address类，p2克隆p1的时候只对person进行克隆，对于依附于person类的Address类并没有克隆，只是复制其地址 
下面的代码是person类和Address类

import java.io.Serializable;

class Address implements Serializable{
    String address;
    public Address(String address){
        this.address=address;
    }
}

public class Person implements Cloneable,Serializable{
    Address a;
    String bianhao;
    String name;
    public Person(String bianhao,String name,Address a){
        this.bianhao=bianhao;
        this.name=name;
        this.a=a;
    }
    @Override
    public String toString() {
        return "Person [a=" + a.address + ", bianhao=" + bianhao + ", name=" + name + "]";
    }
    @Override
    public Object clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return super.clone();
    }
}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

下面的代码是用浅克隆的测试

public class Demo1 {
    public static void main(String[] args) throws Throwable {
        Address a=new Address("河南");
        Person p1=new Person("123", "张三", a);
        Person p2=(Person) p1.clone();
        p2.name="李四";
        p2.a.address="北京";
        System.out.println("p1:"+p1);
        System.out.println("p2:"+p2);
    }
}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
 
 
1
2
3
4
5
6
7
8
9
10
11
12

下面是运行上面代码所产生的结果： 

深克隆：深克隆是对其依附的对象也进行克隆 
深克隆需要注意的地方： 
1：利用IO流进行存储，然后进行读取 
2：需要实现可序列化接口（Java.io.Serializable） 
下面是用深克隆进行克隆的例子： 
person和Address跟上面的一样 
下面是测试类代码：

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Demo2 {
    public static void main(String[] args) throws Throwable {   
        Address a=new Address("河南");
        Person p1=new Person("110", "张三", a);
        writObject(p1);
        Person p2=readObject();
        p2.a.address="北京";
        p2.name="李四";
        System.out.println("p1:"+p1);
        System.out.println("p2:"+p2);
    }
    /*
     * 从文件中读取这个对象
     */
    public static Person readObject() throws Exception{
            File f=new File("person.txt");
            ObjectInputStream in=new ObjectInputStream(new FileInputStream(f));
            Person pp=(Person)in.readObject();
            in.close();
            return pp;
    }
    /*
     * 将对象写入磁盘
     */
    public static void writObject(Person p) throws Exception{
        File f=new File("./person.txt");
        ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream(f));
        out.writeObject(p);
        out.close();    
    }
}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

运行结果为： 

两者的区别是:浅客隆中的对于包含的对象是公用的,也就是说只要有一个对象对他做出更改则另一个自动更改.保持值一直是相同的.

深客隆,对于包含的对象是相互不影响的.也就是其中一个对包含的对象做出更改,则另一个是不会变的.

注意！！！！ 
利用下面的代码不叫克隆，这个只是对象的引用

Person p1=new Person("110", "张三", a);
Person p2=p1;

对于引用和浅客隆的区别是:

   引用是只通过内存地址来指向,克隆是在内存中开辟一块新的空间并复制一份原有对象.简单的说有两个对象所表示同一种内容,引用是在内存中实际只存在  


 一份,两个对象共同使用它.而克隆则是内存中实际存在两份,两个对象分别使用