当前位置:   article > 正文

java设计模式(1) 适配器模式、装饰器模式、策略模式、观察者模式_适配器模式和装饰器模式

适配器模式和装饰器模式

适配器模式

适配器就是一种适配中间件,它存在于不匹配的了两者之间,用于连接两者,使不匹配变得匹配。

手机充电需要将220V的交流电转化为手机锂电池需要的5V直流电

知识补充:手机充电器输入的电流是交流,通过变压整流输出电流是直流的。。

类适配器

️2️⃣Adaptee 源角色   :220V的交流电(家用电一般是220V)  

  1. //家用电压
  2. public class HomeElectri {
  3. //输出220v交流电,AC指的是交流电
  4. public int outputAC220V() {
  5. int output = 220;
  6. return output;
  7. }
  8. }

1️⃣Target 目标角色 :  手机锂电池需要的5V直流电

目标类只需要定义方法,由适配器来转化:

  1. //手机充电接口
  2. public interface MobileCharge {
  3. //需要5v的直流电
  4. //DC指的是直流电
  5. int outputDC5V();
  6. }

3️⃣Adapter 适配器角色  :手机充电器

我为什么这么写,又去继承又去实现的?

          作为适配器,需要拿到俩边的资源。通过继承拿到源角色的能力(输出220V)通过实现接口,知道自己的目的角色。

  1. //手机的适配器(手机充电器)
  2. public class PhoneAdapter extends HomeElectri implements MobileCharge {
  3. @Override
  4. public int outputDC5V() {
  5. int output = outputAC220V();
  6. return (output / 44);
  7. }
  8. }

对象适配器

不继承HomeElectri 类,而是持有HomeElectri 类的实例

提供一个包装类Adapter,这个包装类包装了一个Adaptee的实例,从而此包装类能够把Adaptee的API与Target类的API链接起来。

  1. //手机的适配器(手机充电器)
  2. public class PhoneAdapter implements MobileCharge {
  3. HomeElectri homeElectri;
  4. public PhoneAdapter(HomeElectri homeElectri) {
  5. this.homeElectri = homeElectri;
  6. }
  7. @Override
  8. public int outputDC5V() {
  9. int output = homeElectri.outputAC220V();
  10. return (output / 44);
  11. }
  12. }
  1. PhoneAdapter adapter=new PhoneAdapter(new HomeElectri());
  2. System.out.println("输出电压: "+adapter.outputDC5V());


接口适配器

接口的适配器是这样的:接口中往往有多个抽象方法,但是我们写该接口的实现类的时候,必须实现所有这些方法,这明显有时比较浪费,因为并不是所有的方法都是我们需要的,有时只需要某一些,

如:MouseListener是一个接口,里面有鼠标的各种事件

  1. public interface MouseListener extends EventListener {
  2. public void mouseClicked(MouseEvent e);
  3. public void mousePressed(MouseEvent e);
  4. public void mouseReleased(MouseEvent e);
  5. public void mouseEntered(MouseEvent e);
  6. public void mouseExited(MouseEvent e);
  7. }

此处为了解决这个问题,我们引入了接口的适配器模式,借助于一个抽象类,该抽象类实现了该接口,实现了所有的方法

MouseAdapter有2个特点

第一:它是抽象类。

第二:每个方法MouseAdapter都做了空实现

  1. public abstract class MouseAdapter implements MouseListener, MouseWheelListener, MouseMotionListener {
  2. public void mouseClicked(MouseEvent e) {}
  3. public void mousePressed(MouseEvent e) {}
  4. public void mouseReleased(MouseEvent e) {}
  5. public void mouseEntered(MouseEvent e) {}
  6. public void mouseExited(MouseEvent e) {}
  7. public void mouseWheelMoved(MouseWheelEvent e){}
  8. public void mouseDragged(MouseEvent e){}
  9. public void mouseMoved(MouseEvent e){}
  10. }

而我们不和原始的接口打交道,只和该抽象类取得联系,所以我们写一个类,继承该抽象类,重写我们需要的方法就行

addMouseListener()这个方法需要MouseListener的一个参数

  1. JButton jButton = new JButton("点我有惊喜");
  2. jButton.addMouseListener(new MouseAdapter() {
  3. @Override
  4. public void mouseClicked(MouseEvent e) {
  5. System.out.println("惊不惊喜,意不意外");
  6. }
  7. });

装饰器模式

装饰模式核心

装饰器的核心就是在不改原有类的基础上给类新增功能。。

1.装饰模式是继承的一个替代模式,通过组的方式完成继承的功能,但却避免了继承的侵入性

2.装饰类和被装饰类可以独立发展,不会相互耦合


原有类[被装饰]

原有的:

  1. //制作蛋糕
  2. public interface MakCake {
  3. //cake -蛋糕
  4. void createCake();
  5. }

它的实现类

  1. public class MakeCakeImpl implements MakCake {
  2. //制作蛋糕的通用基础逻辑
  3. @Override
  4. public void createCake() {
  5. System.out.println("使用面粉、鸡蛋、牛奶等...制作一个基础蛋糕");
  6. }
  7. }

抽象装饰器

抽象装饰器(Decorator): 通用的装饰的装饰器,其实现一般是一个抽象类。

被装饰类[MakeCakeImpl]和所有的装饰类【CakeDecorator、FruitAddDecorator、BiscuitAddDecorator ] 必须实现同一个接口[MakCake]

1、而且必须持有被装饰的对象[MakCake的引用],这样,装饰器可以调用MakeCake的方法,也可以选择性的添加自己的行为。

2、可以无限装饰,在运行时为对象添加多个装饰器,从而组合出不同的功能

  1. //制作蛋糕的抽象装饰器
  2. public abstract class CakeDecorator implements MakCake{
  3. private MakCake makCake;
  4. public CakeDecorator(MakCake makCake) {
  5. this.makCake = makCake;
  6. }
  7. @Override
  8. public void createCake() {
  9. makCake.createCake();
  10. }
  11. }

装饰器实现的重点是对抽象类继承接口方式的使用,同时设定被继承的接口可以通过构造函数传递其实现类,由此增加扩展性并重写方法里可以实现此部分父类实现的功能。


具体装饰器

具体装饰器(Concrete Decorator):向“制作蛋糕”添加新的职责

给蛋糕添加水果

  1. public class FruitAddDecorator extends AbsCakeDecorator{
  2. public FruitAddDecorator(MakCake makCake) {
  3. super(makCake);
  4. }
  5. @Override
  6. public void createCake() {
  7. super.createCake();
  8. decorateMethod();
  9. }
  10. // 定义自己的修饰逻辑
  11. private void decorateMethod() {
  12. System.out.println("加一份新鲜的水果,如草莓...");
  13. }
  14. }

给蛋糕添加饼干

  1. public class BiscuitAddDecorator extends AbsCakeDecorator {
  2. public BiscuitAddDecorator(MakCake makCake) {
  3. super(makCake);
  4. }
  5. @Override
  6. public void createCake() {
  7. super.createCake();
  8. decorateMethod();
  9. }
  10. // 定义自己的修饰逻辑
  11. private void decorateMethod() {
  12. System.out.println("加一份好吃的饼干,如奥利奥...");
  13. }
  14. }

测试

  1. public static void main(String[] args) {
  2. //制作最基础的蛋糕面饼
  3. MakCake cake = new MakeCakeImpl();
  4. //为蛋糕添加水果
  5. cake= new FruitAddDecorator(cake);
  6. cake.createCake();
  7. }

控制台:


无限装饰

什么是无限装饰?使用装饰器模式一层一层的对最底层被包装类进行功能扩展了。 

  • 对一个对象进行多次装饰,通过使用不同的具体装饰类以及这些装饰类的排列组合,可以创造出很多不同行为的组合,得到功能更为强大的对象。
  1. public static void main(String[] args) {
  2. //制作最基础的蛋糕面饼
  3. MakCake cake = new MakeCakeImpl();
  4. //为蛋糕添加水果
  5. cake= new FruitAddDecorator(cake);
  6. // 第二次修饰,蛋糕添加饼干
  7. cake = new BiscuitAddDecorator(cake);
  8. cake.createCake();
  9. }

先看结果,打印的顺序和编写代码的顺序是一致的

说实话:看着好像java的缓存流,对基层的io流做了装饰

最后一行调用的时候:cake.createCake()做啥了???

 此时cake是BiscuitAddDecorator的引用

1. 会先调用BiscuitAddDecorator的createCake方法,

2. 走super的createCake(),进入其父类AbsCakeDecorator的方法

3.1 从idea提示看的出此时makCake是FruitAddDecorator的实例(被装饰的对象)那么接着进入FruitAddDecorator的createCake()

3.2.走super的createCake(),再进入AbsCakeDecorator,此时makCake是MakeCakeImpl

的实例

 3.3.进入MakeCakeImpl,控制台打印输出

打印完成后回到3.1,再打印输出

 再回到第一步,BiscuitAddDecorator的createCake(),打印输出

 new 构造器分析

如上,再new装饰器的时候,构造器做啥了 

  1. //为蛋糕添加水果
  2. cake= new FruitAddDecorator(cake);

1 进入FruitAddDecorator 

2 AbsCakeDecorator中的makCake赋值为MakeCakeImpl的实例

-----------------------------------

 代码再走一行

  1. // 第二次修饰,蛋糕添加饼干
  2. cake = new BiscuitAddDecorator(cake);

3. 进入BiscuitAddDecorator

4.又进入父类AbsCakeDecorator,AbsCakeDecorator中的makCake赋值为FruitAddDecorator的实例


在java哪里见过

Decorator模式的目的就是把一个一个的附加功能,用Decorator的方式给一层一层地累加到原始数据源上,最终,通过组合获得我们想要的功能

例子一:给FileInputStream增加缓冲和解压缩功能,用Decorator模式写出来如下:

  1. // 创建原始的数据源:
  2. InputStream fis = new FileInputStream("test.gz");
  3. // 增加缓冲功能:
  4. InputStream bis = new BufferedInputStream(fis);
  5. // 增加解压缩功能:
  6. InputStream gis = new GZIPInputStream(bis);

BufferedInputStreamGZIPInputStream,它们实际上都是从FilterInputStream继承的,这个FilterInputStream就是一个抽象的Decorator。

Decorator模式有什么好处?它实际上把核心功能和附加功能给分开了

核心功能指FileInputStream这些真正读数据的源头,附加功能指加缓冲、压缩、解密这些功能。而具体如何附加功能,由调用方自由组合,从而极大地增强了灵活性。

例子二:安全的并发容器类SynchronizedList,比如

List<Object> synchronizedList = Collections.synchronizedList(new ArrayList<>());

Decorator使用场景

场景举例一:

假设我们需要渲染一个HTML的文本,但是文本还可以附加一些效果,比如加粗、变斜体、加下划线等。为了实现动态附加效果,可以采用Decorator模式。

场景举例二:

假设电商平台上有各种商品可以卖,有些商品需要提供定制化的服务,如礼品包装、定制化贺卡等等。这时候可以使用装饰器模式,对商品进行装饰以提供相应服务。

场景举例三:

一个煎饼摊,煎饼可以加鸡蛋、加香肠,计算最终的价格,我们如何实现?


代理模式

代理模式核心

代理模式的特点在于隔离:隔离调用类和被调用类的关系,通过一个代理类去调用。代理模式主要目的是控制对象的访问,并在不改变原对象的前提下增加额外的功能(如权限检查、日志记录),也常用于延迟加载,只有当真正需要的时候才会创建真实对象。


静态代理

被代理对象与代理对象需要实现相同的接口或者是继承相同父类,因此要

定义一个接口或抽象类。

  1. public interface Calculator {
  2. int add(int i, int j);
  3. }

接口的实现类

  1. public class CalculatorImpl implements Calculator {
  2. @Override
  3. public int add(int i, int j) {
  4. int result = i + j;
  5. return result;
  6. }
  7. }

现在想要在add方法执行之前,执行后打印返回结果。做一个增强,很容易想到这么做。。但是一看就不符合开闭原则。。

增加一个代理类,在代理类里打印日志,在代理类里去调用目标对象的方法

  1. public class CalculatorProxy implements Calculator{
  2. private CalculatorImpl calculatorImpl;
  3. public CalculatorProxy(CalculatorImpl calculatorImpl) {
  4. this.calculatorImpl = calculatorImpl;
  5. }
  6. @Override
  7. public int add(int i, int j) {
  8. System.out.println("[日志] add 方法执行前,参数是:" + i + "," + j);
  9. int result = calculatorImpl.add(i, j);
  10. System.out.println("[日志] add 方法结束,运算结果是:" + result);
  11. return result;
  12. }
  13. }

测试:

  1. public static void main(String[] args) {
  2. //创建目标对象
  3. CalculatorImpl calculator = new CalculatorImpl();
  4. //创建代理对象
  5. CalculatorProxy calculatorProxy = new CalculatorProxy(calculator);
  6. //使用代理对象去调用方法,隔离目标对象和客户端
  7. calculatorProxy.add(1,3);
  8. }


jdk动态代理

jdk动态代理是基于接口的一种代理方式,目标对象一定要实现接口。

原理是,利用反射机制,动态生成匿名类继承Proxy类并且实现了要代理的接口

cglib动态代理


策略模式

很多个if...else

通过页面传来的type值,需要返回不同的下拉框内容,我们先用很多个if...else实现。如下:

  1. public class Test {
  2. public static void main(String[] args) {
  3. String type = "选择基点";
  4. String[] conext = getSelectConext(type);
  5. //打印返回的string数组
  6. Arrays.stream(conext).forEach(System.out::println);
  7. }
  8. public static String[] getSelectConext(String type) {
  9. if (type.equals("判断条件")) {
  10. return new String[]{"大于", "小于", "等于", "大于等于", "小于等于"};
  11. } else if (type.equals("点击方式")) {
  12. return new String[]{"左键单击", "左键双击", "右键单击", "右键双击"};
  13. } else if (type.equals("选择基点")) {
  14. return new String[]{"左上", "左下", "中心", "右上", "右下"};
  15. }
  16. return null;
  17. }
  18. }

缺点:当传入不同的type类型的时候,我们需要继续增加else if。。。


引入策略模式

创建一个接口,该接口针对不同的type。会使用不同的实现类返回对应的内容

  1. //下拉框内容
  2. public interface ComboBoxContent {
  3. public String[] dropDownlist();
  4. }

创建完成后,就是感觉类有点爆炸(多)。但是可以很好的满足隔离性扩展性需求,方便承接不断新增的需求

三个实现类

  1. //判断条件
  2. public class JudgeConditionComboBox implements ComboBoxContent{
  3. @Override
  4. public String[] dropDownlist() {
  5. return new String[]{"大于", "小于", "等于", "大于等于", "小于等于"};
  6. }
  7. }
  8. //---------------------------------------
  9. //点击方式
  10. public class ClickWayComboBox implements ComboBoxContent{
  11. @Override
  12. public String[] dropDownlist() {
  13. return new String[]{"左键单击", "左键双击", "右键单击", "右键双击"};
  14. }
  15. }
  16. //---------------------------------------
  17. //选择基点
  18. public class BasePointComboBox implements ComboBoxContent{
  19. @Override
  20. public String[] dropDownlist() {
  21. return new String[]{"左上", "左下", "中心", "右上", "右下"};
  22. }
  23. }

场景一:map结构获取策略

  1. public class ComboBoxStrategyFactory {
  2. private static final Map<String, ComboBoxContent> map = new HashMap<>();
  3. static {
  4. map.put("判断条件", new JudgeConditionComboBox());
  5. map.put("点击方式", new ClickWayComboBox());
  6. map.put("选择基点", new BasePointComboBox());
  7. }
  8. public static ComboBoxContent getStrategy(String type) {
  9. return map.get(type);
  10. }
  11. }

改造之前

----------------------------------

改造后:


场景二:context指定策略

策略模式的控制类[Context]主要是外部可以传递不同的策略实现,再通过统一的方法执行策略计算。

  1. //上下文类
  2. public class ContextComboBox {
  3. private ComboBoxContent comboBoxContent;
  4. public ContextComboBox(ComboBoxContent comboBoxContent) {
  5. this.comboBoxContent = comboBoxContent;
  6. }
  7. //真正对外暴露的接口
  8. public String[] getComboBoxList() {
  9. //通过不同接口实现类调用具体的策略
  10. return comboBoxContent.dropDownlist();
  11. }
  12. }

比如:awt的布局管理器,用户在构建界面的时候指定要使用的布局管理器


观察者模式

观察者模式定义

观察者模式的定义:观察者模式结构中主要包括观察目标(Object)和观察者(Observer

一个目标对象可被多个观察者对象同时监听,使得每当目标对象状态变化时,所有依赖于它的观察者对象都会得到通知并被自动更新。此种模式通常被用来实时事件处理系统。


Subject 

Subject里面有要通知的观察者们,定义为一个<Observer> observers 。

  1. public class Subject {
  2. private List<Observer> observers = new ArrayList<Observer>();
  3. private int state;
  4. public int getState() {
  5. return state;
  6. }
  7. public void setState(int state) {
  8. this.state = state;
  9. // 通知所有的观察者,调用notifyall()方法
  10. notifyAllObservers();
  11. }
  12. public void add(Observer observer) {
  13. observers.add(observer);
  14. }
  15. public void notifyAllObservers() {
  16. for (Observer observer : observers) {
  17. // 更新每一个观察者查看的信息
  18. observer.update();
  19. }
  20. }
  21. }

这些观察者都得有update方法,这样在被通知的时候就能去更新了。

怎么保证Observer每一个都有这个方法呢,是不是可以考虑把Observer去继承一个抽象类,里面写一个update()抽象方法,让每一个观察者去继承这个Observer抽象类即可。


Observer

Observer抽象类

  1. public abstract class Observer {
  2. // 把一个类放进抽象类中意义:其实与普通类中放进去道理一样
  3. public Subject subject;
  4. // 定义抽象类,由实现类实现
  5. public abstract void update();
  6. }

第一个观察者:二进制

  1. //二进制
  2. public class BinaryObserver extends Observer {
  3. public BinaryObserver(Subject subject) {
  4. this.subject = subject;
  5. this.subject.add(this);
  6. }
  7. @Override
  8. public void update() {
  9. //二进制方式输出数字
  10. System.out.println("二进制观察者,接收到新的数字: " + subject.getState() + ";并做出对应的处理,处理结果:" + Integer.toBinaryString(subject.getState()));
  11. }
  12. }

第二个观察者:八进制

  1. //八进制
  2. public class OctalObserver extends Observer {
  3. public OctalObserver(Subject subject) {
  4. this.subject = subject;
  5. this.subject.add(this);
  6. }
  7. @Override
  8. public void update() {
  9. //八进制方式输出数字
  10. System.out.println("八进制观察者,接收到新的数字: " + subject.getState() + ";并做出对应的处理,处理结果:" + Integer.toOctalString(subject.getState()));
  11. }
  12. }

第三个观察者:十六进制

  1. //十六进制
  2. public class HexaObserver extends Observer {
  3. public HexaObserver(Subject subject) {
  4. this.subject = subject;
  5. this.subject.add(this);
  6. }
  7. @Override
  8. public void update() {
  9. //十六进制方式输出数字
  10. System.out.println("十六进制观察者,接收到新的数字: " + subject.getState() + ";并做出对应的处理,处理结果:" + Integer.toHexString(subject.getState()));
  11. }
  12. }

功能测试

  1. public class Test {
  2. public static void main(String[] args) {
  3. Subject subject = new Subject();
  4. //添加二进制观察者
  5. new BinaryObserver(subject);
  6. //添加八进制观察者
  7. new OctalObserver(subject);
  8. //添加十六进制观察者
  9. new HexaObserver(subject);
  10. System.out.println("First state change: 15");
  11. subject.setState(15);
  12. System.out.println("------------------------------------------");
  13. System.out.println("Second state change: 10");
  14. subject.setState(10);
  15. System.out.println("------------------------------------------");
  16. System.out.println("Third state change: 5");
  17. subject.setState(5);
  18. }
  19. }


观察者模式变种

声明:本文内容由网友自发贡献,转载请注明出处:【wpsshop】
推荐阅读
相关标签
  

闽ICP备14008679号