@[toc]
一、单例模式
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整理
下载地址
https://download.csdn.net/download/weixin_44624117/12840404百度网盘
链接：https://pan.baidu.com/s/1qAAsPktlcCPYle0yHdkoyQ
提取码：f0zv
