值传递和引用传递、深拷贝和浅拷贝！

首先给大家解释一下这几个名词的概念：

值传递：在方法的调用过程中，实参把它的实际值传递给形参，此传递过程就是将实参的值复制一份传递到函数中，这样如果在函数中对该值（形参的值）进行了操作将不会影响实参的值。因为是直接复制，所以这种方式在传递大量数据时，运行效率会特别低下。

引用传递：引用传递弥补了值传递的不足，如果传递的数据量很大，直接复过去的话，会占用大量的内存空间，而引用传递就是将对象的地址值传递过去，函数接收的是原始值的首地址值。在方法的执行过程中，形参和实参的内容相同，指向同一块内存地址，也就是说操作的其实都是源数据，所以方法的执行将会影响到实际对象。

浅拷贝：java中提供的clone方法就是浅拷贝，浅拷贝会拷贝一个对象

深拷贝：之所以有深浅之分，是因为浅拷贝在拷贝一个对象的时候，不会拷贝对象的子类，所以引入了深拷贝的概念，解决这个问题就可以让被拷贝的子类实现clone接口，就可以实现深拷贝。

应用场景

值传递：

值传递传递的是真实内容的一个副本，对副本的操作不影响原内容，也就是形参怎么变化，不会影响实参对应的内容。

public class Test
{
 public static void changeStr(String str)
 {
     str = "welcome";
 }
 public static void main(String[] args)
 {
     String str = "1234";
     changeStr(str);
     System.out.println(str);
 }
}

引用传递：

引用 也就是指向真实内容的地址值，在方法调用时，实参的地址通过方法调用被传递给相应的形参，在方法体内，形参和实参指向通愉快内存地址，对形参的操作会影响的真实内容。对象没有被拷贝，拷贝的是栈地址（地址、指针）

public class Demo {
    public static void PersonCrossTest(Person person){
        System.out.println(“传入的person的name：”+person.getName());
        person.setName(“二哈”);
    System.out.println("方法内重新赋值后的name："+person.getName());
}
//测试
public static void main(String[] args) {
    Person p=new Person();
    p.setName("藏獒");
    p.setAge(3);
    PersonCrossTest(p);
    System.out.println("方法执行后的name："+p.getName());
}

我们通过代码展示一下深浅拷贝：

package com.yaolong.clone;

public class Person implements Cloneable{

    //private Integer age;
    private int age;

    private String name;

    public Person(Integer age, String name) {
        super();
        this.age = age;
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return super.toString();
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

//对象拷贝
    private static void copyRealObject() throws CloneNotSupportedException{
        Person p = new Person(23, "zhang");
        Person p1 = (Person) p.clone();      
        System.out.println(p);
        System.out.println(p1);
    }

可以看出，二者的对象地址不一样，因此实现了拷贝。

但是还是有个问题，就是Person类中有一个String类型的引用对象name，它真的也被拷贝过去了吗，还是说依然

是引用的是同一个name对象呢，在上面的代码基础上，我们继续打印：

​
        System.out.println("pName："+p.getName().hashCode());
        System.out.println("p1Name："+p1.getName().hashCode());

​

可见，二者的name属性依然是指向同一个对象。上面故意将age属性改为int基本类型，因为基本数据类型是不存在引用问题。这实际上就是典型的浅拷贝。

深拷贝：

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

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

        Student student2 = (Student) 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("jack");
        System.out.println("student1的teacher为： " + student1.getTeacher().getName());
        System.out.println("student2的teacher为： " + student2.getTeacher().getName());
    }
}

class Teacher 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 Student implements Cloneable {
    private String name;
    private int age;
    private Teacher 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 Teacher getTeacher() {
        return teacher;
    }

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

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

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

    }
}

运行结果：

-------------拷贝后-------------
edgar
18
riemann
28
-------------修改老师的信息后-------------
student1的teacher为： jack
student2的teacher为： riemann