原型模式，孙悟空都会用，猴毛变出的小猴子！

大家好呀，今天又又又是设计模式的一天！跟着洪爵轻松学完设计模式~

​ 今天要讲的是原型模式，大家可能都听过原型模式，因为在spring中你可以给bean配置成原型模式，或者是单例模式，如果是原型模式，那么每次去获取这个bean的时候，都会去生成一个新的对象。

​ 原型模式，是一种创建型模式，它用在创建重复的对象的场景，并且保证它的性能。原型模式需要实现Cloneable接口，那么既然每次返回的都是一个新对象，那么我为什么不直接使用new呢？洪爵知道大家有这样的问题，所以也写有相关的文章，贴在了本篇文章的下方啦！其实通俗的说，clone是本地方法，基于内存的二进制流的复制，在性能上比直接new一个对象会更加的高效，并且还有一点很重要，就是内存的优化上，具体可以看洪爵的文章，已经贴在本篇文章下方。

​ 那么为什么叫做原型模式？它一开始会获取到一个对象，这个对象是我们告诉它的，然后它会根据这个原有的原型对象，快速地生成和原型对象一样的实例对象。

我们抽象出一个原型类，Prototype，实现了Cloneable接口。

然后具体的原型类ConcretePrototype可以继承自抽象原型类Prototype。

最后需要有一个保存每个具体原型对象的地方A，当需要创建具体原型类的时候，直接从地方A去拿到原型对象进行克隆，返回一个新的对象。

上代码，充分了解原型模式：

public abstract class Ball implements Cloneable {

    private String id;
    protected String name;
    
    abstract void show();

    public String getName() {
        return this.name;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getId() {
        return id;
    }

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

public class Badminton extends Ball {

    public Badminton() {
        this.name = "羽毛球";
    }

    void show() {
        System.out.println(name + "呀");
    }
}

public class Basketball extends Ball {

    public Basketball() {
        name = "篮球";
    }

    void show() {
        System.out.println(name + "呀");
    }
}

public class TableTennis extends Ball {

    public TableTennis() {
        name = "乒乓球";
    }

    void show() {
        System.out.println(name + "呀");
    }
}

public class BallCache {

    private static ConcurrentHashMap<String, Ball> ballMap = new ConcurrentHashMap();

    static {
        Basketball basketball = new Basketball();
        basketball.setId("1");
        ballMap.put(basketball.getId(), basketball);

        Badminton badminton = new Badminton();
        badminton.setId("2");
        ballMap.put(badminton.getId(), badminton);

        TableTennis tableTennis = new TableTennis();
        tableTennis.setId("3");
        ballMap.put(tableTennis.getId(), tableTennis);
    }



    public static Ball getBall(String id) {
        Ball ball = ballMap.get(id);
        return (Ball) ball.clone();
    }
}

public class Client {
    public static void main(String[] args) {

        Badminton badminton1 = (Badminton) BallCache.getBall("2");
        Basketball basketball1 = (Basketball) BallCache.getBall("1");
        TableTennis tableTennis1 = (TableTennis) BallCache.getBall("3");

        badminton1.show();
        basketball1.show();
        tableTennis1.show();

        Badminton badminton2 = (Badminton) BallCache.getBall("2");
        Basketball basketball2 = (Basketball) BallCache.getBall("1");
        TableTennis tableTennis2 = (TableTennis) BallCache.getBall("3");

        badminton2.show();
        basketball2.show();
        tableTennis2.show();

        System.out.println(badminton1.equals(badminton2));
        System.out.println(basketball1.equals(basketball2));
        System.out.println(tableTennis1.equals(tableTennis2));
    }
}

羽毛球呀
篮球呀
乒乓球呀
羽毛球呀
篮球呀
乒乓球呀
false
false
false

​ 好啦，希望本篇文章有助你了解原型模式，孙悟空猴毛变出的小猴子，到底是不是使用的原型模式呢？下方留言告诉我！

愿每个人都能带着怀疑的态度去阅读文章并探究其中原理。

道阻且长，往事作序，来日为章。

期待我们下一次相遇！