设计_qq_40320556-CSDN博客

本文链接：https://blog.csdn.net/qq_40320556/article/details/101211856

设计模式

创建形

1. 单例模式及其使用场景

懒汉式-线程不安全

懒汉式-线程安全

懒汉式-双重校验锁-线程安全

public class Singleton {

    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

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

volatile的作用就是防止指令重排序 代码读取到instance不为null时，instance引用的对象有可能还没有完成初始化

static的作用就是保证是类变量的一个单例

饿汉式-线程安全

静态内部类实现

public class Singleton {

    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }
}

2.简单工厂

简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。

public class Client {

    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        Product product = simpleFactory.createProduct(1);
        // do something with the product
    }
}

public class SimpleFactory {

    public Product createProduct(int type) {
        if (type == 1) {
            return new ConcreteProduct1();
        } else if (type == 2) {
            return new ConcreteProduct2();
        }
        return new ConcreteProduct();
    }
}

public interface Product {
}

public class ConcreteProduct implements Product {
}

public class ConcreteProduct1 implements Product {
}

public class ConcreteProduct2 implements Product {
}

工厂方法用到了抽象类

定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类工厂。

与简单工厂的区别：简单工厂是工厂固定根据不同要求得到不同产品，工厂模式是根据要求不同划分到不同工厂去执行

public abstract class Factory {
    abstract public Product factoryMethod();
    public void doSomething() {
        Product product = factoryMethod();
        // do something with the product
    }
}

抽象工厂

抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象，这和抽象工厂模式有很大不同。从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂方法模式使用了继承。

电脑 interl可以产cput和显示器戴尔也可产cpu个显示器

public class Client {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = new ConcreteFactory1();
        AbstractProductA productA = abstractFactory.createProductA();
        AbstractProductB productB = abstractFactory.createProductB();
        // do something with productA and productB
    }
}

public abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}

public class ConcreteFactory1 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA1();
    }

    AbstractProductB createProductB() {
        return new ProductB1();
    }
}

public class ConcreteFactory2 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA2();
    }

    AbstractProductB createProductB() {
        return new ProductB2();
    }
}

生成器Builder 比如StringBuildr

封装一个对象的构造过程，并允许按步骤构造。

核心是：先把所有的属性都设置给 Builder，然后 build() 方法的时候，将这些属性复制给实际产生的对象。项目里面ticket的狗在过程

原型模式

使用原型实例指定要创建对象的类型，通过复制这个原型来创建新对象。

原型模式很简单：有一个原型实例，基于这个原型实例产生新的实例，也就是“克隆”了。

Object 类中有一个 clone() 方法，它用于生成一个新的对象，当然，如果我们要调用这个方法，java 要求我们的类必须先实现 Cloneable 接口，此接口没有定义任何方法，但是不这么做的话，在 clone() 的时候，会抛出 CloneNotSupportedException 异常。

行为型

责任链

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链发送该请求，直到有一个对象处理它为止。

责任链通常需要先建立一个单向链表，然后调用方只需要调用头部节点就可以了，后面会自动流转下去。比如流程审批就是一个很好的例子，只要终端用户提交申请，根据申请的内容信息，自动建立一条责任链，然后就可以开始流转了。（拦截器）

有这么一个场景，用户参加一个活动可以领取奖品，但是活动需要进行很多的规则校验然后才能放行，比如首先需要校验用户是否是新用户、今日参与人数是否有限额、全场参与人数是否有限额等等。

定义好一个链表，然后在通过任意一节点后，如果此节点有后继节点，那么传递下去。

至于它和我们前面说的用一个 List 存放需要执行的规则的做法有什么异同，留给读者自己琢磨吧。

命令

Command：命令
Receiver：命令接收者，也就是命令真正的执行者
Invoker：通过它来调用命令
Client：可以设置命令与命令的接收者

其实就是命令集合命令的执行者(电视) 命令的调用者(遥控器)

命令根据电视封装起来调用者调用命令即可（不需要知道电视怎么开的）

解释器（Interpreter）

为语言创建解释器，通常由语言的语法和语法分析来定义。

通过规则可以构建一颗解析树，用来检验一个文本是否满足解析树定义的规则。

例如一颗解析树为 D And (A Or (B C))，文本 "D A" 满足该解析树定义的规则。

迭代器（Iterator）

提供一种顺序访问聚合对象元素的方法，并且不暴露聚合对象的内部表示。

Class Diagram

Aggregate 是聚合类，其中 createIterator() 方法可以产生一个 Iterator；
Iterator 主要定义了 hasNext() 和 next() 方法。
Client 组合了 Aggregate，为了迭代遍历 Aggregate，也需要组合 Iterator。

中介者（Mediator）

集中相关对象之间复杂的沟通和控制方式。大脑来控制其他对象

Class Diagram

Mediator：中介者，定义一个接口用于与各同事（Colleague）对象通信。
Colleague：同事，相关对象

备忘录（Memento）

在不违反封装的情况下获得对象的内部状态，从而在需要时可以将对象恢复到最初状态。

Class Diagram

Originator：原始对象
Caretaker：负责保存好备忘录
Menento：备忘录，存储原始对象的的状态。备忘录实际上有两个接口，一个是提供给 Caretaker 的窄接口：它只能将备忘录传递给其它对象；一个是提供给 Originator 的宽接口，允许它访问到先前状态所需的所有数据。理想情况是只允许 Originator 访问本备忘录的内部状态。

以下实现了一个简单计算器程序，可以输入两个值，然后计算这两个值的和。备忘录模式允许将这两个值存储起来，然后在某个时刻用存储的状态进行恢复。