一、浅拷贝：

     （1） 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性复制一份给新的对象。因为是两份不同的数据，所以对其中一的对象的成员变量值进行修改，不会影响另一个对象拷贝得到的数据。
     （2） 对于数据类型是引用类型的成员变量，比如说成员变量是某个数组，某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用指（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

  实现浅拷贝主要有以下两种方式：

• 通过拷贝构造方法

 
public class CopyConstructor {
    public static void main(String[] args) {
        Age a = new Age(20);
        Person p1 = new Person(a,"宁采臣");
        Person p2 = new Person(p1);
        System.out.println("p1是"+p1);
        System.out.println("p2是"+p2);
        //修改p1的各属性值，观察p2得到各属性值是否跟随变化
        p1.setName("聂小倩");
        a.setAge(18);
        System.out.println("修改后的p1是"+p1);
        System.out.println("修改后的p2是"+p2);
    }
}
 
class   Person{
    private Age age;
    private String name;
    public Person(Age age,String name){
        this.age = age;
        this.name = name;
    }
 
    //拷贝构造方法
    public Person(Person p){
        this.name = p.name;
        this.age = p.age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public String toString(){
        return this.name + " " + this.age;
    }
}
 
 
class Age{
    private int age;
    public Age(int age){
        this.age = age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public int getAge() {
        return this.age;
    }
 
    public String toString(){
        return getAge()+"";
    }
 
}

输出结果：

    结果分析：这里对Person类选择了两个具有代表性的属性值：一个是引用传递类型；另一个是字符串类型（属于常量）。

通过拷贝构造方法进行了浅拷贝，各属性值成功复制。其中，p1值传递部分的属性值发生变化时，p2不会随之改变；而引用传递部分属性值发生变化时，p2也随之改变。

要注意：如果在拷贝构造方法中，对引用数据类型变量逐一开辟新的内存空间，创建新的对象，也可以实现深拷贝。而对于一般的拷贝构造，则一定是浅拷贝。

• 通过重写clone()方法进行浅拷贝

Object类是类结构的根类，其中有一个方法为protected Object clone() throw CloneNotSupportedException,这个方法就是进行的浅拷贝。有了这个浅拷贝的模板，就可以通过调用clone()方法来实现对象的浅拷贝，但是需要注意：

 （1）Object类虽然有这个方法，但是这个方法是受保护的(被projected修饰)，所以是无法直接使用。

 （2）使用clone方法的类必须实现Cloneable接口，否则会抛出异常CloneNotSupportedException。

 （3）对于以上两点，解决方法是，在使用clone方法的类中重写了clone()方法，通过super.clone()调用Object类中的原clone方法

实例代码如下：

     对Student类的对象进行拷贝，直接重写clone()方法，通过调用clone方法完成浅复制。

public class ShallowCopy {
    public static void main(String[] args) {
        Age a = new Age(18);
        Student stu1 = new Student("宁采臣",a,174);
 
        //通过调用重写后的clone方法进行浅拷贝
        Student stu2 =(Student)stu1.clone();
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
 
        //尝试修改stu1中的各属性，观察stu2的属性有没有变化
        stu1.setName("聂小倩");
        //修改age这个引用类型的成员变量的值
        a.setAge(20);
        //stu1.setaAge（new Age（20））;使用这种方式修改age属性值的话，stu2是不会跟着改变的。因为创建了一个新的Age类对象而不是改变原对象的实例值
        stu1.setLength(158);
        System.out.println(stu1.toString());
        System.out.println(stu2.toString());
    }
}
 
/*
*创建年龄类
*/
class Age{
    //年龄类的成员变量（属性）
    private int age;
    //构造方法
    public Age(int age){
        this.age = age;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    @Override
    public String toString() {
        return this.age+"";
    }
}
 
/*
*创建学生类
*/
class Student implements Cloneable{
    //学生类的成员变量（属性），其中一个属性为类的对象
    private String name;
    private Age aage;
    private int length;
    //构造方法，其中一个参数为另一个类的对象
    public Student(String name,Age a,int length){
        this.name = name;
        this.aage = a;
        this.length = length;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public Age getAge() {
        return aage;
    }
 
    public void setAge(Age age) {
        this.aage = age;
    }
 
    public int getLength() {
        return length;
    }
 
    public void setLength(int length) {
        this.length = length;
    }
 
    //设置输出的字符串形式
 
    @Override
    public String toString() {
        return "姓名是:"+this.getName()+",年龄为:"+this.getAge().toString()+",长度是："+this.getLength();
    }
 
    //重写Object类的clone方法
    public Object clone(){
        Object obj = null;
        try {
            obj = super.clone();
        } catch (CloneNotSupportedException e){
            e.printStackTrace();
        }
        return obj;
    }
}

输出结果：

分析结果：

        基本数据类型是值传递，所以修改值后不会影响另一个对象的该属性值；引用数据类型是地址传递（引用传递），所以修改值后另一个对象的该属性值会同步被修改。

        String类型非常特殊，所以额外设置了一个字符串类型的成员变量来进行说明。首先，String类型属于引用数据类型，不属于基本数据类型，但是String类型的数据是存放在常量池中的，也就是无法修改的！也就是说，当将name属性从“宁采臣”改为“聂小倩"后，并不是修改了这个数据的值，而是把这个数据的引用从指向”宁采臣“这个常量改为了指向”聂小倩“这个常量。在这种情况下，另一个对象的name属性值仍然指向”宁采臣“不会受到影响。

 二、深拷贝：

        深拷贝是一个整个独立的对象拷贝，深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。

        简而言之，深拷贝把要复制的对象所引用的对象都复制了一遍。

实例代码：

package com.test;

public class DeepCopy {
    public static void main(String[] args) throws CloneNotSupportedException {
        Teacher2 teacher = new Teacher2();
        teacher.setName("riemann");
        teacher.setAge(27);

        Student3 student1 = new Student3();
        student1.setName("edgar");
        student1.setAge(18);
        student1.setTeacher(teacher);

        Student3 student2 = (Student3) student1.clone();
        System.out.println("拷贝后");
        System.out.println(student2.getName());
        System.out.println(student2.getAge());
        System.out.println(student2.getTeacher().getName());
        System.out.println(student2.getTeacher().getAge());

        System.out.println("修改老师的信息后-------------");
        // 修改老师的信息
        teacher.setName("Games");
        System.out.println(student1.getTeacher().getName());
        System.out.println(student2.getTeacher().getName());
    }
}

class Teacher2 implements Cloneable {
    private String name;
    private int age;

    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 Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Student3 implements Cloneable {
    private String name;
    private int age;
    private Teacher2 teacher;

    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 Teacher2 getTeacher() {
        return teacher;
    }

    public void setTeacher(Teacher2 teacher) {
        this.teacher = teacher;
    }

    public Object clone() throws CloneNotSupportedException {
        // 浅复制时：
        // Object object = super.clone();
        // return object;

        // 改为深复制：
        Student3 student = (Student3) super.clone();
        // 本来是浅复制，现在将Teacher对象复制一份并重新set进来
        student.setTeacher((Teacher2) student.getTeacher().clone());
        return student;

    }
}

输出结果：

拷贝后
edgar
18
riemann
27
修改老师的信息后-------------
Games
riemann

结果分析：

        两个引用student1和student2指向不同的两个对象，两个引用student1和student2中的两个teacher引用指向的是两个对象，但对teacher对象的修改只能影响student1对象,所以说是深拷贝。