一篇文章读懂六大设计模式

绝地灬酷狼 2023-10-05 10:02 13阅读 0赞

### 文章目录 ###

*   *  一、单例模式
     *   *   *  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、结构图解 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center]

#### 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、结构图解 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 1]

#### 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、结构图解 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 2]

#### 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、结构图解 ####

![在这里插入图片描述][20200914145453216.jpg_pic_center]

#### 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、结构图解 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 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、结构图解 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 4]

#### 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整理 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 5]

下载地址

[CSDN地址][CSDN]

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

百度网盘

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

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center]: https://img-blog.csdnimg.cn/20200914145410975.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 1]: https://img-blog.csdnimg.cn/2020091414543091.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 2]: https://img-blog.csdnimg.cn/20200914145440797.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70#pic_center
[20200914145453216.jpg_pic_center]: https://img-blog.csdnimg.cn/20200914145453216.jpg#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 3]: https://img-blog.csdnimg.cn/20200914145503649.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 4]: https://img-blog.csdnimg.cn/20200914145514823.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70#pic_center
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw_size_16_color_FFFFFF_t_70_pic_center 5]: https://img-blog.csdnimg.cn/2020091414552638.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDYyNDExNw==,size_16,color_FFFFFF,t_70#pic_center
[CSDN]: https://download.csdn.net/download/weixin_44624117/12840404