java设计模式－－－创建者模式

GOF(23种设计模式)分为三大类：

创建型模式：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式

结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式

行为模式：模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

一、创建者模式：都是用来帮助我们创建对象的

１．单例模式

　　保证一个类只有一个实例，并且提供一个访问该实例的全局访问点。

优点：

１）由于单例模式只生成一个实例，减少了系统性能的开销，当一个对象的产生需要比较多的资源时，如读取配置、产生其他依赖对象时，则可以通过在应用启动时产生一个单例对象，然后永久驻留内存的方式来解决。

２）由于单例模式可以在系统设置全局的访问点，优化环境共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

常见五种单例模式实现方式：

１）饿汉式（线程安全，调用效率高。但是，不能延时加载。）

/*
 * 测试饿汉式单例模式
 * */
public class SingletonDemo1 {
    //声明私有静态属性，同时创建对象
    //类初始化时，就会加载这个对象(没有延时加载的优势)!
    // 由于加载类时，天然的是线程安全的
    private static SingletonDemo1 instance = new SingletonDemo1();
    //构造器私有化
    private SingletonDemo1() {
    }
    //创建一个对外公开的静态方法访问该静态变量
    //方法没有同步调用效率高
    public static SingletonDemo1 getInstance() {
        return instance;
    }
}

２）懒汉式（线程安全，调用效率不高。但是，可以延时加载。）

/*
 * 测试懒汉式单例模式
 * */
public class SingletonDemo2 {
    //声明私有静态属性
    private static SingletonDemo2 instance;
    //构造器私有化
    private SingletonDemo2() {

    }
    //创建一个对外公开的静态方法访问该静态变量
    //延时加载，懒加载，真正用的时候才加载
    //资源效率高了，但是并发时调用效率较低。
    // 因为方法synchronized同步，并发时需要等待调用getInstance()方法
    public static synchronized SingletonDemo2 getInstance() {
        if (null == instance) {
            instance = new SingletonDemo2();
        }
        return instance;
    }
}

３）双重检测锁式（由于编译器优化原因和JVM底层内部模型原因，偶尔会出问题，不建议使用）

/*
 * 双重检测锁实现单例模式
 * */
public class SingletonDemo3 {
    private static SingletonDemo3 instance = null;

    private SingletonDemo3() {

    }

    public static SingletonDemo3 getInstance() {
        if (instance == null) {
            SingletonDemo3 sc;
            synchronized (SingletonDemo3.class) {
                sc = instance;
                if (sc == null) {
                    synchronized (SingletonDemo3.class) {
                        if (sc == null) {
                            sc = new SingletonDemo3();
                        }
                    }
                    instance = sc;
                }
            }
        }
        return instance;
    }
}

４）静态内部类式（线程安全，调用效率高，但是，可以延时加载）

/*
* 静态内部类实现单例模式（也是一种懒加载方式）
* 外部类没有static属性，则不会像饿汉式那样立即加载对象
* */
public class SingletonDemo4 {
    private SingletonDemo4() {

    }
    private static class SingletonClassIntance{
        private static final SingletonDemo4 instance = new SingletonDemo4();
    }
  　//只有真正调用了getInstance()才会加载静态内部类。
    　//加载类是线程安全的。
    　// instance是static final类型，保证了内存中只有一个这样的实例存在，而且只能被赋值一次，从而保证了线程安全性。
    　//兼并了并发高效调用和延迟加载的优势
    　public static SingletonDemo4 getInstance() {
        return SingletonClassIntance.instance;
    }
}

５）枚举单例（线程安全，调用效率高。但是，不能延时加载。）

优点：<1>实现简单

　　　<2>枚举本身就是单例模式。由JVM从根本上提供保证！避免通过反射和反序列化的漏洞

缺点：无延时加载

/*
 * 使用枚举实现单例模式 枚举类天然是单例的
 * 没有延时加载
 * */
public enum SingletonDemo5 {
    //定义一个枚举元素，本身就是单例对象，它就代表了Singleton的一个实例
    INSTANCE;
    //单例可以有自己的操作
    public void SingletonOperation() {
        //功能处理
    }
}

２．如何选用？

单例对象　占用资源少，不需要　延时加载

　　　　枚举式　好于　饿汉式

单例对象　占用资源大，需要　延时加载

　　　　静态内部类　好于　懒汉式

问题：

１）反射可以破解上面几种（不包含枚举式）实现方式（可以在构造方法中手动抛出异常控制）

SingletonDemo6 s1 = SingletonDemo6.getInstance();
SingletonDemo6 s2 = SingletonDemo6.getInstance();

System.out.println(s1);
System.out.println(s2);

//通过反射的方式直接调用私有构造器
Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("cn.hyy.test.pattern.singlePattern.SingletonDemo6");
Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
c.setAccessible(true);
SingletonDemo6 s3 = c.newInstance();
SingletonDemo6 s4 = c.newInstance();

System.out.println(s3);
System.out.println(s4);

在构造方法中手动抛出异常控制

/*
* 测试懒汉式单例模式（如何防止反射和反序列化漏洞）
* */
public class SingletonDemo6 {
    //声明私有静态属性
    private static SingletonDemo6 instance;
    //构造器私有化
    private SingletonDemo6() {
        if (instance != null) {
            throw new RuntimeException();
        }
    }
    //创建一个对外公开的静态方法访问该静态变量
    //延时加载，懒加载，真正用的时候才加载
    //资源效率高了，但是并发时调用效率较低。
    // 因为方法synchronized同步，并发时需要等待调用getInstance()方法
    public static synchronized SingletonDemo6 getInstance() {
        if (null == instance) {
            instance = new SingletonDemo6();
        }
        return instance;
    }

}

２）反序列化可以破解上面几种（不包含枚举式）实现方式

　　　可以通过定义readResolve()防止获得不同对象

　　　　－－反序列化时，如果对象所在类定义了readResolve()，（实际是一种回调），定义返回哪个对象。

//通过反序列化方式构造多个对象
FileOutputStream fos = new FileOutputStream("/home/deepin/Desktop/test/aa.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
oos.writeObject(s1);
oos.close();
fos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream("/home/deepin/Desktop/test/aa.txt"));
SingletonDemo6 s3 = (SingletonDemo6) ois.readObject();
System.out.println(s3);

/*
* 测试懒汉式单例模式（如何防止反射和反序列化漏洞）
* */
public class SingletonDemo6 implements Serializable {
   //声明私有静态属性
    private static SingletonDemo6 instance;
   //构造器私有化
    private SingletonDemo6() {
        if (instance != null) {
            throw new RuntimeException();
        }
    }
  //创建一个对外公开的静态方法访问该静态变量
    //延时加载，懒加载，真正用的时候才加载
    //资源效率高了，但是并发时调用效率较低。
    // 因为方法synchronized同步，并发时需要等待调用getInstance()方法
    public static synchronized SingletonDemo6 getInstance() {
        if (null == instance) {
            instance = new SingletonDemo6();
        }
        return instance;
    }

 //反序列化时，如果定义了readResolve()，则直接返回此方法指定的对象。而不需要单独再创建对象!
 public Object readResolve() throws ObjectStreamException {
       return instance;
    }
}

多线程环境下五种创建单例模式的效率

CountDownLatch

      同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待

　  countDown()　当前线程调此方法，则计数减一（建议放在finally里执行）

       await(),调用此方法会一直阻塞当前线程，直到计时器的值为０

/*
 * 测试多线程环境下五种创建单例模式的效率
 * */
public class Client3 {

    public static void main(String[] args) throws InterruptedException {

        long start = System.currentTimeMillis();
        CountDownLatch countDownLatch =  new CountDownLatch(10);

        for (int i = 0; i <10 ; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 1000000; i++) {
                        Object o = SingletonDemo2.getInstance();
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();  //main线程阻塞，直到计数器变为０，才会继续往下执行
       　　　 long end = System.currentTimeMillis();
        System.out.println("总耗时:" + (end - start)+"秒");
    }
}

2.工厂模式

实现了创建者和调用者的分离

详细分类：

　　１）简单工厂模式

　　２）工厂方法模式

　　３）抽象工厂模式

面向对象设计的六大基本原则：

　　SRP（单一职责原则，Single Responsibility Principle）:就一个类而言，应该仅有一个引起它变化的原因。简单来说，一个类中应该是一组相关性很高的函数、数据的封装。

　　OCP(开闭原则，Open-Closed Principle):一个软件的实体应当对扩展开放，对修改关闭

         LSP(里式替换原则，Liskov Substitution Principle):所有引用基类的地方必须能透明地使用其子类的对象。通俗点讲，只要父类能出现的地方子类就可以出现，而且替换为子类也不会产生任何错误或异常，使用者可能根本就不需要知道是父类还是子类。但是，反过来就不行了，有子类出现的地方，父类未必就能适应。

　    DIP(依赖倒转原则，Dependence Inversion Principle):要针对接口编程，不要针对实现编程

　    ISP（接口隔离原则，Interface Segregation Principles):客户端不应该依赖它不需要的接口

         LoD(迪米特法则，Law of Demeter):只与你直接的朋友通信，而避免和陌生人通信

１）简单工厂模式

            也叫静态工厂模式，就是工厂类一般使用静态方法，通过接收的系数的不同来返回不同的对象实例。

　　　对于增加新产品无能为力！不修改代码的话，是无法扩展的（违反开闭原则）

public interface Car {
    void run();
}

public class Audi implements Car {

    @Override
    public void run() {
        System.out.println("奥迪在跑");
    }
}

public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪在跑");
    }
}

<1>没有简单工厂的情况下

/*
* 没有工厂模式的情况下
* */
public class Client01 {
    public static void main(String[] args) {
        Car c1 = new Audi();
        Car c2 = new Byd();

        c1.run();
        c2.run();
    }
}

UML类图

<2>在有简单工厂的情况下，调用者只需要和工厂打交道

public class CarFactory{
    public static Car createCar(String type) {
        if ("奥迪".equals(type)) {
            return new Audi();
        } else if ("比亚迪".equals(type)) {
            return new Byd();
        } else {
            return null;
        }
    }
}

或者

public class CarFactory2 {
    public static Car createAudi() {
        return new Audi();
    }

    public static Car createByd() {
        return new Byd();
    }
}

UML类图

２）工厂方法模式

　－－为了避免简单工厂的缺点，不完全满足OCP

   －－工厂方法模式和简单工厂模式最大不同完全在于，简单工厂模式只有一个（对应一个项目或者独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

public interface Car {
    void run();
}

public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奥迪在跑");
    }
}

public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪在跑");
    }
}

public class Benz implements Car {
    @Override
    public void run() {
        System.out.println("奔驰在跑");
    }
}

public interface CarFactory {
    Car createCar();
}

public class AudiFactory implements CarFactory {
    @Override
    public Car createCar() {
        return  new Audi();
    }
}

public class BydFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Byd();
    }
}

public class BenzFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new Benz();
    }
}

public class Client {
    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();
        c1.run();
        c2.run();
    }
}

简单工厂模式和工厂方法模式比较：

１>结构复杂度

　　简单工厂模式占优，简单工厂模式只需要一个工厂类，而工厂方法模式的工厂类会随着产品类的个数增加而增加，从而增加了结构复杂度。

2>代码复杂度

　　代码复杂度和结构复杂度是一对矛盾。简单工厂模式在结构方面相对简洁，那么在代码方面肯定比工厂方法模式复杂的了。简单工厂模式的工厂类会随着产品类的个数增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁

3>客户端编程难度

　　工厂方法模式虽然在工厂类结构中引入接口从而满足了OCP,但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点。

4>管理上的难度

这是个关键的问题

　　首先先谈扩展，工厂方法模式完全满足OCP，即它有非常良好的的扩展性。那是否说明了简单工厂模式就没有扩展性了呢？答案是否定的，简单工厂模式同样具备良好的扩展性－－扩展的时候仅需要修改少量代码（修改工厂类的代码）就可以满足扩展性的要求了，尽管没有完全满足OCP，但我们不需要太拘泥于设计理论。

　　然后从维护性的角度分析下，假如某个具体产品类需要进行一定的修改，很可能需要修改对应的工厂类。当同时需要修改多个产品类的时候，对工厂类的修改变得相当麻烦。反而简单工厂模式没有这些麻烦，当多个产品类需要修改时，简单工厂模式仍然仅仅需要修改唯一的工厂类

根据设计理论建议：工厂方法模式，但实际上，我们一般都用简单工厂模式

３）抽象工厂模式

－－用来生产不同产品族的全部产品（对于新增加的产品，无能为力；支持增加产品族）

－－抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务、分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

public interface Engine {
    void run();

    void start();
}

class LuxuryEngine implements Engine {

    @Override
    public void run() {
        System.out.println("转得快");
    }

    @Override
    public void start() {
        System.out.println("启动快，可以自动启停");

    }
}
class LowEngine implements Engine {

    @Override
    public void run() {
        System.out.println("转得慢");
    }

    @Override
    public void start() {
        System.out.println("启动慢");

    }
}

public interface Seat {
    void massage();
}

class LuxurySeat implements Seat {

    @Override
    public void massage() {
        System.out.println("可以自动按摩");
    }
}
class LowSeat implements Seat {

    @Override
    public void massage() {
        System.out.println("不能按摩");
    }
}

public interface Tyre {
    void revolve();
}

class LuxuryTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋转不磨损");
    }
}

class LowTyre implements Tyre {

    @Override
    public void revolve() {
        System.out.println("旋转磨损快");
    }
}

public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}

public class LuxuryCarFactory implements CarFactory {

    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }

    @Override
    public Seat createSeat() {
        return new LuxurySeat();
    }

    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}

public class LowCarFactory implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LowEngine();
    }

    @Override
    public Seat createSeat() {
        return new LowSeat();
    }

    @Override
    public Tyre createTyre() {
        return new LowTyre();
    }
}

public class Client {
    public static void main(String[] args) {
        CarFactory factory = new LuxuryCarFactory();
        Engine e = factory.createEngine();
        Seat seat = factory.createSeat();
        Tyre tyre = factory.createTyre();
        e.run();
        e.start();

        CarFactory factory1 = new LowCarFactory();
        Engine e1 = factory1.createEngine();
        e1.run();
        e1.start();

    }
}

3.建造者模式

本质：

　－－分离对象子组件的单独构造（由Buider来负责）和装配（由Director负责）。从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况下使用。

　－－由于实现构造和装配的解耦。不同的构造器，相同的装配，也可以做出不同的对象；相同的构造器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。

public class AirShip {
    private OrbitalModule orbitalModule;//轨道舱
    private Engine engine;   //发动机
    private EscapeTower escapeTower; //逃逸塔

    public void launch() {
        System.out.println("发射");
    }

    public OrbitalModule getOrbitalModule() {
        return orbitalModule;
    }

    public void setOrbitalModule(OrbitalModule orbitalModule) {
        this.orbitalModule = orbitalModule;
    }

    public Engine getEngine() {
        return engine;
    }

    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public EscapeTower getEscapeTower() {
        return escapeTower;
    }

    public void setEscapeTower(EscapeTower escapeTower) {
        this.escapeTower = escapeTower;
    }
}

class OrbitalModule{
    private String name;

    public OrbitalModule(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

class Engine{
    private String name;

    public Engine(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

class EscapeTower {
    private String name;

    public EscapeTower(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

public interface AirShipBuider {

    Engine buiderEngine();

    OrbitalModule buiderOrbitalModule();

    EscapeTower buiderEscapeTower();
}

public class SxtAirShipBuider implements AirShipBuider {

    @Override
    public Engine buiderEngine() {
        System.out.println("构建发动机");
        return new Engine("尚学堂牌发动机");
    }

    @Override
    public OrbitalModule buiderOrbitalModule() {
        System.out.println("构建轨道舱");
        return new OrbitalModule("尚学堂牌轨道舱");
    }

    @Override
    public EscapeTower buiderEscapeTower() {
        System.out.println("构建逃逸塔");
        return new EscapeTower("尚学堂牌逃逸塔");
    }
}

public interface AirShipDirector {
    AirShip directorAirShip();  //组装飞船对象
}

public class SxtAirShipDirector implements AirShipDirector {

    private AirShipBuider buider;

    public SxtAirShipDirector(AirShipBuider buider) {
        this.buider = buider;
    }

    @Override
    public AirShip directorAirShip() {

        Engine e=buider.buiderEngine();
        OrbitalModule o=buider.buiderOrbitalModule();
        EscapeTower et = buider.buiderEscapeTower();
        //装配成飞船
        　　　AirShip ship = new AirShip();
        ship.setEngine(e);
        ship.setEscapeTower(et);
        ship.setOrbitalModule(o);
        return ship;
    }
}

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

        AirShipDirector director = new SxtAirShipDirector(new SxtAirShipBuider());
        AirShip ship = director.directorAirShip();
        System.out.println(ship.getEngine().getName());
        System.out.println(ship.getEscapeTower().getName());
        System.out.println(ship.getOrbitalModule().getName());
        ship.launch();
    }
}

４．原型模式

－－通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

－－就是java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点

－－优势有：效率高（直接克隆，避免了重新执行构造过程步骤。）

－－克隆类似于new，但是不同于new。new创建新的对象属性采用的是默认值。克隆出的对象的属性完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后再修改克隆对象的值。

１>原型模式的实现

－－Cloneable接口和clone方法

－－Prototype模式中实现起来最困难的地方就是内存复制操作，所幸在java中提供了clone()方法替我们做了绝大部分事情

2>浅复制

public class Sheep implements Cloneable {
    private String sname;
    private Date birthday;

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Sheep(String sname, Date birthday) {
        this.sname = sname;
        this.birthday = birthday;
    }

    public Sheep() {

    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();//直接调用object对象的clone()方法
        return obj;
    }
}

/*
* 测试原型模式(浅克隆)
* */
public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        Date date= new Date(1222232);
        Sheep s1 = new Sheep("少利", date);
        Sheep s2 = (Sheep) s1.clone();
        System.out.println(s1);
        System.out.println(s1.getSname());
        System.out.println(s1.getBirthday());
        date.setTime(556344552);　//修改出生日期，也会修改s2的出生日期
        System.out.println(s1.getBirthday());


        s2.setSname("多利");
        System.out.println(s2);
        System.out.println(s2.getSname());
        System.out.println(s2.getBirthday());
    }
}

3>深复制

public class Sheep2 implements Cloneable {
    private String sname;
    private Date birthday;

    public String getSname() {
        return sname;
    }

    public void setSname(String sname) {
        this.sname = sname;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public Sheep2(String sname, Date birthday) {
        this.sname = sname;
        this.birthday = birthday;
    }

    public Sheep2() {

    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();//直接调用object对象的clone()方法
                   //添加如下代码实现深复制
                   Sheep2 s = (Sheep2) obj;
        s.birthday = (Date) this.birthday.clone();//把属性也进行克隆
                  return obj;
    }
}

/*
* 原型模式（深复制）
* */
public class Client2 {
    public static void main(String[] args) throws CloneNotSupportedException {

        Date date= new Date(1222232);
        Sheep2 s1 = new Sheep2("少利", date);
        Sheep2 s2 = (Sheep2) s1.clone(); //实现深复制，s2对象的birthday是一个新对象
                  System.out.println(s1);
        System.out.println(s1.getSname());
        System.out.println(s1.getBirthday());
        date.setTime(556344552); //此时不会修改s2的出生日期
        System.out.println(s1.getBirthday()); 

                  s2.setSname("多利");
        System.out.println(s2);
        System.out.println(s2.getSname());
        System.out.println(s2.getBirthday());

    }
}

4>使用序列化和反序列化实现深复制

－－在Sheep类记得实现Serializable接口

/*
 * 原型模式（深复制,使用序列化和反序列化的方式实现深复制）
 * */
public class Client3 {
    public static void main(String[] args) throws IOException, ClassNotFoundException {

        Date date= new Date(1222232);
        Sheep s1 = new Sheep("少利", date);
        System.out.println(s1);
        System.out.println(s1.getSname());
        System.out.println(s1.getBirthday());

        //使用序列化和反序列化的方式实现深复制
                   ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);

        oos.writeObject(s1);
        byte[] bytes = bos.toByteArray();

        ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
        ObjectInputStream ois = new ObjectInputStream(bis);

        Sheep s2 = (Sheep) ois.readObject();

        date.setTime(556344552);//修改出生日期，也会修改s2的出生日期
                  System.out.println(s1.getBirthday());


        s2.setSname("多利");
        System.out.println(s2);
        System.out.println(s2.getSname());
        System.out.println(s2.getBirthday());
    }
}

５＞new方式创建对象和clone方式创建对象的效率差异

/*
* 测试普通new方法创建对象和clone方式创建对象的效率差异
* 如果需要短时间创建大量对象，并且new的过程比较耗时。则可以考虑使用原型模式！
* */
public class Client4 {

    public static void testNew(int size) {
        long start = System.currentTimeMillis();
        for (int i = 0; i < size; i++) {
            Laptop t = new Laptop();
        }

        long end = System.currentTimeMillis();
        System.out.println("new方式创建耗时:"+(end-start));
    }

    public static void testClone(int size) throws CloneNotSupportedException {
        long start = System.currentTimeMillis();
        Laptop t = new Laptop();
        for (int i = 0; i < size; i++) {
            Laptop temp = (Laptop) t.clone();
        }

        long end = System.currentTimeMillis();
        System.out.println("clone方式创建耗时:" + (end - start));
    }


    public static void main(String[] args) throws CloneNotSupportedException {
        testNew(1000);
        testClone(1000);

    }

}

class Laptop implements Cloneable{  //笔记本电脑
    public Laptop() {

        try {
            Thread.sleep(10);  //模拟创建对象耗时的过程
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();//直接调用object对象的clone()方法
        return obj;
    }
}

开发中的应用场景：

－－原型模式很少单独出现，一般是和工厂方法模式一起出现。通过clone的方法创建一个对象，然后由工厂方法提供给调用者

　　spring中bean的创建实际就是两种：单例模式和原型模式。（当然原型模式需要和工厂模式搭配起来）