“纵使面试无数，难敌考官吃素“，昨天去乐视面试，遇到一个从来没有遇到过的考题！

请分别实现深度和浅读的对象克隆？

原理：深度克隆和浅度克隆，Object中的克隆方法是浅度克隆。JDK规定了克隆需要满足的一些条件，简要总结一下就是：对某个对象进行克隆，对象的的成员变量如果包括引用类型或者数组，那么克隆的时候其实是不会把这些对象也带着复制到克隆出来的对象里面的，只是复制一个引用，这个引用指向被克隆对象的成员对象，但是基本数据类型是会跟着被带到克隆对象里面去的。而深度可能就是把对象的所有属性都统统复制一份新的到目标对象里面去。简单画个对比图：

img

img

实现方式

  • 实现Serializable接口，通过对象的序列化和反序列化实现克隆，可以实现真正的深度克隆；

  • 实现Cloneable接口并重写Object类中的clone()方法，即可实现浅度克隆。

代码

Car.java

  1. public class Car implements Serializable {
  3.     private static final long serialVersionUID = 1L;
  5.     private String brand;//品牌
  6.     private int maxSpeed;//最高时速
  8.     public Car(String brand, int maxSpeed) {
  9.         this.brand = brand;
  10.         this.maxSpeed = maxSpeed;
  11.     }
  13.     public String getBrand() {
  14.         return brand;
  15.     }
  17.     public void setBrand(String brand) {
  18.         this.brand = brand;
  19.     }
  21.     public int getMaxSpeed() {
  22.         return maxSpeed;
  23.     }
  25.     public void setMaxSpeed(int maxSpeed) {
  26.         this.maxSpeed = maxSpeed;
  27.     }
  29.     @Override
  30.     public String toString() {
  31.         return "Car{" +
  32.                 "brand='" + brand + '\'' +
  33.                 ", maxSpeed=" + maxSpeed +
  34.                 '}';
  35.     }
  36. }

Person.java

  1. public class Person implements Serializable {
  2.     private static final long serialVersionUID = 1L;
  4.     private String name;//姓名
  5.     private int age;//年龄
  6.     private Car car;//座驾
  8.     public Person(String name, int age, Car car) {
  9.         this.name = name;
  10.         this.age = age;
  11.         this.car = car;
  12.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  22.     public int getAge() {
  23.         return age;
  24.     }
  26.     public void setAge(int age) {
  27.         this.age = age;
  28.     }
  30.     public Car getCar() {
  31.         return car;
  32.     }
  34.     public void setCar(Car car) {
  35.         this.car = car;
  36.     }
  38.     @Override
  39.     public String toString() {
  40.         return "Person{" +
  41.                 "name='" + name + '\'' +
  42.                 ", age=" + age +
  43.                 ", car=" + car +
  44.                 '}';
  45.     }
  46. }

Person2.java

  1. public class Person2 implements Serializable {
  2.     private static final long serialVersionUID = 1L;
  4.     private String name;//姓名
  5.     private int age;//年龄
  6.     private Car car;//座驾
  8.     public Person2(String name, int age, Car car) {
  9.         this.name = name;
  10.         this.age = age;
  11.         this.car = car;
  12.     }
  14.     public String getName() {
  15.         return name;
  16.     }
  18.     public void setName(String name) {
  19.         this.name = name;
  20.     }
  22.     public int getAge() {
  23.         return age;
  24.     }
  26.     public void setAge(int age) {
  27.         this.age = age;
  28.     }
  30.     public Car getCar() {
  31.         return car;
  32.     }
  34.     public void setCar(Car car) {
  35.         this.car = car;
  36.     }
  38.     @Override
  39.     protected Object clone(){
  40.         Person2 s= null;
  41.         try {
  42.             s = (Person2) Person2.super.clone();
  43.         } catch (CloneNotSupportedException e) {
  44.             e.printStackTrace();
  45.         }
  46.         return s;
  47.     }
  49.     @Override
  50.     public String toString() {
  51.         return "Person{" +
  52.                 "name='" + name + '\'' +
  53.                 ", age=" + age +
  54.                 ", car=" + car +
  55.                 '}';
  56.     }
  57. }

CloneUtil.java

  1. public class CloneUtil {
  3.     private CloneUtil() {
  4.         throw new AssertionError();
  5.     }
  7.     public static <T extends Serializable> T clone(T object) throws IOException, 
  8.             ClassNotFoundException {
  9.         // 说明：调用ByteArrayOutputStream或ByteArrayInputStream对象的close方法没有任何意义
  10.         // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源，这一点不同于对外资源(如文件流)的释放
  11.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  12.         ObjectOutputStream oos = new ObjectOutputStream(baos);
  13.         oos.writeObject(object);
  15.         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
  16.         ObjectInputStream ois = new ObjectInputStream(bais);
  17.         return (T) ois.readObject();
  18.     }
  19. }

CloneTest

  1. public class CloneTest {
  2.     public static void main(String[] args){
  3.         try {
  4.             // 深拷贝
  5.             Person p1 = new Person("xiaoming",18,new Car("Benz",300));
  6.             Person p2 = CloneUtil.clone(p1);
  7.             // 修改克隆的Person对象p2关联的汽车对象的品牌属性
  8.             // 原来的Person对象p1关联的汽车不会受到任何影响，还是Benz
  9.             // 因为在克隆Person对象时其关联的汽车对象也被克隆了
  11.             p2.setAge(25);
  12.             p2.getCar().setBrand("BYD");
  14.             System.out.println(p1);
  16.             Person2 p3 = new Person2("xiaoming",18,new Car("Benz",300));
  17.             Person2 p4 = (Person2) p3.clone();
  18.             p4.setAge(25);
  19.             p4.getCar().setBrand("BYD");
  21.             System.out.println(p3);
  22.         } catch (Exception e) {
  23.             e.printStackTrace();
  24.         }
  25.     }
  26. }

结果 img