GOF23-创建模型式

都是用来帮助我们创建对象的！！！！

01.单例模式

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

1.饿汉式

public class SingletonDemo1 {
    //类初始化立即加载
    private static /*final*/ SingletonDemo1 instance = new SingletonDemo1();

    //私有构造器
    private SingletonDemo1() {
    }

    //方法没有同步，调用效率高
    public static SingletonDemo1 getInstance() {
        return instance;
    }
}

2.懒汉式 延迟加载

public class SingletonDemo2 {
    //类初始化时，不初始化对象，延迟加载
    private static SingletonDemo2 instance;

    //私有构造器
    private SingletonDemo2() {
    }

    //方法同步，调用效率低
    public static synchronized SingletonDemo2 getInstance() {
        if(instance==null){
            instance=new SingletonDemo2();
        }
        return instance;
    }
}

3.双重检测锁实现

/*
双重检测锁实现  由于JVM底层内部原因 偶然会出问题
 */
public class SingletonDemo3 {
    //类初始化时，不初始化对象
    private static SingletonDemo3 instance = null;

    //私有构造器
    private SingletonDemo3() {
    }

    /*
    这个模式将同步内容下方到if内部，提高了执行的效率，
    不必每次获取对象时都进行同步，
    只有第一次才同步，创建了以后就没有必要了
     */
    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;
    }
}

4.静态内部类实现

/*
单例模式：
静态内部类实现（是一种懒加载）
 */
public class SingletonDemo4 {
    //类初始化延迟加载
    private static class SinglentonClassInstance{

    private static /*final*/ SingletonDemo4 instance = new SingletonDemo4();
    }

    //私有构造器
    private SingletonDemo4() {
    }

    //方法没有同步，调用效率高
    public static SingletonDemo4 getInstance() {
        return SinglentonClassInstance.instance;
    }
}

5.枚举单例

/*
单例模式：
枚举单例(没有延迟加载)
 */
public enum  SingletonDemo5 {

    //枚举本身就是天然的单例
    INSTANCE;

    //添加自己需要的操作
    public void singletonOperation(){

    }
}

6.测试消耗时间

import java.util.concurrent.CountDownLatch;
/*
测试消耗的时间
 */
public class Client3 {
    public static void main(String[] args) throws InterruptedException {
        long l = System.currentTimeMillis();
        //同步辅助类  countDown()计数减一   await() 阻塞
        int num = 10;
        final CountDownLatch countDownLatch = new CountDownLatch(num);

        for (int i = 0; i < num; i++) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000000; i++) {
                        //Object instance = SingletonDemo4.getInstance();
                        Object instance = SingletonDemo5.INSTANCE;
                    }
                    countDownLatch.countDown();
                }
            }).start();
        }
        countDownLatch.await();
        long l2 = System.currentTimeMillis();
        System.out.println("时间：" + (l2 - l));
    }
}
测试时间：
饿汉：20
懒汉：3837
双重检测：20
静态：40
枚举：10

02.工厂方法模式

1.简单工厂

虽然某种情况不符合设计原则，但实际使用最多

//接口
public interface Car {
    void run();
}
//1简单工厂类
public class CarFactory {
    public Car createCar(String type){
        if("奥迪".equals(type)){
            return new Audi();
        }else if ("比亚迪".equals(type)){
            return new Byd();
        }else {
            return null;
        }
    }
}
//2简单工厂类(静态工厂模式)
public class CarFactory2 {
    public static Car createAudi() {
        return new Audi();
    }
    public static Car createByd() {
        return new Byd();
    }
}
//实现方法
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 Client01 {
    public static void main(String[] args) {
        
/*      Car c1 = new Audi();
        Car c2 = new Byd();
        c1.run();
        c2.run();*/
        
        Car c1 = new CarFactory().createCar("比亚迪");
        Car c2 = new CarFactory().createCar("奥迪");
        c1.run();
        c2.run();
    }
}
代码效果：
比亚迪在跑！
奥迪再跑！

2.工厂方法

不改变以有内的前提，通过增加新的工厂类实现扩展

//工厂模式
public interface Car {
    void run();
}
public class Audi implements Car {
    @Override
    public void run() {
        System.out.println("奥迪再跑！");
    }
}
public class Benz implements Car{
    @Override
    public void run() {
        System.out.println("奔驰在跑！");
    }
}
public class Byd implements Car {
    @Override
    public void run() {
        System.out.println("比亚迪在跑！");
    }
}
//工厂方法模式
public interface CarFactory03 {
    Car createCar();
}
public class AudiFactory implements CarFactory03{
    @Override
    public Car createCar() {
        return new Audi();
    }
}
public class BenzFactory implements CarFactory03{
    @Override
    public Car createCar() {
        return new Benz();
    }
}
public class BydFactory implements CarFactory03{
    @Override
    public Car createCar() {
        return new Byd();
    }
}

public class Client01 {
    public static void main(String[] args) {
        Car c1 = new AudiFactory().createCar();
        Car c2 = new BydFactory().createCar();
        Car c3 = new BenzFactory().createCar();

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

代码效果：
奥迪再跑！
比亚迪在跑！
奔驰在跑！

03.抽象工厂模式

抽象工厂：不可以增加产品，可以增加产品族

public interface CarFactory {
    Engine createEngine();
    Seat createSeat();
    Tyre createTyre();
}
//发动机接口
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 class LowCarFactoy 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 LuxuryCarFactoy implements CarFactory {
    @Override
    public Engine createEngine() {
        return new LuxuryEngine();
    }
    @Override
    public Seat createSeat() {
        return new LowSeat();
    }
    @Override
    public Tyre createTyre() {
        return new LuxuryTyre();
    }
}
//抽象工厂：不可以增加产品，可以增加产品族
public class Client {
    public static void main(String[] args) {
        CarFactory fa = new LowCarFactoy();
        Engine e = fa.createEngine();
        e.run();
        e.start();
    }
}
代码效果：
转的慢！
启动慢，可以自动停止！

04.建造者模式

分离了对象子组件的单独构造（由Builder来负责）和装配（有由Director负责）。从而可以构造出复杂的对象

public interface AirShipBuilder {
    Engine builderEngine();
    OrbitalModule builderOrbitalModule();
    EscapeTower builderEscapeTower();
}
public interface AirShipDirector {
    //组装飞船对象
    AirShip directAirShip();
}
//飞船
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 class SxtAirShipBuilder implements AirShipBuilder{
    @Override
    public Engine builderEngine() {
        System.out.println("构建发动机！");
        return new Engine("发动机");
    }
    @Override
    public OrbitalModule builderOrbitalModule() {
        System.out.println("构建轨道舱！");
        return new OrbitalModule("轨道舱");
    }
    @Override
    public EscapeTower builderEscapeTower() {
        System.out.println("构建逃逸塔");
        return new EscapeTower("逃逸塔");
    }
}
//装配
public class SxtAirshipDirector implements AirShipDirector{
    private AirShipBuilder builder;
    public SxtAirshipDirector(AirShipBuilder builder){
        this.builder = builder;
    }
    @Override
    public AirShip directAirShip() {
        Engine e = builder.builderEngine();
        OrbitalModule o = builder.builderOrbitalModule();
        EscapeTower et = builder.builderEscapeTower();
        //组装成飞船对象
        AirShip ship = new AirShip();
        ship.setEngine(e);
        ship.setEscapeTower(et);
        ship.setOrbitalModule(o);
        return ship;
    }
}
public class Client {
    public static void main(String[] args) {
        SxtAirshipDirector director = new SxtAirshipDirector(new SxtAirShipBuilder());
        AirShip ship = director.directAirShip();
        System.out.println(ship.getEngine().getName());
        ship.launch();
    }
}
效果：
构建发动机！
构建轨道舱！
构建逃逸塔
发动机
发射！

05.原型模式

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

import java.io.Serializable;
import java.util.Date;
//prototype 原型模式
public class Sheep implements Cloneable, Serializable {
    private String name;
    private Date birthday;
    @Override
    protected Object clone() throws CloneNotSupportedException {
        Object obj = super.clone();//直接调用object对象的clone()方法！
/*        //深复制
        Sheep s = (Sheep)obj;
        s.birthday = (Date) this.birthday.clone();*/
        return obj;
    }
    public Sheep(String nsme, Date birthday) {
        this.name = nsme;
        this.birthday = birthday;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
}
public class Client {
    public static void main(String[] args) throws Exception {
        Date date = new Date(12112352213L);
        Sheep s1 = new Sheep("少你",date);
        Sheep s2 = (Sheep)s1.clone();
        System.out.println(s1);
        System.out.println(s1.getName());
        System.out.println(s1.getBirthday());
        date.setTime(1256422122222L);
        System.out.println(s1.getBirthday());

        //Sheep s2 = (Sheep)s1.clone();
        s2.setName("duli");
        System.out.println(s2);
        System.out.println(s2.getName());
        System.out.println(s2.getBirthday());
    }
}
效果：
job01.gof05.Sheep@73035e27
少你
Thu May 21 12:32:32 CST 1970
Sun Oct 25 06:08:42 CST 2009
job01.gof05.Sheep@3f2a3a5
duli
Sun Oct 25 06:08:42 CST 2009

//使用序列化和反序列化实现深复制
public class Client2 {
    public static void main(String[] args) throws Exception {
        Date date = new Date(12112352213L);
        Sheep s1 = new Sheep("少你",date);
        System.out.println(s1);
        System.out.println(s1.getName());
        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();//克隆对象
        System.out.println("修改");
        date.setTime(12456455555L);

        System.out.println(s1.getBirthday());
        s2.setName("duli");
        System.out.println(s2);
        System.out.println(s2.getName());
        System.out.println(s2.getBirthday());
    }
}
效果：
job01.gof05.Sheep@73035e27
少你
Thu May 21 12:32:32 CST 1970
修改
Mon May 25 12:07:35 CST 1970
job01.gof05.Sheep@20e2cbe0
duli
Thu May 21 12:32:32 CST 1970