java对象---深/浅拷贝

继原型模式的续，本文分享的是浅拷贝和深拷贝
深入了解浅拷贝与深拷贝

在学习深拷贝和浅拷贝之前，咱们先来一个例子；

1. import java.util.ArrayList;

3. public class MyBaby implements Cloneable {

4.    /**

5.     * 私有变量

6.     */

7.    private ArrayList<String> list = new ArrayList<>();

9.    @Override

10.    protected Object clone() throws CloneNotSupportedException {

11.        MyBaby myBaby = null;

12.        try {

13.            myBaby = (MyBaby) super.clone();

14.       } catch (CloneNotSupportedException ex) {

15.            ex.printStackTrace();

16.       }

17.        return myBaby;

18.   }

20.    /**

21.     * 给List设置

22.     *

23.     * @param value 值

24.     */

25.    public void setValue(String value) {

26.        this.list.add(value);

27.   }

29.    /**

30.     * 获取list

31.     *

32.     * @return list

33.     */

34.    public ArrayList<String> getValue() {

35.        return this.list;

36.   }

37. }

在MyBaby类中有一个私有变量list，类似为List，然后咱们使用setValue对其进行设值，使用getValue进行取值。接下来咱们来看看他是如何拷贝的。

1. public class TestMyBaby {

2.    public static void main(String[] args) {

3.        MyBaby baby = new MyBaby();

4.        baby.setValue("Java后端技术栈");

5.        try {

6.            MyBaby myBabyClone = (MyBaby) baby.clone();

7.            myBabyClone.setValue("咖啡");

8.            

9.            System.out.println(baby.getValue());

10.       } catch (CloneNotSupportedException e) {

11.            e.printStackTrace();

12.       }

13.   }

14. }

猜想运行结果会是神马？

[Java后端技术栈, 咖啡]

怎么会这样呢？怎么会有“咖啡”呢？

是因为Java给我们做了一个偷懒性的拷贝动作，Object类原本就提供一个方法clone用来拷贝对象，因为其对象内部的数组、引用对象等都不拷贝，还是指向了原生对象的内部元素地址，这种拷贝就叫做浅拷贝。

浅拷贝

上面这个拷贝也太浅了吧，两个对象引用都boby、myBaby共享一个私有变量list，都可以对list进行改变，是一种非常不安全的方式。

再看一个例子；

1. public class Person implements Cloneable {

3.    private int age;

4.    private String name;

6.    public int getAge() {

7.        return age;

8.   }

10.    public void setAge(int age) {

11.        this.age = age;

12.   }

14.    public String getName() {

15.        return name;

16.   }

18.    public void setName(String name) {

19.        this.name = name;

20.   }

22.    @Override

23.    protected Object clone() throws CloneNotSupportedException {

24.        Person person=null;

25.        try{

26.            person=(Person)super.clone();

27.       }catch (CloneNotSupportedException ex){

28.            ex.printStackTrace();

29.       }

30.        return person;

31.   }

32. }

。。。。。。。。。。。。。。。。。

版权原因，完整文章，请参考如下：java对象---深/浅拷贝