克隆羊的问题

现有一只羊tom,姓名：tom,年龄：1,颜色：白色，请编写程序创建和tom羊属性完全相同的10只羊。普通方案

@Data
public class Sheep {
    private String name;
    private int age;
    private String color;

    public Sheep(String name, int age, String color) {
        this.name = name;
        this.age = age;
        this.color = color;
    }
    @Override
    public String toString() {
        return "Sheep{" +
                "name='" + name + ''' +
                ", age=" + age +
                ", color='" + color + ''' +
                '}';
    }
}

public class SheepTest {
    public static void main(String[] args) {
        Sheep sheep = new Sheep("tom", 1, "白色");
        Sheep sheepClone1 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        Sheep sheepClone2 = new Sheep(sheep.getName(), sheep.getAge(), sheep.getColor());
        System.out.println(sheep);
        System.out.println(sheepClone1);
        System.out.println(sheepClone2);
    }
}

普通方案分析

优点是简单易理解，易操作。
在创建新的对象时，总是需要重新获取原始对象的属性，如果创建的对象比较复杂时，效率较低。
总是需要重新初始化对象，而不是动态地获得对象运行时的状态，不够灵活
对象扩展字段时，需要修改复制的类，违反ocp原则。 改进思路分析 Java中Object类是所有类的根类，Object类提供了一个clone()方法，该方法可以将一个Java对象复制一份，但是需要实现clone的Java类必须要实现一个接口Cloneable,该接口表示该类能够复制且具有复制的能力=》原型模式。

原型模式基本介绍

原型模式（prototype）是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象。
原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节。创建对象时通过拷贝当前对象来创建新的对象，即newObject=oldObject.clone()。 原型模式解决克隆羊的问题 Sheep类实现Cloneable接口,并覆写clone方法。test类调用clone()即可。

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

public static void main(String[] args) throws Exception {
    Sheep sheep = new Sheep("tom", 1, "白色", "蒙古羊");
    Sheep sheepClone1 = (Sheep) sheep.clone();
    Sheep sheepClone2 = (Sheep) sheep.clone();
    System.out.println(sheep);
    System.out.println(sheepClone1);
    System.out.println(sheepClone2);
}

浅拷贝和深拷贝

浅拷贝

数据类型是基本数据类型或String,浅拷贝直接进行值传递，即将属性值直接复制一份给新的对象。
数据类型是引用类型（对象、数组），浅拷贝会进行引用传递，也就是将成员变量的引用值（内存地址）复制一份给新的对象。如属性A是一个引用类型，那么浅拷贝后newObject.A=oldObject.A。如果A有修改，将影响到newObject和oldObject。
上面用原型模式改进的克隆羊的例子就是浅拷贝，浅拷贝是用默认的clone()来实现的，super.clone()。 深拷贝

相对于浅拷贝来说，深拷贝对基本类型或String类型的处理是一样的，不同的是处理引用类型。深拷贝会为所有的引用类型的成员变量申请存储空间，并复制每个引用数据成员变量所引用的对象，直到改对象可达的所有对象。 深拷贝的两种实现方式 方式1：重写clone方法来实现深拷贝。

@Override
protected Object clone() throws CloneNotSupportedException {
    //对基本数据类型的clone
    Sheep sheep = (Sheep) super.clone();
    //对引用数据类型的clone
    if (this.getBestGoodFriend() != null) {
        sheep.setBestGoodFriend((Sheep) this.bestGoodFriend.clone());
    }
    return sheep;
}

方式1分析：不易扩展，如果sheep中有多个引用类型，那都需要手动clone()，并且如果引用类型里面还有引用类型，则需要每个引用类型都实现clone()，操作起来校麻烦。

方式2：通过对象序列化实现深拷贝。 Sheep类实现Cloneable, Serializable

@Override
    protected Object clone() throws CloneNotSupportedException {
        ByteArrayOutputStream bos = null;
        ObjectOutputStream oos = null;
        ByteArrayInputStream bis = null;
        ObjectInputStream ois = null;
        try {
            //序列化
            oos = new ObjectOutputStream(bos = new ByteArrayOutputStream());
            oos.writeObject(this);

            //反序列化
            ois = new ObjectInputStream(bis = new ByteArrayInputStream(bos.toByteArray()));
            return ois.readObject();
        } catch (Exception e) {
            System.out.println("序列化反序列化出错");
        } finally {
            try {
                bos.close();
                oos.close();
                bis.close();
                ois.close();
            } catch (Exception e) {

            }
        }
        return null;
    }

注意事项及细节

创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也能够提高效率。
不用重新初始化对象，而是动态地获得对象运行时的状态。
如果原始对象发生变化（增加或减少属性），其它克隆对象的也会发生相应的变化，无需修改代码。
缺点：实现深克隆的时候可能需要比较复杂的代码。需要为每个类配备一个clone(),这对全新的类来说不是很难，单对已有的类进行改造时，需要修改其源代码，违背了ocp原则。

原型模式--java实现

克隆羊的问题

原型模式基本介绍

浅拷贝和深拷贝