创建者模式关注的点是 "怎样创建对象"，他的主要特点是 "将对行的使用和创建与使用进行分离"，这样做的好处是可以降低系统的耦合度，使用者不需要关系对象的创建细节

单例模式

单例模式又分成饿汉式和懒汉式

饿汉式

饿汉式：在类加载的时候就会被创建

//饿汉式
public class Singleton {
    //1.私有化构造方法
    private Singleton() { }
    //2.在本类中创建本类的对象
    private static Singleton instance = new Singleton();
    //3.提供公共方法进行访问
    public static Singleton getInstance(){
        return instance;
    }
}
//这是测试方法
public class Client {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
    }
}

懒汉式

在首次使用该对象的时候才会创建实例对象

//懒汉式 线程不安全
public class Singleton {
   //1.私有化构造器
   private Singleton(){}
   //2.声明一个静态的实例变量
   private static Singleton instance;
   //3.对外提供方法
   public static Singleton getInstance(){
       if (instance == null){
           instance = new Singleton();
       }
       return instance;
   }
}

//懒汉式 线程安全
public class Singleton {
   //1.私有化构造器
   private Singleton(){}
   //2.声明一个静态的实例变量
   private static Singleton instance;
   //3.对外提供方法
   public static synchronized Singleton getInstance(){
       if (instance == null){
           instance = new Singleton();
       }
       return instance;
   }
}

//双重检查锁机制
public class Singleton {
   //1. 私有化构造器
   private Singleton(){}
   //2. 声明Singleton类型的变量
   private static Singleton instance;
   //3. 提供对外的暴露方法
   public  static  Singleton getInstance(){
       if (instance == null){
           synchronized (Singleton.class){
               if (instance == null){
                   instance = new Singleton();
               }
           }
       }
       return instance;
   }
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、以及安全上的问题，但是还有一点问题，就是在多线程的情况下，很有可能会出现空指针的问题，出现的原因是因为JVM在实例化对象的时候会进行优化和指令重排操作。此时可以使用volatile关键字解决这个问题

//指令重排序
public class Singleton {
   //1. 私有化构造器
   private Singleton(){}
   //2. 声明Singleton类型的变量
   private static volatile Singleton instance;
   //3. 提供对外的暴露方法
   public  static  Singleton getInstance(){
       if (instance == null){
           synchronized (Singleton.class){
               if (instance == null){
                   instance = new Singleton();
               }
           }
       }
       return instance;
   }
}

静态内部类的创建方式由于JVM在加载外部类的过程中，是不会加载内部类的，只有在内部类的属性/方法被调用的时候才会被加载，并将其初始化，静态属性被static修饰保证实例被实例化一次，并且严格保证实例化顺序

public class Singleton {
    private Singleton() {}
    private static class SingleTtonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }
    public static Singleton getInstance(){
        return SingleTtonHolder.INSTANCE;
    }
}

通过枚举的方式创建单例

public enum Singleton {
    INSTANCE
}

总结：在使用单例模式的情况下如果还想解决线程安全问题，首选双重检查锁+ 指令重排或者是选择内部类的方式

工厂模式

简单工厂

简单工厂不是一种设计模式，而是一种编程习惯

简单工厂包括一下的角色：

抽象产品：定义产品的规范，描述了产品的主要特性和功能
具体产品：实现或者继承抽象产品的子类
具体工厂：提供了创建产品的方法，调用者通过该方法来创建产品

抽象产品


public abstract class Coffee {
    public abstract String getName();
    public void addSuger(){
        System.out.println(" add suger");
    }
    public void addMilk(){
        System.out.println(" add Milk");
    }
}

具体产品

public class AmericanCoffee extends Coffee{
    @Override
    public String getName() {
        return "美式咖啡";
    }
}
public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

具体工厂类

public class SimpleCoffeeFactory {
    public Coffee createCoffeeFactory(String type){
        Coffee coffee = null;
        if ("美式咖啡".equals(type)){
           coffee = new AmericanCoffee();
        }else if ("拿铁咖啡".equals(type)){
            coffee = new LatteCoffee();
        }else{
            throw new RuntimeException("没有您想要的咖啡");
        }
        return  coffee;
    }
}

调用者

public class CoffeeStore {
    public Coffee orderCoffee(String type){
        SimpleCoffeeFactory factory = new SimpleCoffeeFactory();
        Coffee coffee = factory.createCoffeeFactory(type);
        return coffee;
    }
}

测试

public class Client {
    public static void main(String[] args) {
        CoffeeStore coffeeStore = new CoffeeStore();
        Coffee coffee = coffeeStore.orderCoffee("美式咖啡");
        System.out.println(coffee.getName());
        Coffee coffee1 = coffeeStore.orderCoffee("拿铁咖啡");
        System.out.println(coffee1.getName());
        Coffee coffee2 = coffeeStore.orderCoffee("卡布奇诺");
        System.out.println(coffee2.getName());
    }
}

简单工厂的优点：

封装了对象的创建过程，可以直接通过参数进行对象的创建。吧对象和创建的业务层分开。

简单工程的缺点：

当需要增加新的产品的时候还是要修改工厂类的代码，违背了 `开闭原则`

工厂方法

定义一个用于创建对象的接口，让子类决定实例化哪一个产品的队形。工厂方法使用一个产品类的实例化延迟到工厂的子类。

工厂方法包括一下角色：

抽象工厂：提供了创建产品的接口，调用者通过它访问具体工厂的工厂方法来创建产品
具体工厂：主要是实现抽象工厂中的抽象方法，完场具体产品的创建
抽象产品：定义产品的规范，描述了产品的主要特性和功能
具体产品：实现或者继承抽象产品的子类

抽象产品

public abstract class Cofffee {
    public abstract String getName();
    public void addSuger(){
        System.out.println("加糖");
    }
    public void addMilk(){
        System.out.println("加牛奶");
    }
}

具体产品

public class LatteCoffee extends Coffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}
public class AmericalCoffee extends Coffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

抽象工厂

public interface CoffeeFactory {

    public Coffee createCoffee();
}

具体工厂

public class AmericanCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new AmericalCoffee();
    }
}
public class LatterCoffeeFactory implements CoffeeFactory{
    @Override
    public Coffee createCoffee() {
        return new LatteCoffee();
    }
}

总结：

工厂方法的优点：用户在只要知道工厂的名称就可以得到想要的产品，并且不需要知道产品的创建过程，满足了开闭原则

工厂方法的缺点：没添加一个类就需要添加一个对应的产品类和具体的工厂类，会造成类的爆炸

抽象工厂

抽象工厂是一种为访问类提供一个创建一组相关或相互依赖对象的接口，且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构

抽象工厂（Abstract Factory）：提供了创建产品的接口，它包含多个创建产品的方法，可以创建多个不同等级的产品。
具体工厂（Concrete Factory）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创建。
抽象产品（Product）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多个抽象产品。
具体产品（ConcreteProduct）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它同具体工厂之间是多对一的关系。

现在有如下需求：

现咖啡店业务发生改变，不仅要生产咖啡还要生产甜点，如提拉米苏、抹茶慕斯等，要是按照工厂方法模式，需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类，很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级，都是咖啡；提拉米苏、抹茶慕斯也是一个产品等级；拿铁咖啡和提拉米苏是同一产品族（也就是都属于意大利风味），美式咖啡和抹茶慕斯是同一产品族（也就是都属于美式风味）。所以这个案例可以使用抽象工厂模式实现。类图如下：

抽象产品类

public abstract class Dessert {
    abstract void show();
}

public abstract class Cofffee {
    public abstract String getName();
    public void addSuger(){
        System.out.println("加糖");
    }
    public void addMilk(){
        System.out.println("加牛奶");
}

具体产品类

public class LatteCoffee extends Cofffee {
    @Override
    public String getName() {
        return "拿铁咖啡";
    }
}

class AmericanCoffee extends Cofffee {
    @Override
    public String getName() {
        return "美式咖啡";
    }
}

public class MatchaMousse extends Dessert{
    @Override
    void show() {
        System.out.println("抹茶慕斯");
    }
}

public class Tirmisu extends Dessert{
    @Override
    void show() {
        System.out.println("提拉米苏");
    }
}

抽象工厂

public  interface  DessertFactory {
    public Cofffee createCoffee();
    public Dessert createDessert();
}

具体工厂

public class ItalyDessertFactory implements DessertFactory{
    @Override
    public Cofffee createCoffee() {
        return new LatteCoffee();
    }
    @Override
    public Dessert createDessert() {
        return new Tirmisu();
    }
}
public class AmericanDessertFactory implements DessertFactory{
    @Override
    public Cofffee createCoffee() {
        return new AmericanCoffee();
    }
    @Override
    public Dessert createDessert() {
        return new MatchaMousse();
    }
}

原型模式

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型对象相同的新对象。

原型模式中包含如下角色：

抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。
具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
访问类：使用具体原型类中的 clone() 方法来复制新的对象。

原型模式类图

浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

原型模式案例

同一学校的“三好学生”奖状除了获奖人姓名不同，其他都相同，可以使用原型模式复制多个“三好学生”奖状出来，然后在修改奖状上的名字即可。

类图如下：

浅拷贝代码实现：

Citation：

class Citation implements Cloneable , Serializable{
    private Student stu;

    public Student getStu() {
        return stu;
    }

    public void setStu(Student stu) {
        this.stu = stu;
    }

    void show() {
        System.out.println(stu.getName() + "同学：在2020学年第一学期中表现优秀，被评为三好学生。特发此状！");
    }

    @Override
    public Citation clone() throws CloneNotSupportedException {
        return (Citation) super.clone();
    }
}

class Student implements Serializable{
    private String name;
    private String address;

    public Student(String name, String address) {
        this.name = name;
        this.address = address;
    }

    public Student() {
    }

    public String getName() {
        return name;
    }

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

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

CitationTest：

public class CitationTest {

    //浅拷贝
    public static void main(String[] args) {
        Citation c1 = new Citation();
        Student stu = new Student("张三", "西安");
        c1.setStu(stu);

        //复制奖状
        Citation c2 = null;
        try {
            c2 = c1.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        //获取c2奖状所属学生对象
        Student stu1 = c2.getStu();
        stu1.setName("李四");

        //判断stu对象和stu1对象是否是同一个对象
        System.out.println("stu和stu1是同一个对象？" + (stu == stu1));
        System.out.println("c1和c2是同一个对象？" + (stu == stu1));
        c1.show();
        c2.show();
    }
}

深拷贝代码实现：

public class CitationTest {
    /*深拷贝*/
    public static void main(String[] args) throws Exception {
        Citation c1 = new Citation();
        Student stu = new Student("张三", "西安");
        c1.setStu(stu);

        //创建对象输出流对象
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("D:\b.txt"));
        //将c1对象写出到文件中
        oos.writeObject(c1);
        oos.close();

        //创建对象出入流对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("D:\b.txt"));
        //读取对象
        Citation c2 = (Citation) ois.readObject();
        //获取c2奖状所属学生对象
        Student stu1 = c2.getStu();
        stu1.setName("李四");

        //判断stu对象和stu1对象是否是同一个对象
        System.out.println("stu和stu1是同一个对象？" + (stu == stu1));

        c1.show();
        c2.show();
    }
}

建造者模式

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

分离了部件的构造(由Builder来负责)和装配(由Director负责)。从而可以构造出复杂的对象。这个模式适用于：某个对象的构建过程复杂的情况。
由于实现了构建和装配的解耦。不同的构建器，相同的装配，也可以做出不同的对象；相同的构建器，不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦，实现了更好的复用。
建造者模式可以将部件和其组装过程分开，一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象，而无须知道其内部的具体构造细节。

建造者模式中的几个角色：

建造者（Builder）模式包含如下角色：

抽象建造者类（Builder）：这个接口规定要实现复杂对象的那些部分的创建，并不涉及具体的部件对象的创建。
具体建造者类（ConcreteBuilder）：实现 Builder 接口，完成复杂产品的各个部件的具体创建方法。在构造过程完成后，提供产品的实例。
产品类（Product）：要创建的复杂对象。
指挥者类（Director）：调用具体建造者来创建复杂对象的各个部分，在指导者中不涉及具体产品的信息，只负责保证对象各部分完整创建或按某种顺序创建。

案例：

生产自行车是一个复杂的过程，它包含了车架，车座等组件的生产。而车架又有碳纤维，铝合金等材质的，车座有橡胶，真皮等材质。对于自行车的生产就可以使用建造者模式。

这里Bike是产品，包含车架，车座等组件；Builder是抽象建造者，MobikeBuilder和OfoBuilder是具体的建造者；Director是指挥者。类图如下：

代码：

产品类

public class Bike {
    private String frame;
    private String seat;

    public String getFrame() {
        return frame;
    }
    public void setFrame(String frame) {
        this.frame = frame;
    }
    public String getSeat() {
        return seat;
    }
    public void setSeat(String seat) {
        this.seat = seat;
    }
}

抽象建造者类

public abstract class Builder {

    protected Bike mBike = new Bike();

    public abstract void buildFrame();
    public abstract void buildSeat();
    public abstract Bike createBike();
}

具体建造者

public class OfoBuilder extends Builder{
    @Override
    public void buildFrame() {
        mBike.setFrame("碳纤维车架");
    }

    @Override
    public void buildSeat() {
        mBike.setSeat("橡胶车座");
    }

    @Override
    public Bike createBike() {
        return mBike;
    }
}

public class MobikeBuilder extends Builder{

    @Override
    public void buildFrame() {
        mBike.setFrame("铝合金车架");
    }

    @Override
    public void buildSeat() {
        mBike.setSeat("真皮车座");
    }

    @Override
    public Bike createBike() {
        return mBike;
    }
}

指挥者

public class Director {
    private Builder mBuilder;

    public Director(Builder builder) {
        mBuilder = builder;
    }

    public Bike construct() {
        mBuilder.buildFrame();
        mBuilder.buildSeat();
        return mBuilder.createBike();
    }
}

优点：

建造者模式的封装性很好。使用建造者模式可以有效的封装变化，在使用建造者模式的场景中，一般产品类和建造者类是比较稳定的，因此，将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
在建造者模式中，客户端不必知道产品内部组成的细节，将产品本身与产品的创建过程解耦，使得相同的创建过程可以创建不同的产品对象。
可以更加精细地控制产品的创建过程。将复杂产品的创建步骤分解在不同的方法中，使得创建过程更加清晰，也更方便使用程序来控制创建过程。
建造者模式很容易进行扩展。如果有新的需求，通过实现一个新的建造者类就可以完成，基本上不用修改之前已经测试通过的代码，因此也就不会对原有功能引入风险。符合开闭原则。

缺点：

造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。

建造者（Builder）模式创建的是复杂对象，其产品的各个部分经常面临着剧烈的变化，但将它们组合在一起的算法却相对稳定，所以它通常在以下场合使用。

创建的对象较复杂，由多个部件构成，各部件面临着复杂的变化，但构件间的建造顺序是稳定的。
创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式，即产品的构建过程和最终的表示是独立的。

创建者模式对比

工厂方法模式VS建造者模式

工厂方法模式注重的是整体对象的创建方式；而建造者模式注重的是部件构建的过程，意在通过一步一步地精确构造创建出一个复杂的对象。

我们举个简单例子来说明两者的差异，如要制造一个超人，如果使用工厂方法模式，直接产生出来的就是一个力大无穷、能够飞翔、内裤外穿的超人；而如果使用建造者模式，则需要组装手、头、脚、躯干等部分，然后再把内裤外穿，于是一个超人就诞生了。

抽象工厂模式VS建造者模式

抽象工厂模式实现对产品家族的创建，一个产品家族是这样的一系列产品：具有不同分类维度的产品组合，采用抽象工厂模式则是不需要关心构建过程，只关心什么产品由什么工厂生产即可。

建造者模式则是要求按照指定的蓝图建造产品，它的主要目的是通过组装零配件而产生一个新产品。

如果将抽象工厂模式看成汽车配件生产工厂，生产一个产品族的产品，那么建造者模式就是一个汽车组装工厂，通过对部件的组装可以返回一辆完整的汽车。

创建型模式（Creational Patterns）