在使用克隆时，我们需要知道使用的目的：就是为了快速构造一个和已有对象相同的副本。
一、浅克隆：
要实现java.lang.Cloneable接口，并重写clone方法。

public class A implements Cloneable {
    private String name;
    private int age;
    private int[] s;
    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 int[] getS() {
        return s;
    }
    public void setS(int[] s) {
        this.s = s;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        
        return super.clone();
    }
}

测试类：

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        A a = new A();
        a.setName("abc");
        a.setAge(22);
        a.setS(new int[]{12});
        System.out.println("克隆前a：name="+a.getName()+" age="+a.getAge()+" s="+a.getS()[0]);
        A a2 = (A) a.clone();
        a2.setName("aaa");
        a2.setAge(10);
        int[] i = a2.getS();
        i[0] = 13;
        a2.setS(i);
        System.out.println("克隆后a：name="+a.getName()+" age="+a.getAge()+" s="+a.getS()[0]);
        System.out.println("克隆后a2：name="+a2.getName()+" age="+a2.getAge()+" s="+a2.getS()[0]);
    }
}
打印结果：
克隆前a：name=abc age=22 s=12
克隆后a：name=abc age=22 s=13
克隆后a2：name=aaa age=10 s=13

可以看出，基本类型可以使用浅克隆，而对于引用类型，由于引用的是内容相同，所以改变a2实例对象中的属性就会影响到a。所以引用类型需要使用深克隆。
二、使用序列化实现深克隆：
javabean类

import java.io.Serializable;
public class B implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private int[] s;
    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 int[] getS() {
        return s;
    }
    public void setS(int[] s) {
        this.s = s;
    }
}

克隆类

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class DeepClone {
    public Object deepClone(Object src) {
        Object o = null;
        try {
            if (src != null) {
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
                oos.writeObject(src);
                ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
                ObjectInputStream ois = new ObjectInputStream(bais);
                o = ois.readObject();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return o;
    }
}

测试类

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        B b = new B();
        b.setName("abc");
        b.setAge(22);
        b.setS(new int[]{12});
        System.out.println("克隆前a：name="+b.getName()+" age="+b.getAge()+" s="+b.getS()[0]);
        DeepClone dc = new DeepClone();
        B b2 = (B) dc.deepClone(b);
        b2.setName("aaa");
        b2.setAge(20);
        int[] i2 = b2.getS();
        i2[0] = 10;
        b2.setS(i2);
        System.out.println("克隆后a：name="+b.getName()+" age="+b.getAge()+" s="+b.getS()[0]);
        System.out.println("克隆后a2：name="+b2.getName()+" age="+b2.getAge()+" s="+b2.getS()[0]);
    }
}
打印结果：
克隆前a：name=abc age=22 s=12
克隆后a：name=abc age=22 s=12
克隆后a2：name=aaa age=20 s=10

可以看到，两个引用所指向的对象在堆中相互独立，互不干扰，这样就实现了深度克隆。