设计模式初识

设计模式

1、设计模式七大原则

• 开闭原则

  对扩展开放，对修改关闭

• 单一职责原则

  一个类只干一件事，实现类要单一

• 里氏替换原则

  不要破坏继承体系，子类重写方法功能发生改变，不应该影响父类方法的含义

• 依赖倒转原则

  高层不应该依赖低层，要面向接口编程。

• 接口隔离原则

  一个接口只干一件事，接口要精简单一

• 迪米特法则

  不该知道的不要知道，一个类应该保持对其它对象最少的了解，降低耦合度

• 合成复用原则

  尽量使用组合或者聚合关系实现代码复用，少使用继承

2、设计模式分类

• 创建型模式

  这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

• 结构型模式

  这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。

• 行为型模式

  这些设计模式特别关注对象之间的通信。

2、设计模式全部

不常用

1. 创建型模式

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

2. 结构型模式

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

3. 行为型模式

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

总览

分类	设计模式	简述	一句话归纳	目的	生活案例
创建型设计模式 （简单来说就是用来创建对象的）	工厂模式（Factory Pattern）	不同条件下创建不同实例	产品标准化，生产更高效	封装创建细节	实体工厂
	单例模式（Singleton Pattern）	保证一个类仅有一个实例，并且提供一个全局访问点	世上只有一个我	保证独一无二	CEO
	原型模式（Prototype Pattern）	通过拷贝原型创建新的对象	拔一根猴毛，吹出千万个	高效创建对象	克隆
	建造者模式（Builder Pattern）	用来创建复杂的复合对象	高配中配和低配，想选哪配就哪配	开放个性配置步骤	选配
结构型设计模式 （关注类和对象的组合）	代理模式（Proxy Pattern）	为其他对象提供一种代理以控制对这个对象的访问	没有资源没时间，得找别人来帮忙	增强职责	媒婆
	外观模式（Facade Pattern）	对外提供一个统一的接口用来访问子系统	打开一扇门，通向全世界	统一访问入口	前台
	装饰器模式（Decorator Pattern）	为对象添加新功能	他大舅他二舅都是他舅	灵活扩展、同宗同源	煎饼
	享元模式（Flyweight Pattern）	使用对象池来减少重复对象的创建	优化资源配置，减少重复浪费	共享资源池	全国社保联网
	组合模式（Composite Pattern）	将整体与局部（树形结构）进行递归组合，让客户端能够以一种的方式对其进行处理	人在一起叫团伙，心在一起叫团队	统一整体和个体	组织架构树
	适配器模式（Adapter Pattern）	将原来不兼容的两个类融合在一起	万能充电器	兼容转换	电源适配
	桥接模式（Bridge Pattern）	将两个能够独立变化的部分分离开来	约定优于配置	不允许用继承	桥
行为型设计模式 （关注对象之间的通信）	模板模式（Template Pattern）	定义一套流程模板，根据需要实现模板中的操作	流程全部标准化，需要微调请覆盖	逻辑复用	把大象装进冰箱
	策略模式（Strategy Pattern）	封装不同的算法，算法之间能互相替换	条条大道通罗马，具体哪条你来定	把选择权交给用户	选择支付方式
	责任链模式（Chain of Responsibility Pattern）	拦截的类都实现统一接口，每个接收者都包含对下一个接收者的引用。将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。	各人自扫门前雪，莫管他们瓦上霜	解耦处理逻辑	踢皮球
	迭代器模式（Iterator Pattern）	提供一种方法顺序访问一个聚合对象中的各个元素	流水线上坐一天，每个包裹扫一遍	统一对集合的访问方式	逐个检票进站
	命令模式（Command Pattern）	将请求封装成命令，并记录下来，能够撤销与重做	运筹帷幄之中，决胜千里之外	解耦请求和处理	遥控器
	状态模式（State Pattern）	根据不同的状态做出不同的行为	状态驱动行为，行为决定状态	绑定状态和行为	订单状态跟踪
	备忘录模式（Memento Pattern）	保存对象的状态，在需要时进行恢复	失足不成千古恨，想重来时就重来	备份、后悔机制	草稿箱
	中介者模式（Mediator Pattern）	将对象之间的通信关联关系封装到一个中介类中单独处理，从而使其耦合松散	联系方式我给你，怎么搞定我不管	统一管理网状资源	朋友圈
	解释器模式（Interpreter Pattern）	给定一个语言，定义它的语法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子	我想说”方言“，一切解释权都归我	实现特定语法解析	摩斯密码
	观察者模式（Observer Pattern）	状态发生改变时通知观察者，一对多的关系	到点就通知我	解耦观察者与被观察者	闹钟
	访问者模式（Visitor Pattern）	稳定数据结构，定义新的操作行为	横看成岭侧成峰，远近高低各不同	解耦数据结构和数据操作	KPI考核
	委派模式（Delegate Pattern）	允许对象组合实现与继承相同的代码重用，负责任务的调用和分配	这个需求很简单，怎么实现我不管	只对结果负责	授权委托书

一、六大原则

宗旨：面向接口开发,不要面向实现开发。

记忆口诀：访问加限制，函数要节俭，依赖不允许，动态加接口，父类要抽象，扩展不更改。

1、开闭原则

对扩展开放，对修改关闭

2、里氏替换原则

里氏替换原则主要阐述了有关继承的一些原则

子类可以扩展父类的功能，但不能改变父类原有的功能

3、依赖倒转原则

高层不应该依赖底层，面向接口

即：接口不能依赖实现

4、单一职责原则

一个类只做一种事，实现要单一

即：实现类不能实现不同功能的接口

5、接口隔离原则

一个接口只做一件事，接口要简单单一

即：将同类的方法封装在同一个接口中

6、迪米特法则

一个类应保持对其他对象更少的了解，降低耦合度

如：明星和经纪人的关系，明星只负责去干自己的事，不用去了解其他的

二、23种设计模式

• 创建型模式

  工厂方法模式、单例模式、原型模式、抽象工厂模式、建造者模式
  

• 结构型模式

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

• 行为型模式

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

1、单例模式

只存在一个对象实例

运用场景：只需要单一实例的对象

//双判

public class SingleToneDemo {
    public static void main(String[] args) {
        System.out.println(SingleTone.getInstance());
        System.out.println(SingleTone.getInstance());
    }
}
class SingleTone {
    private static volatile SingleTone instance;

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

2、工厂方法模式

结构：

抽象工厂（创建单个产品）、具体工厂、抽象产品，具体产品

public class FactoryDemo {
    public static void main(String[] args) {
        Factory factory ;
        Product product ;
        factory = new FactoryImpl();
        product = factory.create();
        product.show();
    }
}

interface Factory {
    Product create();
}

class FactoryImpl implements Factory {

    @Override
    public Product create() {
        System.out.println("创建成功");
        return new ProductImpl();
    }
}

interface Product {
    void show();
}

class ProductImpl implements Product {

    @Override
    public void show() {
        System.out.println("产品实体类展示");
    }
}

3、抽象工厂模式

结构：

抽象工厂（创建多个产品）、具体工厂、抽象产品，具体产品

public class AbstractFactoryDemo {
    public static void main(String[] args) {
        AbstractFactory abstractFactory;
        Product1 product1;
        Product2 product2;
        abstractFactory = new AbstractFactoryImpl();
        product1 = abstractFactory.create1();
        product2 = abstractFactory.create2();
        product1.show();
        product2.show();
    }
}

interface AbstractFactory {
    Product1 create1();

    Product2 create2();
}

interface Product1 {
    void show();
}

interface Product2 {
    void show();
}

class AbstractFactoryImpl implements AbstractFactory {
    @Override
    public Product1 create1() {
        System.out.println("创建第一个产品");
        return new ProductImpl1();
    }

    @Override
    public Product2 create2() {
        System.out.println("创建第二个产品");
        return new ProductImpl2();
    }
}

class ProductImpl1 implements Product1 {

    @Override
    public void show() {
        System.out.println("展示第一个产品");
    }
}

class ProductImpl2 implements Product2 {

    @Override
    public void show() {
        System.out.println("展示第二个产品");
    }
}

4、建造者模式()

主要用来通过链式调用生成不同的配置。

结构：

产品、抽象建造者、具体建造者、指挥者

使用案例：StringBuilder().append().append()....链式调用 （简化）

生活案例：生成不同配置的电脑，不同的套餐等。

package com.mainwood.designdemo.builder;

/**
 * @author qmai 抽象建造者
 */
public interface Builder {
    /**
     * 品牌
     *
     * @param
     * @author renxu
     * @date 2022/3/25 15:40
     * @returns
     **/
    void brand();

    /**
     * 规格配置
     *
     * @param
     * @author renxu
     * @date 2022/3/25 15:41
     * @returns
     **/
    void setting();

    /**
     * 尺寸
     *
     * @param
     * @author renxu
     * @date 2022/3/25 15:41
     * @returns
     **/
    void size();

}


package com.mainwood.designdemo.builder;

/**
 * @author qmai
 */
public class MacBuilder implements Builder{
    /**
     * 品牌
     *
     * @author renxu
     * @date 2022/3/25 15:40
     * @returns
     **/
    @Override
    public void brand() {
        System.out.println("系统品牌 mac");
    }

    /**
     * 规格配置
     *
     * @author renxu
     * @date 2022/3/25 15:41
     * @returns
     **/
    @Override
    public void setting() {
        System.out.println("处理器配置 M1 PRO");
    }

    /**
     * 尺寸
     *
     * @author renxu
     * @date 2022/3/25 15:41
     * @returns
     **/
    @Override
    public void size() {
        System.out.println("屏幕尺寸 13.3寸");
    }
}

    
package com.mainwood.designdemo.builder;

/**
 * @author qmai
 */
public class WindowsBuilder implements Builder{
    /**
     * 品牌
     *
     * @author renxu
     * @date 2022/3/25 15:40
     * @returns
     **/
    @Override
    public void brand() {
        System.out.println("系统品牌 windows");
    }

    /**
     * 规格配置
     *
     * @author renxu
     * @date 2022/3/25 15:41
     * @returns
     **/
    @Override
    public void setting() {
        System.out.println("处理器配置 i9-12008HK");
    }

    /**
     * 尺寸
     *
     * @author renxu
     * @date 2022/3/25 15:41
     * @returns
     **/
    @Override
    public void size() {
        System.out.println("屏幕尺寸 15.6寸");
    }
}

    
package com.mainwood.designdemo.builder;

/**
 * @author qmai
 */
public class Director {
    private Builder builder;

    public Director(Builder builder) {
        this.builder = builder;
    }

    public void make(){
        builder.brand();
        builder.setting();
        builder.size();
    }

}

    

5、原型模式()

深克隆：与原对象地址不同

创建型------分割线------结构型

6、适配器模式

spring中使用：前端控制器中的DispatcherServlet

目标对象：需要调用其他对象的对象
适配对象：被调用的对象
适配器：适配两者的对象
目标对象：要为接口或者抽象类
适配对象：有自己的方法
适配器：要实现或继承目标对象，聚合适配对象，有自己的有参构造函数去执行适配者的方法

public class AdapterDemo {
    public static void main(String[] args) {
        ElectricMachine electricMachine = new ElectricMachine110();
        Switch aSwitch = new Adpater(electricMachine);
        aSwitch.open();
    }
}

//适配者接口
interface ElectricMachine {
    public void start();
}

//适配者实体
class ElectricMachine110 implements ElectricMachine {

    @Override
    public void start() {
        System.out.println("打开110V电器电器");
    }
}

//目标对象接口
interface Switch {
    public void open();
}

//目标对象实体
class SwitchImpl implements Switch {
    @Override
    public void open() {
        ;
    }
}

//适配器
class Adpater implements Switch {

    private ElectricMachine electricMachine;

    public Adpater(ElectricMachine electricMachine) {
        this.electricMachine = electricMachine;
    }

    @Override
    public void open() {
        electricMachine.start();
    }
}

7、代理模式

spring中使用：AOP

结构：

​ 抽象主题：被代理对象的接口或实体类

​ 真实主题：被代理对象实体类

​ 代理类：代理类

​ 关系：代理类要去实现或继承抽象主题，聚合真是主题的被代理类，在代理类中自己写入增强方法区增强原方法。

动态代理与静态代理的主要区别在于：

​ 只是主题是否预先存在，存在使用静态代理，不存在使用动态代理。

public class ProxyDemo {
    public static void main(String[] args) {
        Car car = new ProxyCar();
        car.drive();
    }
}

interface Car {
    void drive();
}

class RealCar implements Car {

    @Override
    public void drive() {
        System.out.println("车子启动");
    }
}

class ProxyCar implements Car {
    RealCar car = new RealCar();

    @Override
    public void drive() {
        before();
        car.drive();
        after();
    }

    void before() {
        System.out.println("打火");
    }

    void after() {
        System.out.println("松刹车");
    }
}

8、装饰器模式

对原有对象正增加一些新功能

结构：

​ 抽象构建：定义的抽象接口

​ 具体构建：集体的实现接口

​ 抽象装饰：实现抽象接口，并聚合具体构建

​ 具体装饰：继承抽象装饰，并扩展方法

public class DecoratorDemo {
    public static void main(String[] args) {
        Shape three = new ThreeShape();
        Shape four  = new FourShape();
        AbDecorator t = new DecoratorImpl(three);
        AbDecorator f = new DecoratorImpl(four);
        t.draw();
        f.draw();
    }
}

interface Shape {
    void draw();
}

class ThreeShape implements Shape {
    @Override
    public void draw() {
        System.out.println("画三角形");
    }
}

class FourShape implements Shape {
    @Override
    public void draw() {
        System.out.println("画四边形");
    }
}

abstract class AbDecorator implements Shape {
    public Shape shape;

    public AbDecorator(Shape shape) {
        this.shape = shape;
    }

    @Override
    public void draw() {
        shape.draw();
    }
}

class DecoratorImpl extends AbDecorator {

    public DecoratorImpl(Shape shape) {
        super(shape);

    }

    @Override
    public void draw() {
        shape.draw();
        otherFun(shape);
    }

    //扩展方法
    public void otherFun(Shape shape) {
        System.out.println(shape + " 的增加方法");
    }

}

9、桥接模式()

10、外观模式

11、组合模式

12、享元模式

结构型------分割线-------行为型

13、策略模式

根据不同的参数执行不同的策略

结构：

​ 抽象策略：提供策略接口的方法，

​ 具体策略：提供策略的具体实现

​ 环境：聚合具体策略，并提供一个执行策略的方法的方法

public class StrategyDemo {
    public static void main(String[] args) {
        Tool plane = new ByPlane();
        Tool car = new ByCar();
        Context s1 = new Context(plane);
        Context s2 = new Context(car);
        s1.exec();
        s2.exec();
    }
}
//抽象策略接口
interface Tool{
    void travel();
}
class ByPlane implements Tool{

    @Override
    public void travel() {
        System.out.println("坐飞机出行");
    }
}
class ByCar implements Tool{

    @Override
    public void travel() {
        System.out.println("开车出行");
    }
}
class Context {
    private Tool tool;

    public Tool getTool() {
        return tool;
    }

    public void setTool(Tool tool) {
        this.tool = tool;
    }
    public Context(Tool tool){
        this.tool = tool;
    }
    public void exec(){
        tool.travel();
    }
}

14、模板方法模式

根据抽象类中的固定方法，去执行抽象方法，抽象方法由子类进行重写来供后期调用

​ 抽象类：提供模板方法和抽象方法

​ 具体子类：重写抽象类的抽象方法

public class TemplateDemo {
    public static void main(String[] args) {
        Template worker = new Worker();
        Template student = new Student();
        worker.exec();
        student.exec();
    }
}

abstract class Template {
    //模板方法
    void exec() {
        setJob();
        setAge();
        setGender();
    }

    abstract void setJob();

    abstract void setAge();

    abstract void setGender();
}

class Worker extends Template {

    @Override
    void setJob() {
        System.out.println("我是工人");
    }

    @Override
    void setAge() {
        System.out.println("我20岁");
    }

    @Override
    void setGender() {
        System.out.println("我是男士");
    }
}

class Student extends Template {

    @Override
    void setJob() {
        System.out.println("我是学生");
    }

    @Override
    void setAge() {
        System.out.println("我10岁");
    }

    @Override
    void setGender() {
        System.out.println("我是女生");
    }
}

15、观察者模式

16、迭代器模式

17、责任链模式

18、状态模式