一篇文章读懂六大设计模式-蒲公英云

文章目录

- 一、单例模式
- - - 1、简介
    - 2、目的
    - 3、结构图解
    - 4、特点
    - 5、代码
    - 6、适用场景
- 二、工厂模式
- - - 1、简介
    - 2、目的
    - 3、结构图解
    - 4、特点
    - 5、代码
- 三、装饰者模式
- - - 1、简介
    - 2、目的
    - 3、结构图解
    - 4、特点
    - 5、代码
    - 6、使用场景
- 四、代理模式
- - - 1、简介
    - 2、目的
    - 3、结构图解
    - 4、特点
    - 5、代码
- 五、观察者模式
- - - 1、简介
    - 2、目的
    - 3、结构图解
    - 4、特点
    - 5、代码
- 六、策略模式
- - - 1、简介
    - 2、目的
    - 3、结构图解
    - 4、特点
    - 5、代码
- 七、Xmind整理

一、单例模式

1、简介

韦小宝有7个老婆，但是每个都只有他这一个老公，他的所有老婆叫老公时，指的都是他，他就是一个单例。

2、目的

为了确保一个类有且仅有一个实例，并为它提供一个全局访问点。

3、结构图解

在这里插入图片描述

4、特点

单例模式保证了类仅有一个实例，并为其提供了一个全局访问点。通过延迟初始化（仅在第一次使用它时才初始化），一个单例对象是达到此目的的通用做法。
在多线程环境下，必须小心管理线程间的协作，因为它们访问单例对象方法与数据的时间，可能只有毫厘之差。
对象具有唯一性，并不意味着使用了单例模式。单例模式通过隐藏构造函数，提供对象创建的唯一入口点。
单例模式初始化时创建对象。
只对外提供公共的getInstance方法，不提供任何公共构造函数。

5、代码

public class Singleton {
    //保证 instance 在所有线程中同步
    private static volatile Singleton instance = null;
    private Singleton() {
    }    //private 避免类在外部被实例化
    public static synchronized Singleton getInstance() {
        //getInstance 方法前加同步
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

6、适用场景

适合需要做全局统一控制的场景，例如：全局唯一的编码生成器。

二、工厂模式

1、简介

小明追妹子的时候，请她喝了不少咖啡，她爱喝卡布奇诺，每次去咖啡店，只要跟服务员说“来杯卡布奇诺”就行了，虽然各家的口味有些不同，但是不管是星爸爸还是Costa，都能够提供卡布奇诺这种咖啡。这里的星爸爸和Costa就是生产咖啡的工厂。

2、目的

直接从工厂类中获取各种产品，不在需要亲自去挑选产品。

3、结构图解

在这里插入图片描述

4、特点

客户类和工厂类分开。消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。

5、代码

用户

public class FactoryPattern {
    public static void main(String[] args) {
//        1、创建工程类
        Factory factory = new ConcreteFactoryA();
//        2、生产产品
        Product product = factory.createProduct();
//        3、消费产品
        product.use();
    }
}

产品力

//实体类产品
interface Product {
    public void use();
}
//具体产品A：实现抽象产品中的抽象方法
class ConcreteProductA implements Product {
    public void use() {
        System.out.println("具体产品A显示...");
    }
}

工厂类

//抽象工厂：提供了厂品的生成方法
interface Factory {
    public Product createProduct();
}
//具体工厂A：实现了厂品的生成方法
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        System.out.println("具体工厂A生成-->具体产品A.");
        return new ConcreteProductA();
    }
}

三、装饰者模式

1、简介

大学毕业，想要送给室友一个有纪念意义的礼物，就找到一张大家的合照，在上面写上“永远的兄弟！”，然后拿去礼品店装了个相框，再包上礼盒。这里的我和礼品店都是装饰器，都没有改变照片本身，却都让照片变得更适合作为礼物送人。

2、目的

在不改变原有功能的基础下，对功能进行扩展。

3、结构图解

在这里插入图片描述

4、特点

使用不同的装饰器组合为对象扩展N个新功能，而不会影响到对象本身。

5、代码

用户

public class DecoratorPattern {
    public static void main(String[] args) {
        Component component = new ConcreteComponent();
        component.operation();
        System.out.println("---------------------------------");
        ConcreteDecorator decorator = new ConcreteDecorator(component);
        decorator.operation();
    }
}

构建角色

//抽象构件角色
interface Component {
    public void operation();
}
//具体构件角色
class ConcreteComponent implements Component {
    public ConcreteComponent() {
        System.out.println("创建具体构件角色");
    }
    public void operation() {
        System.out.println("调用具体构件角色的方法operation()");
    }
}

装饰角色

class ConcreteDecorator {
    private Component component;
    public ConcreteDecorator(Component component) {
        this.component = component;
    }
    public void operation() {
        component.operation();
        System.out.println("为具体构件角色增加额外的功能addBehavior()");
    }
}

6、使用场景

适合需要（通过配置，如：diamond）来动态增减对象功能的场景。
适合一个对象需要N种功能排列组合的场景（如果用继承，会使子类数量爆炸式增长）

四、代理模式

1、简介

淘宝店客服总是会收到非常多的重复问题，例如：有没有现货？什么时候发货?发什么快递？大量回答重复性的问题太烦了，于是就出现了小蜜机器人，他来帮客服回答那些已知的问题，当碰到小蜜无法解答的问题时，才会转到人工客服。这里的小蜜机器人就是客服的代理。

2、目的

代理用户的请求，去完整后续的各项任务。

3、结构图解

在这里插入图片描述

4、特点

代理可以协调调用方与被调用方，降低了系统的耦合度。根据代理类型和场景的不同，可以起到控制安全性、减小系统开销等作用。

5、代码

用户

public class ProxyPattern {
    public static void main(String[] args) {
//        获取代理对象
        Proxy proxy = new Proxy();
//        执行方法
        proxy.request();
    }
}

真实主题

//真实主题
class RealSubject {
    //  2、真实方法
    public void request() {
        System.out.println("访问真实主题方法...");
    }
}

代理类

//代理
class Proxy {
    private RealSubject realSubject;
    public void request() {
        realSubject = new RealSubject();
//        1、之前方法
        preRequest();
//        2、真实方法
        realSubject.request();
//        3、之后方法
        afterRequest();
    }
    //        1、之前方法
    public void preRequest() {
        System.out.println("访问真实主题之前的预处理。");
    }
    //        3、之后方法
    public void afterRequest() {
        System.out.println("访问真实主题之后的后续处理。");
    }
}

五、观察者模式

1、简介

出差在外，想了解孩子在家的情况，这时候只要加入“相亲相爱一家人”群，老爸老妈会经常把孩子的照片和视频发到群里，你要做的就是作为一个观察者，刷一刷群里的信息就能够了解一切了。

2、目的

适用于一对多的的业务场景，一个对象发生变更，会触发N个对象做相应处理的场景。

3、结构图解

在这里插入图片描述

4、特点

将复杂的串行处理逻辑变为单元化的独立处理逻辑，被观察者只是按照自己的逻辑发出消息，不用关心谁来消费消息，每个观察者只处理自己关心的内容。逻辑相互隔离带来简单清爽的代码结构。

5、代码

用户

public class ObserverPattern {
    public static void main(String[] args) {
//        1、创建目标对象
        ConcreteSubject subject = new ConcreteSubject();
//        2、创建具体观察者A、B
        Observer obsA = new ConcreteObserverA();
        Observer obsb = new ConcreteObserverB();
//        3、将具体观察者加入到目标对象中
        subject.add(obsA);
        subject.add(obsb);
//        4、调用A、B查看
        subject.notifoy();
    }
}

具体目标

//具体目标
class ConcreteSubject {
    protected List<Observer> observers = new ArrayList<Observer>();
    //增加观察者方法
    public void add(Observer observer) {
        observers.add(observer);
    }
//  调用观察者执行
    public void notifoy() {
        System.out.println("具体目标状态发生改变...");
        System.out.println("--------------");
        for (Observer obs : observers) {
            obs.process();
        }
    }
}

观察者A、B

//抽象观察者
interface Observer {
    void process(); //具体的处理
}
//具体观察者A
class ConcreteObserverA implements Observer {
    public void process() {
        System.out.println("具体观察者A处理！");
    }
}
//具体观察者B
class ConcreteObserverB implements Observer {
    public void process() {
        System.out.println("具体观察者B处理！");
    }
}

六、策略模式

1、简介

男生追妹子时，一般都会用到这种模式，常见的策略有这些：约会吃饭；看电影；看演唱会；逛街；去旅行……，虽然做的事情不同，但可以相互替换，唯一的目标都是捕获妹子的芳心。

2、目的

为同一的内容，选择不同的解决方案。

3、结构图解

在这里插入图片描述

4、特点

策略模式提供了对“开闭原则”的完美支持，用户可以在不修改原有系统的基础上选择算法或行为。干掉复杂难看的if-else。

5、代码

用户

public class StrategyPattern {
    public static void main(String[] args) {
//        1、创建环境类对象
        Context context = new Context();
//        2.1、创建策略类A对象
        Strategy strategyA = new ConcreteStrategyA();
//        3.1、将策略A添加到环境类中
        context.setStrategy(strategyA);
//        4.1、执行策略A方法
        context.algorithm();
        System.out.println("-----------------");
//        2.1、创建策略类B对象
        Strategy strategyB = new ConcreteStrategyB();
//        3.1、将策略B添加到环境类中
        context.setStrategy(strategyB);
//        4.1、执行策略B方法
        context.algorithm();
    }
}

策略类

//抽象策略类
interface Strategy {
    public void algorithm();    //策略方法
}
//具体策略类A
class ConcreteStrategyA implements Strategy {
    public void algorithm() {
        System.out.println("具体策略A的策略方法被访问！");
    }
}
//具体策略类B
class ConcreteStrategyB implements Strategy {
    public void algorithm() {
        System.out.println("具体策略B的策略方法被访问！");
    }
}

待解决问题

//环境类
class Context {
    private Strategy strategy;
    public void setStrategy(Strategy strategy) {
        this.strategy = strategy;
    }
    public void algorithm() {
        strategy.algorithm();
    }
}

七、Xmind整理

在这里插入图片描述

下载地址

CSDN地址

https://download.csdn.net/download/weixin_44624117/12840404

百度网盘

链接：https://pan.baidu.com/s/1qAAsPktlcCPYle0yHdkoyQ 
提取码：f0zv

文章目录

一、单例模式

1、简介

2、目的

3、结构图解

4、特点

5、代码

6、适用场景

二、工厂模式

1、简介

2、目的

3、结构图解

4、特点

5、代码

三、装饰者模式

1、简介

2、目的

3、结构图解

4、特点

5、代码

6、使用场景

四、代理模式

1、简介

2、目的

3、结构图解

4、特点

5、代码

五、观察者模式

1、简介

2、目的

3、结构图解

4、特点

5、代码

六、策略模式

1、简介

2、目的

3、结构图解

4、特点

5、代码

七、Xmind整理

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

随便看看

教程文章

热评文章

1江湖小白之一起学Python （二）爬取数据的保存

2Java Shiro：简化身份验证和授权的安全框架

3Java中try()catch{}的使用方法

4Swagger注解-@ApiModel 和 @ApiModelProperty

5windows下强制杀死tomcat进程

6uni-app 条形码(一维码)/二维码生成实现

标签列表