首页 > 编程札记 > 编程

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

阅读：评论：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、结构图解

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 = ateProduct();
//        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 {@Overridepublic 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) {thisponent = 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();
//        执行方法quest();}
}

真实主题

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

代理类

//代理
class Proxy {private RealSubject realSubject;public void request() {realSubject = new RealSubject();
//        1、之前方法preRequest();
//        2、真实方法quest();
//        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、BObserver obsA = new ConcreteObserverA();Observer obsb = new ConcreteObserverB();
//        3、将具体观察者加入到目标对象中subject.add(obsA);subject.add(obsb);
//        4、调用A、B查看ifoy();}
}

具体目标

//具体目标
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();}
}