java中的拷贝是什么 ？就是用Object中的clone()拷贝一个对象

在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。

那请问new创建一个对象和clone复制一个对象有什么区别吗？
        new操作符的本意是分配内存。程序执行到new操作符时， 首先去看new操作符后面的类型，因为知道了类型，才能知道要分配多大的内存空间。分配完内存之后，再调用构造函数，填充对象的各个域，这一步叫做对象的初始化，构造方法返回后，一个对象创建完毕，可以把他的引用（地址）发布到外部，在外部就可以使用这个引用操纵这个对象。而clone在第一步是和new相似的， 都是分配内存，调用clone方法时，分配的内存和源对象（即调用clone方法的对象）相同，然后再使用原对象中对应的各个域，填充新对象的域， 填充完成之后，clone方法返回，一个新的相同的对象被创建，同样可以把这个新对象的引用发布到外部。

简单举一个栗子吧：

package fuxi;
class Student{
    int age;
    String name;
    public Student(String name,int age) {
        this.name=name;
        this.age=age;
    }
}
public class One {

    public static void main(String args[]) {
       Student student1=new Student("小蒋", 21);
       Student student2=student1;
       System.out.println("学生1地址"+student1);
       System.out.println("学生2地址"+student2);
    }
}

输出：

意思就是说 如果是引用 直接复制的话 只是把引用给复制一遍 意思就是 student1和student2的引用值是相同的 代表同一个对象。

浅拷贝：

浅拷贝（浅复制、浅克隆）：被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。

　　
　　MainObject1是一个对象 而MainObject2是MainObject1的浅克隆对象
　　Field1 Field2 是int ContainObject1是对象
　　如果是int之类的基本类型 则是直接赋值代表两个不同的变量 但是内容相同 操作一个对另一个不影响
　　如果是引用类型如对象之类的 那么操作MainObject1的ContainObject1就会影响MainObject2中的ContainObject2 因为他俩引用是指向同一个对象
　　注意：String是特殊情况 String 类型在传递时其实也是值传递，因为 String 类型是不可变对象。 所以如果ContainObject1是String类型 那么改变MainObject1的ContainObject1不会影响MainObject2中的ContainObject2 而是指向新的String值 具体的可以看为什么String是不可变的

栗子：

package fuxi;

class Person {
    int age;
    String name;

    public Person(String name,int age) {
        this.name=name;
        this.age=age;
    }
    public void setAge(int a) {
        age=a;
    }
    public void setName(String name) {
        this.name=name;
    }
}

public class One implements Cloneable {
    String bookName;
    double price;
    Person author;

    public One(String bn, double price, Person author) {
        bookName = bn;
        this.price = price;
        this.author = author;
    }

    public Object clone() {
        Object b = null;
        try {
            b =  super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return (One)b;
    }

    public static void main(String args[]) {
        Person p = new Person("Dream", 34);
        One book1 = new One("Java开发", 30.00, p);
        One book2 = (One) book1.clone();
        book2.price = 44.00;
        book2.author.setAge(45);
        book2.author.setName("Fish");
        book2.bookName = "Android开发";
        System.out.println("age = " + book1.author.age + "  name = " + book1.bookName + "     price = " + book1.price);
        System.out.print("age = " + book2.author.age + "  name = " + book2.bookName + "     price = " + book2.price);
    }
}

结果：

age = 45 name = Java开发 price = 30.0

age = 45 name = Android开发 price = 44.0

从结果中发现在改变 book2 对象的 name 和 price 属性时 book1 的属性并不会跟随改变，当改变 book2 对象的 author 属性时 book1 的 author 对象的属性也改变了，说明 author 是浅拷贝，和 book1 的 author 是使用同一引用。

　1.为了获取对象的一份拷贝，我们可以利用Object类的clone()方法。

　2.在派生类中覆盖基类的clone()方法，并声明为public。
  （Object类中的clone()方法是protected的）。在子类重写的时候，可以扩大访问修饰符的范围

　3.在派生类的clone()方法中，调用super.clone()。
因为在运行时刻，Object类中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间  
并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。

4.在派生类中实现Cloneable接口。这个接口中没有什么方法，只是说明作用。
　注意：继承自java.lang.Object类的clone()方法是浅复制。

clone（）方法是复制对象的最快方法。这个过程需要更少的步骤来完成。
默认情况下，clone（）方法提供对象的浅表副本; 即，如果我们调用super.clone（），那么它是一个浅拷贝。
clone()方法将对象复制了一份并返回给调用者。
①对任何的对象x，都有x.clone() != x;//克隆对象与原对象不是同一个对象
②对任何的对象x，都有x.clone().getClass()== x.getClass();//克隆对象与原对象的类型一样

总结 ：浅拷贝 ：浅拷贝对象要继承Cloneable 然后重写clone 直接返回（对象）super.clone即可

深拷贝：

深拷贝（深复制、深克隆）：被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。

那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。

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

直接看图 是全新的 对象 深拷贝后
源对象和拷贝对象之间互不影响。无论字段是否是应用类型还是原始数据类型。
那么如何实现深拷贝呢？
其实 很简单：

即 原来的person浅拷贝处理：

class Person implements Cloneable{
    int age;
    String name;

    public Person(String name,int age) {
        this.name=name;
        this.age=age;
    }
    public void setAge(int a) {
        age=a;
    }
    public void setName(String name) {
        this.name=name;
    }
    public Object clone() {
        Object b = null;
        try {
            b =  super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return (Person)b;
    }
}

加上这句话就可以了

book2.author =(Person)author.clone(); //将Person对象进行拷贝，Person对象需进行了拷贝

即：

One book2 = (One) book1.clone();
book2.author=(Person)p.clone();

上面是用 clone() 方法实现深拷贝，传统重载clone()方法，但当类中有很多引用时，比较麻烦。 当然我们还有一种深拷贝方法，就是将对象 序列化 。

把对象写到流里的过程是序列化（Serilization）过程；而把对象从流中读出来的反序列化（Deserialization）过程。应当指出的是，写在流里的是对象的一个拷贝，而原对象仍然存在于JVM里面。

在Java语言里深复制一个对象，常常可以先使对象实现Serializable接口，然后把对象（实际上只是对象的一个拷贝）写到一个流里，再从流里读出来，便可以重建对象。

public Object deepClone()
{
 //将对象写到流里
     ByteArrayOutoutStream bo=new ByteArrayOutputStream();
     ObjectOutputStream oo=new ObjectOutputStream(bo);
     oo.writeObject(this);
     //从流里读出来
     ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());
     ObjectInputStream oi=new ObjectInputStream(bi);
     return(oi.readObject());
}

注意： 如果拷贝类里面有类对象的话 那么那个类也得是实现Serializable接口
然后拷贝对象的时候调用deepClone（）方法 来代替clone方法

One book2 =(One)book1.deepClone();

完整代码如下 ： 不难 耐心看完

package fuxi;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OptionalDataException;
import java.io.OutputStream;
import java.io.Serializable;

class Person implements Serializable {
    int age;
    String name;

    public Person(String name,int age) {
        this.name=name;
        this.age=age;
    }
    public void setAge(int a) {
        age=a;
    }
    public void setName(String name) {
        this.name=name;
    }

}

public class One implements Serializable {

    String bookName;
    double price;
    Person author;

    public One(String bn, double price, Person author) {
        bookName = bn;
        this.price = price;
        this.author = author;
    }
    public Object deepClone() throws IOException, OptionalDataException, ClassNotFoundException {
        // 将对象写到流里
        OutputStream bo = new ByteArrayOutputStream();
        ObjectOutputStream oo = new ObjectOutputStream(bo);
        oo.writeObject(this);

        // 从流里读出来
        InputStream bi = new ByteArrayInputStream(((ByteArrayOutputStream) bo).toByteArray());
        ObjectInputStream oi = new ObjectInputStream(bi);
        return (oi.readObject());
    }



    public static void main(String args[]) throws OptionalDataException, ClassNotFoundException, IOException {
        Person p = new Person("Dream", 34);
        One book1 = new One("Java开发", 30.00, p);
        One book2 =(One)book1.deepClone();
        book2.price = 44.00;
        book2.author.setAge(45);
        book2.author.setName("Fish");
        book2.bookName = "Android开发";
        System.out.println("age = " + book1.author.age + "  name = " + book1.bookName + "     price = " + book1.price);
        System.out.print("age = " + book2.author.age + "  name = " + book2.bookName + "     price = " + book2.price);
    }
}

输出是：

age = 34  name = Java开发     price = 30.0
age = 45  name = Android开发     price = 44.0

总结：
浅拷贝：

深拷贝：

浅拷贝：
浅拷贝对象需要继承Cloneable接口 重写clone 返回super.clone 并且把protect改为public 依靠clone实现拷贝
调用： Student s2 = (Student)s1.clone();即可

深拷贝：
源对象和拷贝对象之间互不影响。无论字段是否是应用类型还是原始数据类型。
深拷贝对象需要继承Serializable接口 依靠序列化 自定义方法 来写入读出流
调用：One book2 =(One)book1.deepClone();
注意：序列化的时候考虑transient 因为这个修饰符可以 使被修饰的变量不被序列化 意思就是：不能序列化一个transient变量。
(具体可以参考：序列化）

使用场景有：

使用浅拷贝：对象只有原始数据类型字段；有引用类型的字段，但从不更改它。

使用深拷贝：有引用类型的字段，且经常被修改。

它非常简单，如果对象只有原始字段，那么显然你会去浅层复制，但是如果对象引用了其他对象，那么根据请求，应该选择浅拷贝或深拷贝。我的意思是，如果引用不随时修改，那么进行深层复制就没有意义了。你可以选择浅拷贝。但如果参考文件经常被修改，那么您需要进行深度复制。再次没有硬性规定，这一切都取决于要求。

问：什么我们在派生类中覆盖Object的clone()方法时，一定要调用super.clone()呢？

答：在运行时刻，Object中的clone()识别出你要复制的是哪一个对象，然后为此对象分配空间，并进行对象的复制，将原始对象的内容一一复制到新对象的存储空间中。

题外话：
如果是单例模式，你以这种方式进行深拷贝，则它就不再是单例模式了。

参考：
https://blog.csdn.net/zhangjg_blog/article/details/18369201
https://www.jianshu.com/p/8c74edbb46c0