1. 适配器模式
适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。也称包装器(Wrapper)，属于结构型模式。适配器模式主要分为三类：类适配器模式、对象适配器模式、接口适配器模式
简单来说，适配器模式就像个插头转换器，让不同标准的插头和插座可以一起使用，而插座就是原来的接口，插头是用户期望的接口。或者类比电源适配器，把原来的220V电压转换成5V电压等。
1.1 类适配器
以类来继承和实现接口的方式，来获取被适配类的信息并转换输出重写到适配接口。
例:
//目标接口
public interface Mb {
int five();
}
//被适配的类
public class Yuan {
/*
提供220v的电压
* */
public int getDy(){
return 220;
}
}
//适配器类
public class ChongDianQi extends Yuan implements Mb {
public int five() {
// 把交流电 转化为 直流电 5v
int dy = getDy();
//
System.out.println("转化为直流电");
return dy/44;
}
}
public class MyTest {
//类适配测试
@Test
public void testLei(){
ChongDianQi chongDianQi=new ChongDianQi();
int five = chongDianQi.five();
System.out.println("直流电的电压是:"+five+"v");
}
}结果:
1.2 对象适配器
对象适配器是通过实例对象（构造器传递）来实现适配器，而不是再用继承，其余基本同类适配器。
例:
//目标接口
public interface Mb {
int five();
}
public class Yuan {
/*
提供220v的电压
*被适配的类
* */
public int getDy(){
return 220;
}
}
//适配器类
public class ChongDianQi1 implements Mb {
private Yuan yuan = new Yuan();
public int five() {
// 把交流电 转化为 直流电 5v
int dy = yuan.getDy();
//
System.out.println("转化为直流电");
return dy/44;
}
}
public class MyTest {
//类适配测试
@Test
public void testduixiang() {
ChongDianQi1 chongDianQi = new ChongDianQi1();
int five = chongDianQi.five();
System.out.println("直流电的电压是:" + five + "v");
}
}结果:
1.3 接口适配器
接口适配器适用于一个接口不想使用其所有的方法的情况。当不需要实现全部接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地重写父类的某些方法来实现需求
例:
// 目标接口
public interface IDCOutput {
int output5V();//手机 5v
int output10V();//电脑 10v
int output20V();//苹果电脑 20v
}
// 空实现 方法
public abstract class DefaultChongDainQi implements IDCOutput{
public int output5V() {
return 0;
}
public int output10V() {
return 0;
}
public int output20V() {
return 0;
}
}
//被适配的类
public class Yuan {
/*
提供220v的电压
* */
public int getDy(){
return 220;
}
}
//继承 重写父类中的空方法
public class DiannaoChongdianQi extends DefaultChongDainQi{
private Yuan yuan = new Yuan();
@Override
public int output10V() {
int dy = yuan.getDy();
System.out.println("转化为直流电");
return dy/22;
//
}
}
public class MyTest {
//类适配测试
@Test
public void testjiekou() {
DiannaoChongdianQi chongDianQi = new DiannaoChongdianQi();
int five = chongDianQi.output10V();
System.out.println("直流电的电压是:" + five + "v");
}
}结果:
1.4 总结
类适配器： 继承源类(原始类)实现目标接口
对象适配器： 适配器和源是组合关系
接口适配器： 抽象类空实现接口中的所有的方法 具体的适配器根据需要取重写方法
2. 策略模式
策略模式：策略模式是一种行为型模式，它将对象和行为分开，将行为定义为 一个行为接口 和 具体行为的实现。策略模式最大的特点是行为的变化，行为之间可以相互替换。
结构: 策略模式有三个角色
1. 抽象策略（Strategy）类：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
2. 具体策略（Concrete Strategy）类：实现了抽象策略定义的接口，提供具体的算法实现或行为。
3. 环境（Context）类：持有一个策略类的引用，最终给客户端调用
例:
//抽象策略（Strategy）类
public interface Celue {
//活动策略
void huodong();
}
//具体策略（Concrete Strategy）类
public class DuanWudong implements Celue{
//继承抽象策略类，实现接口方法
//端午节优惠活动
public void huodong() {
System.out.println("买二送一");
}
}
//具体策略（Concrete Strategy）类
public class ChunjieHuodong implements Celue{
//继承抽象策略类，实现接口方法
//春节优惠活动
public void huodong() {
System.out.println("送洗衣粉");
}
}
//环境（Context）类
public class SaleMan {
// 持有策略
private Celue celue;
public void showCelue(){
celue.huodong();
}
public Celue getCelue() {
return celue;
}
public void setCelue(Celue celue) {
this.celue = celue;
}
}
//客户端调用
public class MyTest {
@Test
public void celuetest(){
SaleMan saleMan = new SaleMan();
// 策略
Celue chunjieHuodong = new DuanWudong();
saleMan.setCelue(chunjieHuodong);// 领导下发了命令
saleMan.showCelue();
}
}结果:
总结:
策略模式是一种行为型设计模式，它定义了一系列的算法，并将每一个算法封装起来，使它们可以互相替换。这种模式使得算法可以独立于使用它的客户端变化。策略模式的主要目的是通过定义一系列的算法，并将每一个算法封装起来，使得它们可以相互替换，从而让算法的变化不会影响到使用算法的用户。这种模式特别适用于那些需要根据不同的情境或参数变化而改变自身行为的场景。
3. 发布订阅
观察者(Observer)，又称发布-订阅（Publish-Subscrice）。发布订阅模式是一种行为型模式, 发布订阅模式定义了一种一对多的依赖关系，让多个订阅者对象同时监听某一个主题对象。这个主题对象在自身状态变化时，会通知所有订阅者对象，使它们能够自动更新自己的状态。
结构: 观察者模式有四个角色
1. Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
2. ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
3. Observer：抽象观察者，是观察者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
4. ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。
例:
//Observer：抽象观察者
public interface Observe {
void getMsg(String msg);
}
//ConcreteSubject：具体主题（具体被观察者）
public class WeixinYonghu implements Observe {
public WeixinYonghu(String name) {
this.name = name;
}
private String name;
public void getMsg(String msg) {
System.out.println(name + "接收的消息是:");
System.out.println(msg);
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//Subject：抽象主题（抽象被观察者）
public interface Zhuti {
/*
* 所有的观察者
* 添加观察者
* 删除观察者
* 发布消息
* */
void addguancha(Observe observe);
void removeguancha(Observe observe);// 删除观察者
void tongzhiguancha();
}
//ConcrereObserver：具体观察者
public class WeixinGongZhongHao implements Zhuti{
String name;
// 公众号:用户 = 1：m
// observeList 用于存放观察者
private List<Observe> observeList = new ArrayList<Observe>();
// 知道观察者 是谁
// 点击关注公众号
public void addguancha(Observe observe) {
observeList.add(observe);
}
// q取消关注
public void removeguancha(Observe observe) {
// observe 从观者者的队列中移除
observeList.remove(observe);
}
//
public void tongzhiguancha() {
String msg="我是谁";
// 通知所有的观察者
for (Observe observe1 : observeList) {
observe1.getMsg(name+"公众号发布了一篇文章:"+msg);
}
}
public WeixinGongZhongHao(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
//实现观察者模式
public class Test {
@org.junit.jupiter.api.Test
public void testGuanCha(){
// 创建微信用户
WeixinYonghu zs = new WeixinYonghu("张三");
WeixinYonghu ls = new WeixinYonghu("李四");
WeixinYonghu ww = new WeixinYonghu("wangwu");
WeixinYonghu zl = new WeixinYonghu("赵六");
//
WeixinGongZhongHao pfyh = new WeixinGongZhongHao("浦发银行");
// 一个公众号设置了 四个观察者
pfyh.addguancha(zs);
pfyh.addguancha(ls);
pfyh.addguancha(ww);
pfyh.addguancha(zl);
//被删除后 不在接收消息
pfyh.removeguancha(ls);
//观察者接收消息
pfyh.tongzhiguancha();
}
}
结果:
总结:
在这种模式中，发布者负责发布消息，而订阅者则可以选择订阅他们感兴趣的消息类型。当有新消息发布时，订阅者将收到通知并执行相应的操作。这种模式的关键在于实现了一种松耦合的通信机制，使得发布者和订阅者之间不需要直接交互，而是通过消息传递来实现通信。
1081
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
