23种设计模式

前言
- 开闭原则
- 隔离接口
- 迪米特
- 依赖倒置
- 单一
- 里式替换
创建模式（
- 单例
- - 懒汉式
  - 饿汉式
- 原型
- - 浅克隆
  - 深克隆
- 建造者
- 工厂
- - 简单工厂（Log）可以参考一下 LoggerFactory（SLF4J）
  - 抽象工厂
结构模型
- 适配器
- 代理
- - 静态代理/装饰者
  - 动态代理
  - - JDK动态代理
    - cgilb动态代理
- 桥接
- 外观模式
- 组合模式
- 享元模式
行为模式
- 模板模式
- 策略模式
- 状态模式
- 中介者模式
- 观察者模式
- 访问者模式
- 责任链模式

前言

脑图分享脑图
理解设计模式对今后写业务和学习框架源代码有很大的作用，但是设计模式又非常的抽象和晦涩难懂所以一般在第一次学习的时候可以有一个初步的印象大概知道是干什么的然后有哪些组成即，然后再工作一段时间后再回头过来学习就会发现有新的理解（回锅肉很好吃哈哈），这些由前人总结出来的各种模式也都是遵循着设计模式的 7个准则开闭原则隔离接口迪米特依赖倒置单一里式替换等这个都是想让你的更加健壮就是在尽量不修改源代码的基础上增加功能也就是所谓的对修改关闭对扩展开放而写java 的时候总是告诉你要面向接口开发也就是这个原因先抽象也就是先定义规则然后再按照规则开发

开闭原则

意思：对修改关闭对扩展开放。白话的意思是比如你写了一个功能模块但是突然在原来的基础上要加新的功能一般像我刚开始开发的时候都是在源代码上进行修改并进行测试，但是这样会带来一个问题就是目前的功能模块已经是开发过的并且经过测试中心测试通过的已经在线上运行的如果在现在的功能里面进行修改那么以前测试通过的功能又要测试中心重新测试防止误操作产生新的bug 但是测试中心的老师一般也不会情缘因为这个工作会让他做重复性的工作所这个时候你需要在将原功能不动的情况下在新写一个新增的功能然后将他们组合起来这样测试老师只需要测试你新的的功能就可以了如果你的功能模块还没有上线并且还在开发并且业务逻辑也不复杂那么就按照自己习惯简单易读最好，如果你想练手可以慢慢培养这种思维可以在自己的新业务代码种运用进去。

隔离接口

意思：不引用用不到的接口这个最好操作平时我们也不会去引用一个什么都不干的接口。

迪米特

意思：最少知道原则这个意思是不同功能的模块要分开而不是耦合（耦合的意思就是手机数据线放到了裤兜里面拿出来的样子）在一个类中去写。如果放到一个类中写会出现一个问题就是不管哪个功能变更你都要去修改整个代码因为你们写在了一起只要修改就会创造bug 所以这么做的目的也是让我们尽可能少的变动代码

依赖倒置

意思：比如需要将一个引用类型当做一个参数传入那么就不要去放这个类实现类也就是子类放入这个引用接口为什么呢因为这么做你可以很灵活的去传参只要是实现了这个接口都可以当做这个参数这样就增加了方法的健壮型而不是每次换一个类就得重写这个方法传入这也是面向接口的好处

单一

意思就是一个类只干一个事情，比如你创建了一个工具类那么这类中只放平时大家一起用的工具而不是将杂乱方法在里面这样做一个是维护起来省心还有就是自己在写业务的时候也能减少重复造轮子。

里式替换

意思：如果你是一个子类去继承了一个父类去扩展父类的方法同时不要去重写的父类原有的方法这就和上面说的开闭说的就能联系上了我们扩展的目的不是去修改原有的父类方法而是在其基础上去增强所以这个法则存

虽然说设计模式能解决很多实际的问题但是无形中也带来一定的困难有些时候会很不方便如果业务不复杂还是以易读为准吧如果练手那就别出问题就行

（在使用设计模式的是有首先要有抽象层这个很重要也就是要有interface）

创建模式（

会发现这个些都是帮你创建一个对象也就是帮助你去new 一个类只是功能侧重点不同但是同一的创建把他们规整到一个模式）

单例

（单例我就不说了也不难理解网上一大堆资料也不抽象）

懒汉式

饿汉式

原型

（JDK 原生支持只要去实现 clone 接口就行）

浅克隆

（只复制本类）

深克隆

（如果说本类中参数中还有其他引用 Person类里面多了一个 User类这个时候使用深克隆）

建造者

（如果你方法需要传入的参数过多可以考虑这种方式平时我们看后缀带xxxbuilder 方式基本都是建造者模式这个理解起来也不费劲就是一个传参的过程网上很多代码平时的时候也可自己用在代码里面）
1.首先要抽象出来一个建造者里面规定你要创建的方法也就是你后续用到的参数我这里抽象一个手机builder

package Buider;public abstract class AbstracBuiderPhone {Phone phone;abstract AbstracBuiderPhone customCpu(String cpu);abstract AbstracBuiderPhone customMouse(String Mouse);
}

2.需要建造者创建的物品手机

package Buider;class Phone {protected String name;protected String cpu;protected String Mouse;public String getName() {return name;}public String getCpu() {return cpu;}public String getMouse() {return Mouse;}@Overridepublic String toString() {return "Phone{"+ "name='"+ name+ '\''+ ", cpu='"+ cpu+ '\''+ ", Mouse='"+ Mouse+ '\''+ '}';}
}

3 实现一个建造者接口就是你要创造出一个什么样的手机（比如小米手机）

package Buider;public class xiaomBuider extends AbstracBuiderPhone {/**** */public xiaomBuider() {phone = new Phone();}@OverrideAbstracBuiderPhone customCpu(String cpu) {phone.cpu = cpu;return this;}@OverrideAbstracBuiderPhone customMouse(String Mouse) {phone.Mouse = Mouse;return this;}Phone getPhone() {return phone;}
}

4 测试

package Buider;public class ttes {public static void main(String[] args) {//xiaomBuider x = new xiaomBuider();x.customCpu("i7 11000k").customMouse("xiaomni");Phone phone = x.getPhone();System.out.println(phone);}
}

使用这个是链式建造模式使用这个方式有什么好处呢。显而易见就是代码看着规整和方便而不是在你创建对象new 一个类的时候里面需要传入十几个参数每次还都要去查看哪个位置需要什么类型这个就很方便就是直接不停的点方法名就会去提示添加参数。在传入的参数超过5 个以上可以尝试使用一下

工厂

（我这里只说两个方法工厂方法可以尝试就用在现在的业务代码中也许已经在用了只不过以前不知道比如创建的CommUtil 类里面的静态方法都是普通工具类包，工厂类可以将我们同一类型的类同一进行创建并且是在其内部创建好的这么做有什么好处呢比如我们现在的业务代码种存在很多方法但是由于接手或者历史遗留问题代码重复轮子不少其实可以将他们同一归档同一在一个工厂内部创建这样就像咋杂乱无章的贮存房间里面放置了很多架子只需要将他们按照不同类别规整然后贴上标签谁需要直接按照标签去找而不是自己乱翻找）

简单工厂（Log）可以参考一下 LoggerFactory（SLF4J）

抽象工厂

将我们的工厂实体抽象出去变成一个接口这样的好处是工厂就可以扩展了比如就好像将厂子变成了公司集团有很多业务之后可以还用抽象的工厂去继承集团总厂这样就可以在名字上进行区分每个功能厂子比如造汽车或者造手机然后可以在创建一个抽象类去实现这个工厂接口然后对自己不要的方法在抽象方法里面做一下处理在真正的实体工厂类里面就可以不去重写这个抽象类工厂我们不需要的方法了，工厂创建完成了这个时候需要原材料组装才能生产物品，所以将我们工厂要生产的物品抽象（定义他是一个什么东西比如phone）实体类去实现这个物品抽象接口比如我是华为手机物品有了但是华为不生产手机怎么办他需要找代工所以他们联系实体工厂吧自己的设计好的产品送过过这个时候代工的工厂开始工作在里面为我们生产一个个手机（这里生产手机的时候方法返回的是手机实体还是抽象的手机呢？）
代码就不粘贴了放一个图

图可能不太符合规定当时主要思想能看明白就结构模式

结构模型

适配器

适配器模式把别人的功能拿过来增强自己的功能比如包装字符流 InputStreamReader 这里就是将字节流可以用字符流的方式读取其中 private final StreamDecoder sd；这个就是适配器方法。
大概的意思什么呢；比如你要跟老外交流可以英语水平只有2级那么你就偷偷买了一个实时翻译的机器放到兜里面然后带上耳机当老外跟你说话的时候你通过翻译器翻译听懂了他说什么然后你说话通过翻译器同时他有知道你在说什么这样你们就可以无障碍的交流而代理/装饰者与他本质的区别就是你发现老外是个美女但是欧美人喜欢肌肉强壮的男人怎么办你只能增强你自己所以在你见美女之前你要去健身房先去锻炼一身腱子肉然后你再去跟美女深入交流发现了吧适配器就如其名要将两个功能通过第三方交流起来而代理/装饰者而是增强你自身的类的功能。
1 抽象翻译器

package adapter;public interface Machine {void palys();
}

2 实体类英文翻译器

package adapter;public class Simultaneous implements Machine {private final Translator JpmMoviePlayerAdapter = new Zh_EnglishTranslator();private final YourSelf machine;public Simultaneous(YourSelf machine) {this.machine = machine;}@Overridepublic void palys() {String paly = machine.paly();String s = JpmMoviePlayerAdapter.TranslatorEnglish(paly);System.out.println(s);}
}

3 你本体

package adapter;class YourSelf {public String paly() {System.out.println("相遇 。。。。");System.out.println("你说。。。。");return "你好";}
}

4 翻译器功能抽象

package adapter;public interface Translator {String TranslatorEnglish(String str);
}

5 翻译器实体功能

package adapter;public class Zh_EnglishTranslator implements Translator {@Overridepublic String TranslatorEnglish(String str) {if ("你好".equals(str)) {return "hello";}return "";}
}

6 使用

package adapter;public class Simultaneous implements Machine {private final Translator JpmMoviePlayerAdapter = new Zh_EnglishTranslator();private final YourSelf machine;public Simultaneous(YourSelf machine) {this.machine = machine;}@Overridepublic void palys() {String paly = machine.paly();String s = JpmMoviePlayerAdapter.TranslatorEnglish(paly);System.out.println(s);}
}

7 测试

package adapter;import proxy.dynamic.JdkProxy;public class MainTest {public static void main(String[] args) {YourSelf yourSelf = new YourSelf();Machine ch = new Simultaneous(yourSelf);ch.palys();//}
}

8 结果

9 但是你不甘心你想发生点什么你知道欧美女人喜欢强壮的但是你没有肌肉你又不能回炉重造所以你需要增强你自己咋办去健身房增强你自己

代理

静态代理/装饰者

动态代理

JDK动态代理

10 增强自己的方式就在健身房

package proxy.dynamic;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;public class JdkProxy<T> implements InvocationHandler {private final T tagert;public JdkProxy(T t) {tagert = t;}public T getProxy() {Object o =Proxy.newProxyInstance(tagert.getClass().getClassLoader(),tagert.getClass().getInterfaces(),new JdkProxy<>(tagert));return (T) o;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("锻炼身体");Object invoke = method.invoke(tagert, args);System.out.println("同意深入交流");return invoke;}
}

11 增强完成

package adapter;import proxy.dynamic.JdkProxy;public class MainTest {public static void main(String[] args) {YourSelf yourSelf = new YourSelf();Machine ch = new Simultaneous(yourSelf);JdkProxy<Machine> jdkProxy = new JdkProxy(ch);Machine proxy = jdkProxy.getProxy();proxy.palys();//}
}

12 结果

13 身体被掏空被抛弃完~~~ 撒花

动态代理静态代理还有装饰者主要的目的是强化本体而适配器主要是将两个功能适配一个对一个类一个是对两个类静态代理和装饰者就是一个意思要不然学的都蒙圈就当成正方形也是长方形就是因为特使这么理解把

cgilb动态代理

有时间可以自己区看下因为jdk 代理必须要有有接口如果你本类没有接口是代理不了的所有 cglib 可以再底层人家帮你去集成了你本类在你原来类方法不动的情况下增强你自己

桥接

意思有点像一整体你在思想上给他分开成不同的模块然后在桥接点进行耦合，接口隔离单一很像你这儿功能里面有很多维度（维度就是变化量比如时间维度距离维度）如果你将这些多维度东西放到一起最后实现起来耦合性很强有些时候是牵一发而动全身或者相互关联代码重复度高。所以要站在一定的高度对业务的理解上把他们抽象出去然后再一一实现然后再特定的地点进行组合模式的耦合

好比上面的图 1 所有的功能模块都柔和一个类中而图二则是抽象出来需要哪个关联哪个但是这个东西再创建功能之前就需要构思号要不然容易修改代码

1 抽象手机维度可以

package bridge;
/** 耦合点  也就是桥节点* */
public abstract class AbstrcatPhone {String phoneName;/**获得手机属性** */abstract String getPhone();
}

2 实体手机（创建对象可以练习用工厂的方式创建作为练习怎么写都不为过）

package bridge;public class Huawei extends AbstrcatPhone {@OverrideString getPhone() {super.phoneName = "huawei";return phoneName;}
}

3 抽象销售渠道

package bridge;
/** 桥接在此** */
public abstract class AbstractSale {String pirce;String Sale;public AbstractSale(String pirce, String sale) {this.pirce = pirce;Sale = sale;}
}

4 实体销售渠道线下

package bridge;public class Offline extends AbstractSale {public Offline(String pirce, String sale) {super(pirce, sale);}
}

5 线上

package bridge;public class Online extends AbstractSale {public Online(String pirce, String sale) {super(pirce, sale);}
}

6 抽象耦合点

package bridge;public abstract class BridgePoint {AbstrcatPhone phone;AbstractSale sale;public BridgePoint(AbstrcatPhone phone, AbstractSale sale) {this.phone = phone;this.sale = sale;}String getPhone() {return phone.phoneName + sale.pirce + sale.Sale;}
}

7 实体耦合点

package bridge;public class newPoint extends BridgePoint {public newPoint(AbstrcatPhone phone, AbstractSale sale) {super(phone, sale);}
}

8 调用

package bridge;public class MaintExst {public static void main(String[] args) {//AbstrcatPhone phone = new Huawei();phone.phoneName = "huawei";AbstractSale sale = new Offline("线下", "123");AbstractSale saleO = new Online("线上", "321");BridgePoint b = new newPoint(phone, saleO);String phone1 = b.getPhone();System.out.println(phone1);}
}

每个功能之间相互不影响需要就用不需要就不用迪米特隔离接口基本特征分功能引入你只要的

外观模式

组合模式

享元模式

连接池应用他跟原型模式区别一个是个返回的本类一个返回的克隆类克隆不是本类。主要核心是抽象出来的共享的元素然后非共享的元素可以放到实现类中取然后让简单工厂取加工返回一个这个元素的一个集合。好比一个公司相当于工厂类，需求经理过来要找程序员开发新的功能那么在这个公司内部的程序员就是属于一个池化一波人如果项目经理想开发这个功能就需要找一个程序员但是首先要判断一下他所找的程序员是否有任务如果有那么就得换一个如果都在摸鱼那么就得反馈给公司工厂在找一个。

1 抽象公共点

package flyweigth;public class AbstractFlyWeigth {Boolean isCanNotWork = true;String language;public void setCanNotWork(Boolean canNotWork) {isCanNotWork = canNotWork;}void Worke() {}public String getLanguage() {return language;}public void setLanguage(String language) {this.language = language;}
}

2 实体类除了公共还有不同点

package flyweigth;public class Dogs extends AbstractFlyWeigth {String name;public Dogs(String language, String name) {this.language = language;this.name = name;}public Dogs() {}@Overridepublic String toString() {return "Dogs{" + "language='" + language + '\'' + ", isCanNotWork=" + isCanNotWork + '}';}@Overridevoid Worke() {super.Worke();}
}

3 创造简单工厂去创造出来对象

package flyweigth;import javax.annotation.Nullable;
import java.util.HashMap;
import java.util.Map;public class _996Factory {public static Map<String, AbstractFlyWeigth> map = new HashMap<>();/** 目前 仅存存活的 员工* */static {Dogs dogsJava = new Dogs("java", "liergou");Dogs dogsJava1 = new Dogs("java", "zhangmeili");map.put("liergou", dogsJava);map.put("zhangmeili", dogsJava1);}public static void add(String tyep, String name) {Dogs dogsJava = new Dogs(tyep, name);map.put(tyep + name, dogsJava);}public static AbstractFlyWeigth get(@Nullable String type, String name) {/** 获取你想要的 员工* */AbstractFlyWeigth abstractFlyWeigth = map.get(name);if (abstractFlyWeigth != null) {if (abstractFlyWeigth.getLanguage().equals(type)) {return abstractFlyWeigth;}} /** 没有的话随机给你一个* */ else {for (AbstractFlyWeigth value : map.values()) {if (value.isCanNotWork) {value.setCanNotWork(false);System.out.println("ok");return value;} else {System.out.println("working .....");System.out.println("推荐下一个");}}}/** 都没有的话需要提加人了* */return null;}
}
4 测试 ```java
package flyweigth;public class MainTest {public static void main(String[] args) {////      需求1 要一个 javaAbstractFlyWeigth abstractFlyWeigth = _996Factory.get("", "java");System.out.println(abstractFlyWeigth);/*需求二也要一个java*/AbstractFlyWeigth abstractFlyWeigth1 = _996Factory.get("", "java");System.out.println(abstractFlyWeigth1);}
}

5 享元模式 + 策略模式可以使我们在判断 if if if 分别进入分支的时候有很好的支持我们每次获取享元创建出来的池对象然后分别执行我们业务代码这样可以将我们 if else 业务分离并且扩展也不会需要修改源代码。就此结构模式完结

行为模式

模板模式

将在抽象类父类里面实现一些公共的方法只是将一些需要子类实现的功能去自定义实现
换句话说就像把大象放冰箱总共分三步
抽象类父类实现第一步和第二步第三步暴露一个方法出去需要子类去重写覆盖并完成关键的第四步
第一步把冰箱门打开
第二部把大象装冰箱如何去装自己解决。

第三步把冰箱门关上

package template;public abstract class PutEle {public PutEle() {first();second();Three();}void first() {System.out.println("打开冰箱**");}void second() {}void Three() {System.out.println("冰箱门关闭");}
}

package template;public class PutIn extends PutEle {@Overridevoid second() {System.out.println("肢解。。。。。");}
}

package template;public class MainTest {public static void main(String[] args) {PutEle p = new PutIn();System.out.println(p);//}
}

打开冰箱**
肢解。。。。。
冰箱门关闭
template.PutIn@5a2e4553

策略模式

就是实现一个接口的公共方法无限的实现都是相同的类型然后依赖倒置在组合模式到一个 Context 方法中 set一个策略接口。
与状态模式不同因为不管谁来做都得第一第二第三步都是重复且确定的行为

状态模式

1 你早中晚的状态

package state;public abstract class AbstracState {public abstract void paly();public abstract AbstracState next();
}

2 下午状态

package state;public class YourAfter extends AbstracState {@Overridepublic void paly() {System.out.println("困睡觉 状态不行 。。。。");}@Overridepublic AbstracState next() {return new YourNight();}
}

3 早上状态

package state;public class YourMorning extends AbstracState {@Overridepublic void paly() {System.out.println("早起状态不好 3 秒");}@Overridepublic AbstracState next() {return new YourAfter();}
}

4 晚上状态

package state;public class YourNight extends AbstracState {@Overridepublic void paly() {System.out.println("逃避 。。。。");}@Overridepublic AbstracState next() {return new YourMorning();}
}

5 测试】

package state;public class MainText {public static void main(String[] args) {//System.out.println("媳妇来了。。。。");AbstracState abstracState = new YourMorning();abstracState.paly();System.out.println("媳妇来了。。。。");abstracState = abstracState.next();abstracState.paly();System.out.println("媳妇来了。。。。");abstracState = abstracState.next();abstracState.paly();}
}

媳妇来了。。。。
早起状态不好 3 秒
媳妇来了。。。。
困睡觉 状态不行 。。。。
媳妇来了。。。。
逃避 。。。。

中介者模式

将原来网状模式转化为星状模式
状态模式和策略模式很像但是策略模式是你本身想用哪个就用哪个策略没有流转也就是规定好的顺序但是状态模式又内部的规定就是哪一步下一个执行的是什么都是定好的流程框架用一般来说这样会不乱。

不管同事做什么事情都要先请示一下领导同意才能做如果没有领导的话每个人做事的时候都要先去问问所有的同事做过没有标记下然后在做这样很混乱

1。抽象领导主要是保存一个开关就是是否同意的锁然后还有保存这些同事所要做的事情是否可以的业务方法

package mediator;public abstract class Wcleader {boolean flag = true;abstract void setFlag(AbastractWorker state);
}

2 具体领导这里我把领导单例了要不然会出现所有事物都会同意的事情因为领导只有一个如果没有单例的话会出现咨询不同领导一件事情都同意的尴尬

package mediator;
/** 饿汉式单例 因为只能有一个领导** */
public class LeaderZhou extends Wcleader {private static final LeaderZhou leaderZhou = new LeaderZhou();private LeaderZhou() {}public static LeaderZhou getLeaderZhou() {return leaderZhou;}@Overridevoid setFlag(AbastractWorker state) {if ("leader".equals(state.state) && flag) {System.out.println("可以请假。。。。");flag = false;}else {System.out.println("不可以请假。。。。");}}
}

3 抽象同事这里主要保存着个状态就是他要做的事情和要做事情的具体步骤方法

package mediator;public abstract class AbastractWorker {String state;public abstract void getleave();
}

4 同事Li

package mediator;public class LiWorker extends AbastractWorker {public LiWorker(String state) {this.state = state;}@Overridepublic void getleave() {System.out.println("我想请假");}
}

5 同事Wang

package mediator;public class WangWorker extends AbastractWorker {public WangWorker(String state) {this.state = state;}@Overridepublic void getleave() {System.out.println("我想请假 。。。。");}
}

6 测试同时去领导请假但是工作很忙只会同意一个

package mediator;public class MainTest {public static void main(String[] args) {//LeaderZhou leaderZhou = LeaderZhou.getLeaderZhou();LiWorker liWorker = new LiWorker("leader");liWorker.getleave();leaderZhou.setFlag(liWorker);WangWorker wangWorker = new WangWorker("leader");wangWorker.getleave();leaderZhou.setFlag(wangWorker);}
}

我想请假
可以请假。。。。
我想请假 。。。。
不可以请假。。。。

观察者模式

这个通俗一点说就是一个相互关联的组件只要有一个变动就通知所有组件核心是将左右组件放到观察者的内部的一个list 中每次变动的时候都去foreach 这个 list挨个通知同样如果双向观察也是发现就会变动
单相观察者就是观察者有一个接收被观察着的方法被观察者收集着观察者的信息一旦变动就是方法背调用那么就遍历观察者列表去发送通知
我这里有一个双向观察者的例子单相就一个一个发送一个接收双向是两个发送两个接收

1 。抽象警察

package obsever;public interface Police {void addthief(Thief thief);/** 发送通知  观察者的关键* */void arrest(String msg);/** 接收通知* */void accpet(String msg);
}

2 实例化警察

package obsever;import java.util.ArrayList;
import java.util.List;public class WangPolicy implements Police {// 添加 小偷的信息也就是观察者private final List<Thief> ThiefList = new ArrayList<>();
//添加方法 @Overridepublic void addthief(Thief thief) {ThiefList.add(thief);}/** 无间道 小偷卧底  发送给小偷信息* */@Overridepublic void arrest(String msg) {for (Thief thief : ThiefList) {//System.out.println("卧底A");thief.accpet(msg);}}
//接收小偷信息@Overridepublic void accpet(String msg) {System.out.println(msg + "通知 卧底A");}
}

3 抽象小偷

package obsever;public interface Thief {void addPolice(Police police);/** 发送通知* */void flee(String msg);/** 接收通知* */void accpet(String msg);
}

4 实例化小偷和警察一样

package obsever;import java.util.ArrayList;
import java.util.List;public class WangPolicy implements Police {//添加联系警察的信息private final List<Thief> ThiefList = new ArrayList<>();
/真正的添加方法@Overridepublic void addthief(Thief thief) {ThiefList.add(thief);}/** 无间道 发送给警察信息* */@Overridepublic void arrest(String msg) {for (Thief thief : ThiefList) {//System.out.println("卧底A");thief.accpet(msg);}}
// 接收警察信息@Overridepublic void accpet(String msg) {System.out.println(msg + "通知 卧底A");}
}

5 测试

package obsever;public class MainTest {public static void main(String[] args) {//Police police = new WangPolicy();Thief thief = new LiThief();police.addthief(thief);thief.addPolice(police);police.arrest("有内鬼活动终止");thief.flee("收到");}
}

卧底A
卧底 A有内鬼活动终止
收到我已暴露

访问者模式

访问者模式抽象元素实体元素抽象访问者实体访问者还有对象构造
不用修改源代码就能改变最主要的因素是只在对象构造中将实体访问者和实体元素耦合通过组合的模式把实体元素引入到访问者内部通过访问者的方法去修改其内部的属性当执行耦合方法后就会替换原来的内容

核心就是要在第三方也就是你这个一堆元素组成的整体对象构造内部去修改
1 。抽象元素

package visitor;
/** 抽象元素* */
public abstract class AbastrictElement {/** 指令* */String Commands;/** 工作* */public AbastrictElement(String Commands) {this.Commands = Commands;}abstract void work();
}

2 实体CPU

package visitor;public class Cpu extends AbastrictElement {public Cpu(String Commands) {super(Commands);}@Overridevoid work() {System.out.println("Cpu 指令执行" + Commands);}
}

3 实体硬盘

package visitor;public class Disk extends AbastrictElement {public Disk(String Commands) {super(Commands);}@Overridevoid work() {System.out.println("磁盘落盘 " + Commands);}
}

4 抽象访问者

package visitor;public abstract class AbastrictVisitor {abstract void cpuUpDate(AbastrictElement abastrictElement);abstract void diskUpDate(AbastrictElement abastrictElement);
}

5 实体访问者

package visitor;public class Up extends AbastrictVisitor {@Overridevoid cpuUpDate(AbastrictElement abastrictElement) {abastrictElement.Commands = "aaa";}@Overridevoid diskUpDate(AbastrictElement abastrictElement) {abastrictElement.Commands = "bbb";}
}

6 构造对象就是组合成你的物品

package visitor;public class Pc {Cpu cpu = new Cpu("哒哒哒开机");Disk disk = new Disk("轰隆 粗存");public Pc() {}void getWork() {cpu.work();Qdisk.work();}void updatePc(AbastrictVisitor visitor) {visitor.diskUpDate(disk);visitor.cpuUpDate(cpu);}
}