前言

昨天讲了六大原则，今天就进入设计模式的正题了。

思维导图

创建型设计模式，顾名思义就是与对象的创建相关。

单例模式

定义：保证一个类仅有一个实例，并提供用于一个访问它的全局访问点。

5种写法及其优缺点

(1) 饿汉模式

public class Singleton {
    private static Singleton instance = new Singleton();

    public static Singleton getInstance(){
        return instance;
    }
}

在类加载时就已经完成了初始化。
优点：1. 保障了线程同步的问题；2. 获取对象的效率高。
缺点：1. 降低了类加载时速度；2. 如果一直不使用，会内存的浪费。

(2) 懒汉模式

1. 线程不安全

   public class Singleton {
    private static Singleton instance;
   
    public static Singleton getInstance(){
        if(instance == null) instance = new Singleton();
        return instance;
    }
   }

   缺点：存在线程同步问题

2. 线程安全

   public class Singleton {
    private static Singleton instance;
   
    public static synchronized Singleton getInstance(){
        if(instance == null) instance = new Singleton();
        return instance;
    }
   }

   缺点：每一次都需要同步，存在一定的开销问题。

懒汉模式相较于饿汉模式，不会存在不使用的问题。虽然不再在加载时消耗资源，但是实例化时同样会有一定的时间开销。
(3) 双重检查模式/DCL

public class Singleton {
    private volatile static Singleton instance;

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

使用volatile关键词是对正确性的一种保障。
相较于懒汉模式而言，这又是一种升级。因为不在将synchronized套在了函数上，也就不会每次调用都对整个函数同步了，提高了资源的利用率。但是同样存在失效的情况。

失效案例

(4) 静态内部类单例模式

public class Singleton {

    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }

    private static class SingletonHolder {
        private volatile static Singleton instance = new Singleton();
    }
}

这是最常用的方法，也是对DCL的一种升级。
优缺点和前面都差不多，就不再复述了。
(5) 枚举单例模式

public enum  Singleton {
    INSTANCE;  
}

这是一种一般不常用的方法，但是能够保障线程同步。

简单工厂模式

定义：又称静态工厂模式，是由一个工厂对象决定创建出那一种产品类的实例。

既然是一个工厂就举一个工厂的例子。
一般来说的工厂模式都是这样的： 客户 --> 工厂 --> 产品
所以产生了三个类

/**
 * 工厂类
 */
public class Factory {
    public static Product product(String type){
        Product product = null;
        switch (type){
            case "鸡翅":
                product = new ChickenWing();
                break;
            case "汉堡":
                product = new Hamburger();
                break;
        }
        return product;
    }
}

/**
 * 抽象产品类
 */
public abstract class Product {
    public abstract void finish();
}

/**
 * 具体产品类
 */
public class Hamburger extends Product {
    @Override
    public void finish() {
        System.out.println("汉堡制作完成");
    }
}

public class ChickenWing extends Product {
    @Override
    public void finish() {
        System.out.println("鸡翅制作完成");
    }
}

三个类已经完成了对应，就跟你在肯德基吃饭一样，告诉他一个名字，他就开始生产。

优点：根据参数获得实例，降低了耦合度。
缺点：不利于扩展功能，因为工厂从一开始就知道能加载的有什么。
使用场景：(1) 工厂负责创建的对象较少；(2)客户只需要知道想要什么，不用关心怎么生成的时候。

工厂方法模式

定义：定义一个用于创建对象的接口，让子类决定实例化哪个类。工厂方法将类的实例化放到子类中实现。

工厂模式中的四个角色：

1. Product：产品抽象类
2. Factory：工厂抽象类，返回Product对象
3. ConcreteProduct：具体产品类
4. ConcreteFactory：具体工厂类
   其实就是对简单工厂方法的一种升级，因为在简单工厂方法中，只有产品这一层被抽象出来了。而工厂方法是把工厂也抽象出来。
   所以以下代码是对简单工厂方法的一种改进。

   /**
   * 抽象工厂类
   */
   public abstract class Factory {
    public abstract <T extends Product> T  product(Class<T> clazz);
   }
   

/**

• 具体工厂类
• /
  public class KFC extends Factory {
  @Override
  public <t extends="" product=""> T product(Class<t> clazz) {

    Product product = null;
    try{
        product = (Product) Class.forName(clazz.getName()).newInstance();
    }catch (Exception e){
        e.printStackTrace();
    }
    return (T) product;

  }
  }

  使用反射机制，也就解决了简单工厂中分支可能存在增加的问题了。
  

  </t></t>

建造者模式

讲一个复杂对象的构建与它的表示分离，使同样的构建过程可以创建不同的表示。

四个角色：

1. Director：导演类，将工作按顺序完成。

2. Builder：生成抽象类，生产产品的模版，具体操作由子类完成。

3. ConcreteBuilder：生成具体类。

4. Product：产品类。
   跟简单工厂不一样，这一次的主角变成了肯德基里服务的店员们了，他们负责完成汉堡制作的各项流程，而Builder只是说明要干什么事情。

   /**
   * 导演类
   */
   public class Director {
    Builder builder;
   
    Director(Builder builder){
        this.builder = builder;
    }
   
    public Hamburger create(String meat, String vegetable, String bread){
        builder.cookBread(bread);
        builder.cookMeat(meat);
        builder.cookVegetable(vegetable);
        return builder.finish();
    }
   }
   

/**

• Builder抽象类
• /
  public abstract class Builder {
  public abstract void cookMeat(String meat);
  public abstract void cookBread(String bread);
  public abstract void cookVegetable(String vegetable);
  public abstract Hamburger finish();
  }

/**

• Builder类

• /
  public class ChickenHamburgerBuilder extends Builder{

  private Hamburger hamburger = new Hamburger();

  @Override
  public void cookMeat(String meat) {

    hamburger.setMeat(meat);

  }

  @Override
  public void cookBread(String bread) {

    hamburger.setBread(bread);

  }

  @Override
  public void cookVegetable(String vegetable) {

    hamburger.setVegetable(vegetable);

  }

  @Override
  public Hamburger finish() {

    return hamburger;

  }
  }

/**

• 产品类

• /
  public class Hamburger {
  private String vegetable;
  private String meat;
  private String bread;

  // 以下省略Getter 和 Setter方法
  }
  ```