精华内容
下载资源
问答
  • 23种设计模式详解
    万次阅读
    2018-12-08 11:28:31

    基础知识

     

    设计模式概述

    从招式与内功谈起——设计模式概述(一):设计模式从何而来?

    从招式与内功谈起——设计模式概述(二):设计模式是什么?

    从招式与内功谈起——设计模式概述(三):设计模式有什么用?附:个人观点

     

    面向对象设计原则

    面向对象设计原则概述

    面向对象设计原则之单一职责原则

    面向对象设计原则之开闭原则

    面向对象设计原则之里氏代换原则

    面向对象设计原则之依赖倒转原则

    面向对象设计原则之接口隔离原则

    面向对象设计原则之合成复用原则

    面向对象设计原则之迪米特法则

     

    六个创建型模式

     

    简单工厂模式-Simple Factory Pattern

    工厂三兄弟之简单工厂模式(一):图表库的设计

    工厂三兄弟之简单工厂模式(二):简单工厂模式概述

    工厂三兄弟之简单工厂模式(三):图表库的简单工厂模式解决方案

    工厂三兄弟之简单工厂模式(四):图表库解决方案的改进,简单工厂模式的简化,简单工厂模式总结

     

    工厂方法模式-Factory Method Pattern

    工厂三兄弟之工厂方法模式(一):日志记录器的设计

    工厂三兄弟之工厂方法模式(二):工厂方法模式概述

    工厂三兄弟之工厂方法模式(三):日志记录器的工厂方法模式解决方案,反射与配置文件

    工厂三兄弟之工厂方法模式(四):重载的工厂方法,工厂方法的隐藏,工厂方法模式总结

     

    抽象工厂模式-Abstract  Factory Pattern

    工厂三兄弟之抽象工厂模式(一):界面皮肤库的初始设计

    工厂三兄弟之抽象工厂模式(二):产品等级结构与产品族

    工厂三兄弟之抽象工厂模式(三):抽象工厂模式概述

    工厂三兄弟之抽象工厂模式(四):界面皮肤库的抽象工厂模式解决方案

    工厂三兄弟之抽象工厂模式(五):“开闭原则”的倾斜性,抽象工厂模式总结

     

    单例模式-Singleton Pattern

    确保对象的唯一性——单例模式 (一):单例模式的动机,单例模式概述

    确保对象的唯一性——单例模式 (二):负载均衡器的设计与实现

    确保对象的唯一性——单例模式 (三):饿汉式单例与懒汉式单例的讨论

    确保对象的唯一性——单例模式 (四):一种更好的单例实现方法(静态内部类)

    确保对象的唯一性——单例模式 (五):单例模式总结

     

    原型模式-Prototype Pattern

    对象的克隆——原型模式(一):大同小异的工作周报,原型模式概述

    对象的克隆——原型模式(二):工作周报的原型模式解决方案

    对象的克隆——原型模式(三):带附件的周报【浅克隆,深克隆】

    对象的克隆——原型模式(四):原型管理器的引入和实现,原型模式总结

     

    建造者模式-Builder Pattern

    复杂对象的组装与创建——建造者模式(一):游戏角色设计,建造者模式概述

    复杂对象的组装与创建——建造者模式(二):游戏角色设计的建造者模式解决方案

    复杂对象的组装与创建——建造者模式(三):关于Director的进一步讨论,建造者模式总结

     

     

    七个结构型模式

     

    适配器模式-Adapter Pattern

     

    不兼容结构的协调——适配器模式(一):没有源码的算法库,适配器模式概述

    不兼容结构的协调——适配器模式(二):没有源码的算法库的适配器模式解决方案

    不兼容结构的协调——适配器模式(三):类适配器,双向适配器

    不兼容结构的协调——适配器模式(四):缺省适配器,适配器模式总结

     

    桥接模式-Bridge Pattern

    处理多维度变化——桥接模式(一):跨平台图像浏览系统

    处理多维度变化——桥接模式(二):桥接模式概述

    处理多维度变化——桥接模式(三):跨平台图像浏览系统的桥接模式解决方案

    处理多维度变化——桥接模式(四):适配器模式与桥接模式的联用,桥接模式总结

     

    组合模式-Composite Pattern

    树形结构的处理——组合模式(一):设计杀毒软件的框架结构

    树形结构的处理——组合模式(二):组合模式概述

    树形结构的处理——组合模式(三):杀毒软件的框架结构的组合模式解决方案

    树形结构的处理——组合模式(四):透明组合模式与安全组合模式

    树形结构的处理——组合模式(五):公司组织结构,组合模式总结

     

    装饰模式-Decorator Pattern

    扩展系统功能——装饰模式(一):图形界面构件库的设计

    扩展系统功能——装饰模式(二):装饰模式概述

    扩展系统功能——装饰模式(三):图形界面构件库的装饰模式解决方案

    扩展系统功能——装饰模式(四):透明装饰模式与半透明装饰模式,装饰模式注意事项,装饰模式总结

     

    外观模式-Facade Pattern

    深入浅出外观模式(一):外观模式概述,外观模式结构与实现

    深入浅出外观模式(二):外观模式应用实例(文件加密模块)

    深入浅出外观模式(三):抽象外观类,外观模式效果与适用场景

     

    享元模式-Flyweight Pattern

    实现对象的复用——享元模式(一):围棋棋子的设计,享元模式概述(上)

    实现对象的复用——享元模式(二):享元模式概述(下)

    实现对象的复用——享元模式(三):围棋棋子的享元模式解决方案

    实现对象的复用——享元模式(四):带外部状态的围棋棋子解决方案

    实现对象的复用——享元模式(五):单纯享元模式和复合享元模式,关于享元模式的几点补充,享元模式总结

     

    代理模式-Proxy Pattern

     

    代理模式(一):代理模式概述,代理模式结构与实现

    代理模式(二):代理模式应用实例(收费商务信息查询系统)

    代理模式(三):远程代理,虚拟代理,缓冲代理

    代理模式(四):代理模式效果与适用场景

     

     

    十一个行为型模式

     

    职责链模式-Chain of Responsibility Pattern

    请求的链式处理——职责链模式(一):采购单的分级审批

    请求的链式处理——职责链模式(二):职责链模式概述

    请求的链式处理——职责链模式(三):采购单分级审批的职责链模式解决方案

    请求的链式处理——职责链模式(四):纯与不纯的职责链模式,职责链模式总结

     

    命令模式-Command Pattern

    请求发送者与接收者解耦——命令模式(一):自定义功能键,命令模式概述

    请求发送者与接收者解耦——命令模式(二):自定义功能键的命令模式解决方案

    请求发送者与接收者解耦——命令模式(三):命令队列的实现

    请求发送者与接收者解耦——命令模式(四):撤销操作的简单实现

    请求发送者与接收者解耦——命令模式(五):请求日志

    请求发送者与接收者解耦——命令模式(六):宏命令,命令模式总结

     

    解释器模式-Interpreter Pattern

    自定义语言的实现——解释器模式(一):机器人控制程序

    自定义语言的实现——解释器模式(二):文法规则和抽象语法树

    自定义语言的实现——解释器模式(三):解释器模式概述

    自定义语言的实现——解释器模式(四):机器人控制程序的解释器模式解决方案

    自定义语言的实现——解释器模式(五):再谈Context的作用

    自定义语言的实现——解释器模式(六):解释器模式总结

     

    迭代器模式-Iterator Pattern

    遍历聚合对象中的元素——迭代器模式(一):销售管理系统中数据的遍历

    遍历聚合对象中的元素——迭代器模式(二):迭代器模式概述

    遍历聚合对象中的元素——迭代器模式(三):销售管理系统中数据的遍历的迭代器模式解决方案

    遍历聚合对象中的元素——迭代器模式(四):使用内部类实现迭代器

    遍历聚合对象中的元素——迭代器模式(五):JDK内置迭代器的使用

    遍历聚合对象中的元素——迭代器模式(六):迭代器模式总结

     

    中介者模式-Mediator Pattern

    协调多个对象之间的交互——中介者模式(一):客户信息管理窗口的初始设计

    协调多个对象之间的交互——中介者模式(二):中介者模式概述

    协调多个对象之间的交互——中介者模式(三):客户信息管理窗口的中介者模式解决方案

    协调多个对象之间的交互——中介者模式(四):中介者与同事类的扩展

    协调多个对象之间的交互——中介者模式(五):中介者模式总结

     

    备忘录模式-Memento Pattern

    撤销功能的实现——备忘录模式(一):可悔棋的中国象棋

    撤销功能的实现——备忘录模式(二):备忘录模式概述

    撤销功能的实现——备忘录模式(三):中国象棋的备忘录模式解决方案

    撤销功能的实现——备忘录模式(四):实现多次撤销

    撤销功能的实现——备忘录模式(五):再谈备忘录的封装,备忘录模式总结

     

    观察者模式-Observer Pattern

    对象间的联动——观察者模式(一):多人联机对战游戏的设计

    对象间的联动——观察者模式(二):观察者模式概述

    对象间的联动——观察者模式(三):多人联机对战游戏的观察者模式解决方案

    对象间的联动——观察者模式(四):JDK对观察者模式的支持

    对象间的联动——观察者模式(五):观察者模式与Java事件处理

    对象间的联动——观察者模式(六):观察者模式与MVC,观察者模式总结

     

    状态模式-State Pattern

    处理对象的多种状态及其相互转换——状态模式(一):银行系统中的账户类设计

    处理对象的多种状态及其相互转换——状态模式(二):状态模式概述

    处理对象的多种状态及其相互转换——状态模式(三):账户类的状态模式解决方案

    处理对象的多种状态及其相互转换——状态模式(四):共享状态的实现

    处理对象的多种状态及其相互转换——状态模式(五):使用环境类实现状态转换

    处理对象的多种状态及其相互转换——状态模式(六):状态模式总结

     

    策略模式-Strategy Pattern

    算法的封装与切换——策略模式(一):电影票打折方案

    算法的封装与切换——策略模式(二):策略模式概述

    算法的封装与切换——策略模式(三):电影票打折方案的策略模式解决方案

    算法的封装与切换——策略模式(四):策略模式的两个典型应用,策略模式总结

     

    模板方法模式-Template Method Pattern

    模板方法模式深度解析(一):模板方法模式概述,模板方法模式结构与实现

    模板方法模式深度解析(二):模板方法模式应用实例(银行利息计算模块)

    模板方法模式深度解析(三):钩子方法的使用,模板方法模式效果与适用场景

     

    访问者模式-Visitor Pattern

    操作复杂对象结构——访问者模式(一):OA系统中员工数据汇总

    操作复杂对象结构——访问者模式(二):访问者模式概述

    操作复杂对象结构——访问者模式(三):OA系统中员工数据汇总的访问者模式解决方案

    操作复杂对象结构——访问者模式(四):访问者模式与组合模式联用,访问者模式总结

     

    设计模式趣味学习(复习)

     

    设计模式与足球(一):创建型模式

    设计模式与足球(二):结构型模式

    设计模式与足球(三):行为型模式(上)

    设计模式与足球(四):行为型模式(下)

     

     

    设计模式综合应用实例

     

    多人联机射击游戏

     

    多人联机射击游戏中的设计模式应用(一):抽象工厂模式,建造者模式,工厂方法模式,迭代器模式,命令模式

    多人联机射击游戏中的设计模式应用(二):观察者模式,单例模式,状态模式,适配器模式

     

     

     

    数据库同步系统

     

    设计模式综合实例分析之数据库同步系统(一):数据库同步系统概述,建造者模式,简单工厂模式

    设计模式综合实例分析之数据库同步系统(二):享元模式,单例模式,观察者模式,模板方法模式

    设计模式综合实例分析之数据库同步系统(三):策略模式,组合模式,命令模式,职责链模式

     

    转自:https://blog.csdn.net/u013829202/article/details/52513029

    更多相关内容
  • 23种设计模式详解

    2018-02-10 11:05:52
    23种设计模式详解,23种设计模式详解23种设计模式详解23种设计模式详解
  • java23种设计模式详解

    2018-01-19 15:58:04
    java23种设计模式详解附带所有代码实现,适合初学者,请点个赞,谢谢
  • 23种设计模式详解及案例
  • 本项目用来展示23种设计模式的具体实现代码,帮助更好理解设计模式的应用本项目用来展示23种设计模式的具体实现代码,帮助更好理解设计模式的应用本项目用来展示23种设计模式的具体实现代码,帮助更好理解设计模式的...
  • 23 种设计模式详解(全23种

    万次阅读 多人点赞 2019-06-09 00:21:59
    设计模式的分类 总体来说设计模式分为三大类: 创建型模式,共五:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式,共七:适配器模式、装饰器模式、代理模式、外观模式、桥接模式...

    设计模式的分类

    总体来说设计模式分为三大类:

    创建型模式,共五种:工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

    结构型模式,共七种:适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

    行为型模式,共十一种:策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。

     

    A、创建模式(5种)

    工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

    1 工厂模式

    1.1 简单工厂模式

    定义:定义了一个创建对象的类,由这个类来封装实例化对象的行为。

    举例:(我们举一个pizza工厂的例子)

    pizza工厂一共生产三种类型的pizza:chesse,pepper,greak。通过工厂类(SimplePizzaFactory)实例化这三种类型的对象。类图如下:

     

    工厂类的代码:

    public class SimplePizzaFactory {
           public Pizza CreatePizza(String ordertype) {
                  Pizza pizza = null;
                  if (ordertype.equals("cheese")) {
                         pizza = new CheesePizza();
                  } else if (ordertype.equals("greek")) {
                         pizza = new GreekPizza();
                  } else if (ordertype.equals("pepper")) {
                         pizza = new PepperPizza();
                  }
                  return pizza;
           }
    }
    

    简单工厂存在的问题与解决方法: 简单工厂模式有一个问题就是,类的创建依赖工厂类,也就是说,如果想要拓展程序,必须对工厂类进行修改,这违背了开闭原则,所以,从设计角度考虑,有一定的问题,如何解决?我们可以定义一个创建对象的抽象方法并创建多个不同的工厂类实现该抽象方法,这样一旦需要增加新的功能,直接增加新的工厂类就可以了,不需要修改之前的代码。这种方法也就是我们接下来要说的工厂方法模式。

    1.2 工厂方法模式

    定义:定义了一个创建对象的抽象方法,由子类决定要实例化的类。工厂方法模式将对象的实例化推迟到子类。

    举例:(我们依然举pizza工厂的例子,不过这个例子中,pizza产地有两个:伦敦和纽约)。添加了一个新的产地,如果用简单工厂模式的的话,我们要去修改工厂代码,并且会增加一堆的if else语句。而工厂方法模式克服了简单工厂要修改代码的缺点,它会直接创建两个工厂,纽约工厂和伦敦工厂。类图如下:

     

    OrderPizza中有个抽象的方法:

    abstract Pizza createPizza();

    两个工厂类继承OrderPizza并实现抽象方法:

    public class LDOrderPizza extends OrderPizza {
           Pizza createPizza(String ordertype) {
                  Pizza pizza = null;
                  if (ordertype.equals("cheese")) {
                         pizza = new LDCheesePizza();
                  } else if (ordertype.equals("pepper")) {
                         pizza = new LDPepperPizza();
                  }
                  return pizza;
           }
    }
    public class NYOrderPizza extends OrderPizza {
    
    	Pizza createPizza(String ordertype) {
    		Pizza pizza = null;
    
    		if (ordertype.equals("cheese")) {
    			pizza = new NYCheesePizza();
    		} else if (ordertype.equals("pepper")) {
    			pizza = new NYPepperPizza();
    		}
    		return pizza;
    
    	}
    
    }

    、通过不同的工厂会得到不同的实例化的对象,PizzaStroe的代码如下:

    public class PizzaStroe {
           public static void main(String[] args) {
                  OrderPizza mOrderPizza;
                  mOrderPizza = new NYOrderPizza();
           }
    }

    解决了简单工厂模式的问题:增加一个新的pizza产地(北京),只要增加一个BJOrderPizza类:

    public class BJOrderPizza extends OrderPizza {
           Pizza createPizza(String ordertype) {
                  Pizza pizza = null;
                  if (ordertype.equals("cheese")) {
                         pizza = new LDCheesePizza();
                  } else if (ordertype.equals("pepper")) {
                         pizza = new LDPepperPizza();
                  }
                  return pizza;
           }
    }

    其实这个模式的好处就是,如果你现在想增加一个功能,只需做一个实现类就OK了,无需去改动现成的代码。这样做,拓展性较好!

    工厂方法存在的问题与解决方法:客户端需要创建类的具体的实例。简单来说就是用户要订纽约工厂的披萨,他必须去纽约工厂,想订伦敦工厂的披萨,必须去伦敦工厂。 当伦敦工厂和纽约工厂发生变化了,用户也要跟着变化,这无疑就增加了用户的操作复杂性。为了解决这一问题,我们可以把工厂类抽象为接口,用户只需要去找默认的工厂提出自己的需求(传入参数),便能得到自己想要产品,而不用根据产品去寻找不同的工厂,方便用户操作。这也就是我们接下来要说的抽象工厂模式。

    1.3 抽象工厂模式

     定义:定义了一个接口用于创建相关或有依赖关系的对象族,而无需明确指定具体类。

    举例:(我们依然举pizza工厂的例子,pizza工厂有两个:纽约工厂和伦敦工厂)。类图如下:

    工厂的接口:

    public interface AbsFactory {
           Pizza CreatePizza(String ordertype) ;
    }

    工厂的实现:

    public class LDFactory implements AbsFactory {
           @Override
           public Pizza CreatePizza(String ordertype) {
                  Pizza pizza = null;
                  if ("cheese".equals(ordertype)) {
                         pizza = new LDCheesePizza();
                  } else if ("pepper".equals(ordertype)) {
                         pizza = new LDPepperPizza();
                  }
                  return pizza;
           }
    }

    PizzaStroe的代码如下:

    public class PizzaStroe {
           public static void main(String[] args) {
                  OrderPizza mOrderPizza;
                  mOrderPizza = new OrderPizza("London");
           }
    }

    解决了工厂方法模式的问题:在抽象工厂中PizzaStroe中只需要传入参数就可以实例化对象。

    1.4 工厂模式适用的场合

    大量的产品需要创建,并且这些产品具有共同的接口 。

    1.5  三种工厂模式的使用选择

    简单工厂 : 用来生产同一等级结构中的任意产品。(不支持拓展增加产品)

    工厂方法 :用来生产同一等级结构中的固定产品。(支持拓展增加产品)   

    抽象工厂 :用来生产不同产品族的全部产品。(支持拓展增加产品;支持增加产品族)  

    简单工厂的适用场合:只有伦敦工厂(只有这一个等级),并且这个工厂只生产三种类型的pizza:chesse,pepper,greak(固定产品)。

    工厂方法的适用场合:现在不光有伦敦工厂,还增设了纽约工厂(仍然是同一等级结构,但是支持了产品的拓展),这两个工厂依然只生产三种类型的pizza:chesse,pepper,greak(固定产品)。

    抽象工厂的适用场合:不光增设了纽约工厂(仍然是同一等级结构,但是支持了产品的拓展),这两个工厂还增加了一种新的类型的pizza:chinese pizza(增加产品族)。

    所以说抽象工厂就像工厂,而工厂方法则像是工厂的一种产品生产线。因此,我们可以用抽象工厂模式创建工厂,而用工厂方法模式创建生产线。比如,我们可以使用抽象工厂模式创建伦敦工厂和纽约工厂,使用工厂方法实现cheese pizza和greak pizza的生产。类图如下:     

    总结一下三种模式:

    简单工厂模式就是建立一个实例化对象的类,在该类中对多个对象实例化。工厂方法模式是定义了一个创建对象的抽象方法,由子类决定要实例化的类。这样做的好处是再有新的类型的对象需要实例化只要增加子类即可。抽象工厂模式定义了一个接口用于创建对象族,而无需明确指定具体类。抽象工厂也是把对象的实例化交给了子类,即支持拓展。同时提供给客户端接口,避免了用户直接操作子类工厂。

     

    2 单例模式

    定义:确保一个类最多只有一个实例,并提供一个全局访问点

    单例模式可以分为两种:预加载和懒加载

    2.1 预加载

    顾名思义,就是预先加载。再进一步解释就是还没有使用该单例对象,但是,该单例对象就已经被加载到内存了。

    public class PreloadSingleton {
           
           public static PreloadSingleton instance = new PreloadSingleton();
       
           //其他的类无法实例化单例类的对象
           private PreloadSingleton() {
           };
           
           public static PreloadSingleton getInstance() {
                  return instance;
           }
    }

    很明显,没有使用该单例对象,该对象就被加载到了内存,会造成内存的浪费。

    2.2 懒加载

    为了避免内存的浪费,我们可以采用懒加载,即用到该单例对象的时候再创建。

    public class Singleton {
           
           private static Singleton instance=null;
           
           private Singleton(){
           };
           
           public static Singleton getInstance()
           {
                  if(instance==null)
                  {
                         instance=new Singleton();
                  }
                  return instance;
                  
           }
    }

    2.3 单例模式和线程安全

    (1)预加载只有一条语句return instance,这显然可以保证线程安全。但是,我们知道预加载会造成内存的浪费。

    (2)懒加载不浪费内存,但是无法保证线程的安全。首先,if判断以及其内存执行代码是非原子性的。其次,new Singleton()无法保证执行的顺序性。

    不满足原子性或者顺序性,线程肯定是不安全的,这是基本的常识,不再赘述。我主要讲一下为什么new Singleton()无法保证顺序性。我们知道创建一个对象分三步:

    memory=allocate();//1:初始化内存空间
    
    ctorInstance(memory);//2:初始化对象
    
    instance=memory();//3:设置instance指向刚分配的内存地址

    jvm为了提高程序执行性能,会对没有依赖关系的代码进行重排序,上面2和3行代码可能被重新排序。我们用两个线程来说明线程是不安全的。线程A和线程B都创建对象。其中,A2和A3的重排序,将导致线程B在B1处判断出instance不为空,线程B接下来将访问instance引用的对象。此时,线程B将会访问到一个还未初始化的对象(线程不安全)。

    2.4 保证懒加载的线程安全

    我们首先想到的就是使用synchronized关键字。synchronized加载getInstace()函数上确实保证了线程的安全。但是,如果要经常的调用getInstance()方法,不管有没有初始化实例,都会唤醒和阻塞线程。为了避免线程的上下文切换消耗大量时间,如果对象已经实例化了,我们没有必要再使用synchronized加锁,直接返回对象。

    public class Singleton {
           private static Singleton instance = null;
           private Singleton() {
           };
           public static synchronized Singleton getInstance() {
                  if (instance == null) {
                         instance = new Singleton();
                  }
                  return instance;
           }
    }

    我们把sychronized加在if(instance==null)判断语句里面,保证instance未实例化的时候才加锁

    public class Singleton {
           private static Singleton instance = null;
           private Singleton() {
           };
           public static synchronized Singleton getInstance() {
                  if (instance == null) {
                         synchronized (Singleton.class) {
                               if (instance == null) {
                                      instance = new Singleton();
                               }
                         }
                  }
                  return instance;
           }
    }

    我们经过2.3的讨论知道new一个对象的代码是无法保证顺序性的,因此,我们需要使用另一个关键字volatile保证对象实例化过程的顺序性。

    public class Singleton {
           private static volatile Singleton instance = null;
           private Singleton() {
           };
           public static synchronized Singleton getInstance() {
                  if (instance == null) {
                         synchronized (instance) {
                               if (instance == null) {
                                      instance = new Singleton();
                               }
                         }
                  }
                  return instance;
           }
    }

    到此,我们就保证了懒加载的线程安全。

     

    3 生成器模式

    定义:封装一个复杂对象构造过程,并允许按步骤构造。

    定义解释: 我们可以将生成器模式理解为,假设我们有一个对象需要建立,这个对象是由多个组件(Component)组合而成,每个组件的建立都比较复杂,但运用组件来建立所需的对象非常简单,所以我们就可以将构建复杂组件的步骤与运用组件构建对象分离,使用builder模式可以建立。

    3.1 模式的结构和代码示例

    生成器模式结构中包括四种角色:

    (1)产品(Product):具体生产器要构造的复杂对象;

    (2)抽象生成器(Bulider):抽象生成器是一个接口,该接口除了为创建一个Product对象的各个组件定义了若干个方法之外,还要定义返回Product对象的方法(定义构造步骤);

    (3)具体生产器(ConcreteBuilder):实现Builder接口的类,具体生成器将实现Builder接口所定义的方法(生产各个组件);

    (4)指挥者(Director):指挥者是一个类,该类需要含有Builder接口声明的变量。指挥者的职责是负责向用户提供具体生成器,即指挥者将请求具体生成器类来构造用户所需要的Product对象,如果所请求的具体生成器成功地构造出Product对象,指挥者就可以让该具体生产器返回所构造的Product对象。(按照步骤组装部件,并返回Product

     

    举例(我们如果构建生成一台电脑,那么我们可能需要这么几个步骤(1)需要一个主机(2)需要一个显示器(3)需要一个键盘(4)需要一个鼠标)

    虽然我们具体在构建一台主机的时候,每个对象的实际步骤是不一样的,比如,有的对象构建了i7cpu的主机,有的对象构建了i5cpu的主机,有的对象构建了普通键盘,有的对象构建了机械键盘等。但不管怎样,你总是需要经过一个步骤就是构建一台主机,一台键盘。对于这个例子,我们就可以使用生成器模式来生成一台电脑,他需要通过多个步骤来生成。类图如下:

    ComputerBuilder类定义构造步骤:

    public abstract class ComputerBuilder {
       
        protected Computer computer;
       
        public Computer getComputer() {
            return computer;
        }
       
        public void buildComputer() {
            computer = new Computer();
            System.out.println("生成了一台电脑!!!");
        }
        public abstract void buildMaster();
        public abstract void buildScreen();
        public abstract void buildKeyboard();
        public abstract void buildMouse();
        public abstract void buildAudio();
    }

    HPComputerBuilder定义各个组件:

    public class HPComputerBuilder extends ComputerBuilder {
        @Override
        public void buildMaster() {
            // TODO Auto-generated method stub
            computer.setMaster("i7,16g,512SSD,1060");
            System.out.println("(i7,16g,512SSD,1060)的惠普主机");
        }
        @Override
        public void buildScreen() {
            // TODO Auto-generated method stub
            computer.setScreen("1080p");
            System.out.println("(1080p)的惠普显示屏");
        }
        @Override
        public void buildKeyboard() {
            // TODO Auto-generated method stub
            computer.setKeyboard("cherry 青轴机械键盘");
            System.out.println("(cherry 青轴机械键盘)的键盘");
        }
        @Override
        public void buildMouse() {
            // TODO Auto-generated method stub
            computer.setMouse("MI 鼠标");
            System.out.println("(MI 鼠标)的鼠标");
        }
        @Override
        public void buildAudio() {
            // TODO Auto-generated method stub
            computer.setAudio("飞利浦 音响");
            System.out.println("(飞利浦 音响)的音响");
        }
    }

    Director类对组件进行组装并生成产品

    public class Director {
       
        private ComputerBuilder computerBuilder;
        public void setComputerBuilder(ComputerBuilder computerBuilder) {
            this.computerBuilder = computerBuilder;
        }
       
        public Computer getComputer() {
            return computerBuilder.getComputer();
        }
       
        public void constructComputer() {
            computerBuilder.buildComputer();
            computerBuilder.buildMaster();
            computerBuilder.buildScreen();
            computerBuilder.buildKeyboard();
            computerBuilder.buildMouse();
            computerBuilder.buildAudio();
        }
    }

    3.2 生成器模式的优缺点

    优点

    • 将一个对象分解为各个组件

    • 将对象组件的构造封装起来

    • 可以控制整个对象的生成过程

    缺点

    • 对不同类型的对象需要实现不同的具体构造器的类,这可能回答大大增加类的数量

    3.3 生成器模式与工厂模式的不同

    生成器模式构建对象的时候,对象通常构建的过程中需要多个步骤,就像我们例子中的先有主机,再有显示屏,再有鼠标等等,生成器模式的作用就是将这些复杂的构建过程封装起来。工厂模式构建对象的时候通常就只有一个步骤,调用一个工厂方法就可以生成一个对象。

     

    4 原型模式

    定义:通过复制现有实例来创建新的实例,无需知道相应类的信息。

    简单地理解,其实就是当需要创建一个指定的对象时,我们刚好有一个这样的对象,但是又不能直接使用,我会clone一个一毛一样的新对象来使用;基本上这就是原型模式。关键字:Clone

    4.1 深拷贝和浅拷贝

    浅复制:将一个对象复制后,基本数据类型的变量都会重新创建,而引用类型,指向的还是原对象所指向的。

    深复制:将一个对象复制后,不论是基本数据类型还有引用类型,都是重新创建的。简单来说,就是深复制进行了完全彻底的复制,而浅复制不彻底。clone明显是深复制,clone出来的对象是是不能去影响原型对象的

    4.2 原型模式的结构和代码示例

    Client:使用者

    Prototype:接口(抽象类),声明具备clone能力,例如java中得Cloneable接口

    ConcretePrototype:具体的原型类

    可以看出设计模式还是比较简单的,重点在于Prototype接口和Prototype接口的实现类ConcretePrototype。原型模式的具体实现:一个原型类,只需要实现Cloneable接口,覆写clone方法,此处clone方法可以改成任意的名称,因为Cloneable接口是个空接口,你可以任意定义实现类的方法名,如cloneA或者cloneB,因为此处的重点是super.clone()这句话,super.clone()调用的是Object的clone()方法。

    public class Prototype implements Cloneable {  
         public Object clone() throws CloneNotSupportedException {  
             Prototype proto = (Prototype) super.clone();  
             return proto;  
         }  
    }  

    举例(银行发送大量邮件,使用clone和不使用clone的时间对比):我们模拟创建一个对象需要耗费比较长的时间,因此,在构造函数中我们让当前线程sleep一会

    public Mail(EventTemplate et) {
                  this.tail = et.geteventContent();
                  this.subject = et.geteventSubject();
                  try {
                         Thread.sleep(1000);
                  } catch (InterruptedException e) {
                         // TODO Auto-generated catch block
                         e.printStackTrace();
                  }
           }

    不使用clone,发送十个邮件

    public static void main(String[] args) {
                  int i = 0;
                  int MAX_COUNT = 10;
                  EventTemplate et = new EventTemplate("9月份信用卡账单", "国庆抽奖活动...");
                  long start = System.currentTimeMillis();
                  while (i < MAX_COUNT) {
                         // 以下是每封邮件不同的地方
                         Mail mail = new Mail(et);
                         mail.setContent(getRandString(5) + ",先生(女士):你的信用卡账单..." + mail.getTail());
                         mail.setReceiver(getRandString(5) + "@" + getRandString(8) + ".com");
                         // 然后发送邮件
                         sendMail(mail);
                         i++;
                  }
                  long end = System.currentTimeMillis();
                  System.out.println("用时:" + (end - start));
           }

     

    用时:10001

    使用clone,发送十个邮件

        public static void main(String[] args) {
                  int i = 0;
                  int MAX_COUNT = 10;
                  EventTemplate et = new EventTemplate("9月份信用卡账单", "国庆抽奖活动...");
                  long start=System.currentTimeMillis();
                  Mail mail = new Mail(et);         
                  while (i < MAX_COUNT) {
                         Mail cloneMail = mail.clone();
                         mail.setContent(getRandString(5) + ",先生(女士):你的信用卡账单..."
                                      + mail.getTail());
                         mail.setReceiver(getRandString(5) + "@" + getRandString(8) + ".com");
                         sendMail(cloneMail);
                         i++;
                  }
                  long end=System.currentTimeMillis();
                  System.out.println("用时:"+(end-start));
           }

    用时:1001

    4.3 总结

    原型模式的本质就是clone,可以解决构建复杂对象的资源消耗问题,能再某些场景中提升构建对象的效率;还有一个重要的用途就是保护性拷贝,可以通过返回一个拷贝对象的形式,实现只读的限制。

     

    B、结构模式(7种)

    适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

     

    5 适配器模式

    定义: 适配器模式将某个类的接口转换成客户端期望的另一个接口表示,目的是消除由于接口不匹配所造成的类的兼容性问题。

    主要分为三类:类的适配器模式、对象的适配器模式、接口的适配器模式。

    5.1 类适配器模式

    通过多重继承目标接口和被适配者类方式来实现适配

    举例(将USB接口转为VGA接口),类图如下:

     

    USBImpl的代码:

    public class USBImpl implements USB{
           @Override
           public void showPPT() {
                  // TODO Auto-generated method stub
                  System.out.println("PPT内容演示");
           }
    }

    AdatperUSB2VGA 首先继承USBImpl获取USB的功能,其次,实现VGA接口,表示该类的类型为VGA。

    public class AdapterUSB2VGA extends USBImpl implements VGA {
           @Override
           public void projection() {
                  super.showPPT();
           }
    }

    Projector将USB映射为VGA,只有VGA接口才可以连接上投影仪进行投影

    public class Projector<T> {
           public void projection(T t) {
                  if (t instanceof VGA) {
                         System.out.println("开始投影");
                         VGA v = new VGAImpl();
                         v = (VGA) t;
                         v.projection();
                  } else {
                         System.out.println("接口不匹配,无法投影");
                  }
           }
    }

    test代码

           @Test
           public void test2(){
                  //通过适配器创建一个VGA对象,这个适配器实际是使用的是USB的showPPT()方法
                  VGA a=new AdapterUSB2VGA();
                  //进行投影
                  Projector p1=new Projector();
                  p1.projection(a);
           } 

    5.2 对象适配器模式

    对象适配器和类适配器使用了不同的方法实现适配,对象适配器使用组合,类适配器使用继承。

    举例(将USB接口转为VGA接口),类图如下:

     

    public class AdapterUSB2VGA implements VGA {
           USB u = new USBImpl();
           @Override
           public void projection() {
                  u.showPPT();
           }
    }

    实现VGA接口,表示适配器类是VGA类型的,适配器方法中直接使用USB对象。

    5.3 接口适配器模式

    当不需要全部实现接口提供的方法时,可先设计一个抽象类实现接口,并为该接口中每个方法提供一个默认实现(空方法),那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求,它适用于一个接口不想使用其所有的方法的情况。

    举例(将USB接口转为VGA接口,VGA中的b()和c()不会被实现),类图如下:

    AdapterUSB2VGA抽象类

    public abstract class AdapterUSB2VGA implements VGA {
           USB u = new USBImpl();
           @Override
           public void projection() {
                  u.showPPT();
           }
           @Override
           public void b() {
           };
           @Override
           public void c() {
           };
    }

    AdapterUSB2VGA实现,不用去实现b()和c()方法。

    public class AdapterUSB2VGAImpl extends AdapterUSB2VGA {
           public void projection() {
                  super.projection();
           }
    }

    5.4 总结

    总结一下三种适配器模式的应用场景:

    类适配器模式:当希望将一个类转换成满足另一个新接口的类时,可以使用类的适配器模式,创建一个新类,继承原有的类,实现新的接口即可。

    对象适配器模式:当希望将一个对象转换成满足另一个新接口的对象时,可以创建一个Wrapper类,持有原类的一个实例,在Wrapper类的方法中,调用实例的方法就行。

    接口适配器模式:当不希望实现一个接口中所有的方法时,可以创建一个抽象类Wrapper,实现所有方法,我们写别的类的时候,继承抽象类即可。

    命名规则:

    我个人理解,三种命名方式,是根据 src是以怎样的形式给到Adapter(在Adapter里的形式)来命名的。 

    类适配器,以类给到,在Adapter里,就是将src当做类,继承, 

    对象适配器,以对象给到,在Adapter里,将src作为一个对象,持有。 

    接口适配器,以接口给到,在Adapter里,将src作为一个接口,实现。

    使用选择:

    根据合成复用原则,组合大于继承。因此,类的适配器模式应该少用。

     

    6 装饰者模式

    定义:动态的将新功能附加到对象上。在对象功能扩展方面,它比继承更有弹性。

    6.1 装饰者模式结构图与代码示例

    1.Component(被装饰对象的基类)

       定义一个对象接口,可以给这些对象动态地添加职责。

    2.ConcreteComponent(具体被装饰对象)

       定义一个对象,可以给这个对象添加一些职责。

    3.Decorator(装饰者抽象类)

       维持一个指向Component实例的引用,并定义一个与Component接口一致的接口。

    4.ConcreteDecorator(具体装饰者)

       具体的装饰对象,给内部持有的具体被装饰对象,增加具体的职责。

    被装饰对象和修饰者继承自同一个超类

    举例(咖啡馆订单项目:1)、咖啡种类:Espresso、ShortBlack、LongBlack、Decaf2)、调料(装饰者):Milk、Soy、Chocolate),类图如下:

     

    被装饰的对象和装饰者都继承自同一个超类

    public abstract class Drink {
           public String description="";
           private float price=0f;;
           
           
           public void setDescription(String description)
           {
                  this.description=description;
           }
           
           public String getDescription()
           {
                  return description+"-"+this.getPrice();
           }
           public float getPrice()
           {
                  return price;
           }
           public void setPrice(float price)
           {
                  this.price=price;
           }
           public abstract float cost();
           
    }

    被装饰的对象,不用去改造。原来怎么样写,现在还是怎么写。

    public  class Coffee extends Drink {
           @Override
           public float cost() {
                  // TODO Auto-generated method stub
                  return super.getPrice();
           }
           
    }

    coffee类的实现

    public class Decaf extends Coffee {
           public Decaf()
           {
                  super.setDescription("Decaf");
                  super.setPrice(3.0f);
           }
    }

    装饰者

    装饰者不仅要考虑自身,还要考虑被它修饰的对象,它是在被修饰的对象上继续添加修饰。例如,咖啡里面加牛奶,再加巧克力。加糖后价格为coffee+milk。再加牛奶价格为coffee+milk+chocolate。

    public class Decorator extends Drink {
           private Drink Obj;
           public Decorator(Drink Obj) {
                  this.Obj = Obj;
           };
           @Override
           public float cost() {
                  // TODO Auto-generated method stub
                  return super.getPrice() + Obj.cost();
           }
           @Override
           public String getDescription() {
                  return super.description + "-" + super.getPrice() + "&&" + Obj.getDescription();
           }
    }

    装饰者实例化(加牛奶)。这里面要对被修饰的对象进行实例化。

    public class Milk extends Decorator {
           public Milk(Drink Obj) {          
                  super(Obj);
                  // TODO Auto-generated constructor stub
                  super.setDescription("Milk");
                  super.setPrice(2.0f);
           }
    }

    coffee店:初始化一个被修饰对象,修饰者实例需要对被修改者实例化,才能对具体的被修饰者进行修饰。

    public class CoffeeBar {
           public static void main(String[] args) {
                  Drink order;
                  order = new Decaf();
                  System.out.println("order1 price:" + order.cost());
                  System.out.println("order1 desc:" + order.getDescription());
                  System.out.println("****************");
                  order = new LongBlack();
                  order = new Milk(order);
                  order = new Chocolate(order);
                  order = new Chocolate(order);
                  System.out.println("order2 price:" + order.cost());
                  System.out.println("order2 desc:" + order.getDescription());
           }
    }

    6.2 总结

    装饰者和被装饰者之间必须是一样的类型,也就是要有共同的超类。在这里应用继承并不是实现方法的复制,而是实现类型的匹配。因为装饰者和被装饰者是同一个类型,因此装饰者可以取代被装饰者,这样就使被装饰者拥有了装饰者独有的行为。根据装饰者模式的理念,我们可以在任何时候,实现新的装饰者增加新的行为。如果是用继承,每当需要增加新的行为时,就要修改原程序了。

     

     

    7 代理模式

    定义:代理模式给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。通俗的来讲代理模式就是我们生活中常见的中介。

    举个例子来说明:假如说我现在想买一辆二手车,虽然我可以自己去找车源,做质量检测等一系列的车辆过户流程,但是这确实太浪费我得时间和精力了。我只是想买一辆车而已为什么我还要额外做这么多事呢?于是我就通过中介公司来买车,他们来给我找车源,帮我办理车辆过户流程,我只是负责选择自己喜欢的车,然后付钱就可以了。用图表示如下:

    7.1 为什么要用代理模式?

    中介隔离作用:在某些情况下,一个客户类不想或者不能直接引用一个委托对象,而代理类对象可以在客户类和委托对象之间起到中介的作用,其特征是代理类和委托类实现相同的接口。

    开闭原则,增加功能:代理类除了是客户类和委托类的中介之外,我们还可以通过给代理类增加额外的功能来扩展委托类的功能,这样做我们只需要修改代理类而不需要再修改委托类,符合代码设计的开闭原则。代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后对返回结果的处理等。代理类本身并不真正实现服务,而是同过调用委托类的相关方法,来提供特定的服务。真正的业务功能还是由委托类来实现,但是可以在业务功能执行的前后加入一些公共的服务。例如我们想给项目加入缓存、日志这些功能,我们就可以使用代理类来完成,而没必要打开已经封装好的委托类。

    代理模式分为三类:1. 静态代理 2. 动态代理 3. CGLIB代理

    7.2 静态代理

    举例(买房),类图如下:

    第一步:创建服务类接口

    public interface BuyHouse {
        void buyHosue();
    }

    第二步:实现服务接口

    public class BuyHouseImpl implements BuyHouse {
           @Override
           public void buyHosue() {
                  System.out.println("我要买房");
           }
    }

    第三步:创建代理类

    public class BuyHouseProxy implements BuyHouse {
           private BuyHouse buyHouse;
           public BuyHouseProxy(final BuyHouse buyHouse) {
                  this.buyHouse = buyHouse;
           }
           @Override
           public void buyHosue() {
                  System.out.println("买房前准备");
                  buyHouse.buyHosue();
                  System.out.println("买房后装修");
           }
    }

    总结:

    优点:可以做到在符合开闭原则的情况下对目标对象进行功能扩展。

    缺点: 代理对象与目标对象要实现相同的接口,我们得为每一个服务都得创建代理类,工作量太大,不易管理。同时接口一旦发生改变,代理类也得相应修改。 

    7.3 动态代理

    动态代理有以下特点:

    1.代理对象,不需要实现接口

    2.代理对象的生成,是利用JDK的API,动态的在内存中构建代理对象(需要我们指定创建代理对象/目标对象实现的接口的类型)

    代理类不用再实现接口了。但是,要求被代理对象必须有接口。

    动态代理实现:

    Java.lang.reflect.Proxy类可以直接生成一个代理对象

    • Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)生成一个代理对象

      • 参数1:ClassLoader loader 代理对象的类加载器 一般使用被代理对象的类加载器

      • 参数2:Class<?>[] interfaces 代理对象的要实现的接口 一般使用的被代理对象实现的接口

      • 参数3:InvocationHandler h (接口)执行处理类

    • InvocationHandler中的invoke(Object proxy, Method method, Object[] args)方法:调用代理类的任何方法,此方法都会执行

      • 参数3.1:代理对象(慎用)

      • 参数3.2:当前执行的方法

      • 参数3.3:当前执行的方法运行时传递过来的参数

    第一步:编写动态处理器

    public class DynamicProxyHandler implements InvocationHandler {
           private Object object;
           public DynamicProxyHandler(final Object object) {
                  this.object = object;
           }
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                  System.out.println("买房前准备");
                  Object result = method.invoke(object, args);
                  System.out.println("买房后装修");
                  return result;
           }
    }

    第二步:编写测试类

    public class DynamicProxyTest {
        public static void main(String[] args) {
            BuyHouse buyHouse = new BuyHouseImpl();
            BuyHouse proxyBuyHouse = (BuyHouse) Proxy.newProxyInstance(BuyHouse.class.getClassLoader(), new
                    Class[]{BuyHouse.class}, new DynamicProxyHandler(buyHouse));
            proxyBuyHouse.buyHosue();
        }
    }

    动态代理总结:虽然相对于静态代理,动态代理大大减少了我们的开发任务,同时减少了对业务接口的依赖,降低了耦合度。但是还是有一点点小小的遗憾之处,那就是它始终无法摆脱仅支持interface代理的桎梏(我们要使用被代理的对象的接口),因为它的设计注定了这个遗憾。

    7.4 CGLIB代理

    CGLIB 原理:动态生成一个要代理类的子类,子类重写要代理的类的所有不是final的方法。在子类中采用方法拦截的技术拦截所有父类方法的调用,顺势织入横切逻辑。它比使用java反射的JDK动态代理要快。

    CGLIB 底层:使用字节码处理框架ASM,来转换字节码并生成新的类。不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉。

    CGLIB缺点:对于final方法,无法进行代理。

    CGLIB的实现步骤:

    第一步:建立拦截器

    public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
    
            System.out.println("买房前准备");
    
            Object result = methodProxy.invoke(object, args);
    
            System.out.println("买房后装修");
    
            return result;
    
        }

    参数:Object为由CGLib动态生成的代理类实例,Method为上文中实体类所调用的被代理的方法引用,Object[]为参数值列表,MethodProxy为生成的代理类对方法的代理引用。

    返回:从代理实例的方法调用返回的值。

    其中,proxy.invokeSuper(obj,arg) 调用代理类实例上的proxy方法的父类方法(即实体类TargetObject中对应的方法)

    第二步: 生成动态代理类

    public class CglibProxy implements MethodInterceptor {
        private Object target;
        public Object getInstance(final Object target) {
            this.target = target;
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(this.target.getClass());
            enhancer.setCallback(this);
            return enhancer.create();
        }
        public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            System.out.println("买房前准备");
            Object result = methodProxy.invoke(object, args);
            System.out.println("买房后装修");
            return result;
        }
    }

    这里Enhancer类是CGLib中的一个字节码增强器,它可以方便的对你想要处理的类进行扩展,以后会经常看到它。

    首先将被代理类TargetObject设置成父类,然后设置拦截器TargetInterceptor,最后执行enhancer.create()动态生成一个代理类,并从Object强制转型成父类型TargetObject。

    第三步:测试

    public class CglibProxyTest {
        public static void main(String[] args){
            BuyHouse buyHouse = new BuyHouseImpl();
            CglibProxy cglibProxy = new CglibProxy();
            BuyHouseImpl buyHouseCglibProxy = (BuyHouseImpl) cglibProxy.getInstance(buyHouse);
            buyHouseCglibProxy.buyHosue();
        }
    }

    CGLIB代理总结: CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高,但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象,因为无需频繁创建对象,用CGLIB合适,反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法,对于final修饰的方法无法进行代理。

     

    8 外观模式

    定义: 隐藏了系统的复杂性,并向客户端提供了一个可以访问系统的接口。

    8.1 模式结构和代码示例

    简单来说,该模式就是把一些复杂的流程封装成一个接口供给外部用户更简单的使用。这个模式中,设计到3个角色。

      1).门面角色:外观模式的核心。它被客户角色调用,它熟悉子系统的功能。内部根据客户角色的需求预定了几种功能的组合。(客户调用,同时自身调用子系统功能

      2).子系统角色:实现了子系统的功能。它对客户角色和Facade时未知的。它内部可以有系统内的相互交互,也可以由供外界调用的接口。(实现具体功能)

      3).客户角色:通过调用Facede来完成要实现的功能(调用门面角色)。

    举例(每个Computer都有CPU、Memory、Disk。在Computer开启和关闭的时候,相应的部件也会开启和关闭),类图如下:

     

    首先是子系统类:

    public class CPU {
    
    	public void start() {
    		System.out.println("cpu is start...");
    	}
    
    	public void shutDown() {
    		System.out.println("CPU is shutDown...");
    	}
    }
    
    public class Disk {
    	public void start() {
    		System.out.println("Disk is start...");
    	}
    
    	public void shutDown() {
    		System.out.println("Disk is shutDown...");
    	}
    }
    
    public class Memory {
    	public void start() {
    		System.out.println("Memory is start...");
    	}
    
    	public void shutDown() {
    		System.out.println("Memory is shutDown...");
    	}
    }

    然后是,门面类Facade

    public class Computer {
    
    	private CPU cpu;
    	private Memory memory;
    	private Disk disk;
    
    	public Computer() {
    		cpu = new CPU();
    		memory = new Memory();
    		disk = new Disk();
    	}
    
    	public void start() {
    		System.out.println("Computer start begin");
    		cpu.start();
    		disk.start();
    		memory.start();
    		System.out.println("Computer start end");
    	}
    
    	public void shutDown() {
    		System.out.println("Computer shutDown begin");
    		cpu.shutDown();
    		disk.shutDown();
    		memory.shutDown();
    		System.out.println("Computer shutDown end...");
    	}
    }

    最后为,客户角色

    public class Client {
    
    	public static void main(String[] args) {
    		Computer computer = new Computer();
    		computer.start();
    		System.out.println("=================");
    		computer.shutDown();
    	}
    
    }

    8.2 优点

      - 松散耦合

      使得客户端和子系统之间解耦,让子系统内部的模块功能更容易扩展和维护;

      - 简单易用

      客户端根本不需要知道子系统内部的实现,或者根本不需要知道子系统内部的构成,它只需要跟Facade类交互即可。

      - 更好的划分访问层次

        有些方法是对系统外的,有些方法是系统内部相互交互的使用的。子系统把那些暴露给外部的功能集中到门面中,这样就可以实现客户端的使用,很好的隐藏了子系统内部的细节。

     

    9 桥接模式

    定义: 将抽象部分与它的实现部分分离,使它们都可以独立地变化。

    9.1 案例

    看下图手机与手机软件的类图

    增加一款新的手机软件,需要在所有手机品牌类下添加对应的手机软件类,当手机软件种类较多时,将导致类的个数急剧膨胀,难以维护

    手机和手机中的软件是什么关系?

    手机中的软件从本质上来说并不是一种手机,手机软件运行在手机中,是一种包含与被包含关系,而不是一种父与子或者说一般与特殊的关系,通过继承手机类实现手机软件类的设计是违反一般规律的。

    如果Oppo手机实现了wifi功能,继承它的Oppo应用商城也会继承wifi功能,并且Oppo手机类的任何变动,都会影响其子类

    换一种解决思路

    从类图上看起来更像是手机软件类图,涉及到手机本身相关的功能,比如说:wifi功能,放到哪个类中实现呢?放到OppoAppStore中实现显然是不合适的

    引起整个结构变化的元素有两个,一个是手机品牌,一个是手机软件,所以我们将这两个点抽出来,分别进行封装

    9.2 桥接模式结构和代码示例

    类图:

    实现:

    public interface Software {
    	public void run();
    
    }
    public class AppStore implements Software {
    	 
        @Override
        public void run() {
            System.out.println("run app store");
        }
    }
    public class Camera implements Software {
    	 
        @Override
        public void run() {
            System.out.println("run camera");
        }
    }

    抽象:

    public abstract class Phone {
    
    	protected Software software;
    
    	public void setSoftware(Software software) {
    		this.software = software;
    	}
    
    	public abstract void run();
    
    }
    public class Oppo extends Phone {
    	 
        @Override
        public void run() {
            software.run();
        }
    }
    public class Vivo extends Phone {
    	 
        @Override
        public void run() {
            software.run();
        }
    }

    对比最初的设计,将抽象部分(手机)与它的实现部分(手机软件类)分离,将实现部分抽象成单独的类,使它们都可以独立地变化。整个类图看起来像一座桥,所以称为桥接模式

    继承是一种强耦合关系,子类的实现与它的父类有非常紧密的依赖关系,父类的任何变化 都会导致子类发生变化,因此继承或者说强耦合关系严重影响了类的灵活性,并最终限制了可复用性

    从桥接模式的设计上我们可以看出聚合是一种比继承要弱的关联关系,手机类和软件类都可独立的进行变化,不会互相影响

    9.3 适用场景

    桥接模式通常适用于以下场景。

    1. 当一个类存在两个独立变化的维度,且这两个维度都需要进行扩展时。

    2. 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。

    3. 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。

    9.4 优缺点

    优点:

    (1)在很多情况下,桥接模式可以取代多层继承方案,多层继承方案违背了“单一职责原则”,复用性较差,且类的个数非常多,桥接模式是比多层继承方案更好的解决方法,它极大减少了子类的个数。

    (2)桥接模式提高了系统的可扩展性,在两个变化维度中任意扩展一个维度,都不需要修改原有系统,符合“开闭原则”。

    缺点:

    桥接模式的使用会增加系统的理解与设计难度,由于关联关系建立在抽象层,要求开发者一开始就针对抽象层进行设计与编程。

     

    10 组合模式

    定义:有时又叫作部分-整体模式,它是一种将对象组合成树状的层次结构的模式,用来表示“部分-整体”的关系,使用户对单个对象和组合对象具有一致的访问性。

    意图:将对象组合成树形结构以表示"部分-整体"的层次结构。组合模式使得用户对单个对象和组合对象的使用具有一致性。

    主要解决:它在我们树型结构的问题中,模糊了简单元素和复杂元素的概念,客户程序可以向处理简单元素一样来处理复杂元素,从而使得客户程序与复杂元素的内部结构解耦。

    何时使用: 1、您想表示对象的部分-整体层次结构(树形结构)。 2、您希望用户忽略组合对象与单个对象的不同,用户将统一地使用组合结构中的所有对象。

    如何解决:树枝和叶子实现统一接口,树枝内部组合该接口。

    关键代码:树枝内部组合该接口,并且含有内部属性 List,里面放 Component。

    组合模式的主要优点有:

    1. 组合模式使得客户端代码可以一致地处理单个对象和组合对象,无须关心自己处理的是单个对象,还是组合对象,这简化了客户端代码;

    2. 更容易在组合体内加入新的对象,客户端不会因为加入了新的对象而更改源代码,满足“开闭原则”;

    其主要缺点是:

    1. 设计较复杂,客户端需要花更多时间理清类之间的层次关系;

    2. 不容易限制容器中的构件;

    3. 不容易用继承的方法来增加构件的新功能;

    10.1 模式结构和代码示例

    • 抽象构件(Component)角色:它的主要作用是为树叶构件和树枝构件声明公共接口,并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口;在安全式的组合模式中不声明访问和管理子类的接口,管理工作由树枝构件完成。

    • 树叶构件(Leaf)角色:是组合中的叶节点对象,它没有子节点,用于实现抽象构件角色中 声明的公共接口。

    • 树枝构件(Composite)角色:是组合中的分支节点对象,它有子节点。它实现了抽象构件角色中声明的接口,它的主要作用是存储和管理子部件,通常包含 Add()、Remove()、GetChild() 等方法

    举例(访问一颗树),类图如下:

    1 组件

    public interface Component {
        public void add(Component c);
        public void remove(Component c);
        public Component getChild(int i);
        public void operation();
    
    }
    

    2 叶子

    public class Leaf implements Component{
        
    	private String name;
    	
    	
    	public Leaf(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public void add(Component c) {}
    
    	@Override
    	public void remove(Component c) {}
    
    	@Override
    	public Component getChild(int i) {
    		// TODO Auto-generated method stub
    		return null;
    	}
    
    	@Override
    	public void operation() {
    		// TODO Auto-generated method stub
    		 System.out.println("树叶"+name+":被访问!"); 
    	}
    
    }
    

    3 树枝

    public class Composite implements Component {
    
    	private ArrayList<Component> children = new ArrayList<Component>();
    
    	public void add(Component c) {
    		children.add(c);
    	}
    
    	public void remove(Component c) {
    		children.remove(c);
    	}
    
    	public Component getChild(int i) {
    		return children.get(i);
    	}
    
    	public void operation() {
    		for (Object obj : children) {
    			((Component) obj).operation();
    		}
    	}
    }

     

    11 享元模式

    定义:通过共享的方式高效的支持大量细粒度的对象。

    主要解决:在有大量对象时,有可能会造成内存溢出,我们把其中共同的部分抽象出来,如果有相同的业务请求,直接返回在内存中已有的对象,避免重新创建。

    何时使用: 1、系统中有大量对象。 2、这些对象消耗大量内存。 3、这些对象的状态大部分可以外部化。 4、这些对象可以按照内蕴状态分为很多组,当把外蕴对象从对象中剔除出来时,每一组对象都可以用一个对象来代替。 5、系统不依赖于这些对象身份,这些对象是不可分辨的。

    如何解决:用唯一标识码判断,如果在内存中有,则返回这个唯一标识码所标识的对象。

    关键代码:用 HashMap 存储这些对象。

    应用实例: 1、JAVA 中的 String,如果有则返回,如果没有则创建一个字符串保存在字符串缓存池里面。

    优点:大大减少对象的创建,降低系统的内存,使效率提高。

    缺点:提高了系统的复杂度,需要分离出外部状态和内部状态,而且外部状态具有固有化的性质,不应该随着内部状态的变化而变化,否则会造成系统的混乱。

    简单来说,我们抽取出一个对象的外部状态(不能共享)和内部状态(可以共享)。然后根据外部状态的决定是否创建内部状态对象。内部状态对象是通过哈希表保存的,当外部状态相同的时候,不再重复的创建内部状态对象,从而减少要创建对象的数量。

    11.1 享元模式的结构图和代码示例

    1、Flyweight (享元抽象类):一般是接口或者抽象类,定义了享元类的公共方法。这些方法可以分享内部状态的数据,也可以调用这些方法修改外部状态。

    2、ConcreteFlyweight(具体享元类):具体享元类实现了抽象享元类的方法,为享元对象开辟了内存空间来保存享元对象的内部数据,同时可以通过和单例模式结合只创建一个享元对象。

    3、FlyweightFactory(享元工厂类):享元工厂类创建并且管理享元类,享元工厂类针对享元类来进行编程,通过提供一个享元池来进行享元对象的管理。一般享元池设计成键值对,或者其他的存储结构来存储。当客户端进行享元对象的请求时,如果享元池中有对应的享元对象则直接返回对应的对象,否则工厂类创建对应的享元对象并保存到享元池。

    举例(JAVA 中的 String,如果有则返回,如果没有则创建一个字符串保存在字符串缓存池里面)。类图如下:

    (1)创建享元对象接口

    public interface IFlyweight {
        void print();
    }

    (2)创建具体享元对象

    public class Flyweight implements IFlyweight {
        private String id;
        public Flyweight(String id){
            this.id = id;
        }
        @Override
        public void print() {
            System.out.println("Flyweight.id = " + getId() + " ...");
        }
        public String getId() {
            return id;
        }
    }

    (3)创建工厂,这里要特别注意,为了避免享元对象被重复创建,我们使用HashMap中的key值保证其唯一。

    public class FlyweightFactory {
        private Map<String, IFlyweight> flyweightMap = new HashMap();
        public IFlyweight getFlyweight(String str){
            IFlyweight flyweight = flyweightMap.get(str);
            if(flyweight == null){
                flyweight = new Flyweight(str);
                flyweightMap.put(str, flyweight);
            }
            return  flyweight;
        }
        public int getFlyweightMapSize(){
            return flyweightMap.size();
        }
    }

    (4)测试,我们创建三个字符串,但是只会产生两个享元对象

    public class MainTest {
    	public static void main(String[] args) {
            FlyweightFactory flyweightFactory = new FlyweightFactory();
            IFlyweight flyweight1 = flyweightFactory.getFlyweight("A");
            IFlyweight flyweight2 = flyweightFactory.getFlyweight("B");
            IFlyweight flyweight3 = flyweightFactory.getFlyweight("A");
            flyweight1.print();
            flyweight2.print();
            flyweight3.print();
            System.out.println(flyweightFactory.getFlyweightMapSize());
        }
    
    }
    

     

    C、关系模式(11种)

    先来张图,看看这11中模式的关系:

    第一类:通过父类与子类的关系进行实现。

    第二类:两个类之间。

    第三类:类的状态。

    第四类:通过中间类

     

    12 策略模式

    定义: 策略模式定义了一系列算法,并将每个算法封装起来,使他们可以相互替换,且算法的变化不会影响到使用算法的客户。

    意图:定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换。

    主要解决:在有多种算法相似的情况下,使用 if...else 所带来的复杂和难以维护。

    何时使用:一个系统有许多许多类,而区分它们的只是他们直接的行为。

    如何解决:将这些算法封装成一个一个的类,任意地替换。

    关键代码:实现同一个接口。

    优点: 1、算法可以自由切换。 2、避免使用多重条件判断。 3、扩展性良好。

    缺点: 1、策略类会增多。 2、所有策略类都需要对外暴露。

    12.1 策略模式结构和示例代码

     

    抽象策略角色: 这个是一个抽象的角色,通常情况下使用接口或者抽象类去实现。对比来说,就是我们的Comparator接口。

    具体策略角色: 包装了具体的算法和行为。对比来说,就是实现了Comparator接口的实现一组实现类。 

    环境角色: 内部会持有一个抽象角色的引用,给客户端调用。

    举例如下( 实现一个加减的功能),类图如下:

    1、定义抽象策略角色

    public interface Strategy {
    
    	public int calc(int num1,int num2);
    }
    

    2、定义具体策略角色

    public class AddStrategy implements Strategy {
    
    	@Override
    	public int calc(int num1, int num2) {
    		// TODO Auto-generated method stub
    		return num1 + num2;
    	}
    
    }
    public class SubstractStrategy implements Strategy {
    
    	@Override
    	public int calc(int num1, int num2) {
    		// TODO Auto-generated method stub
    		return num1 - num2;
    	}
    
    }

    3、环境角色

    public class Environment {
    	private Strategy strategy;
    
    	public Environment(Strategy strategy) {
    		this.strategy = strategy;
    	}
    
    	public int calculate(int a, int b) {
    		return strategy.calc(a, b);
    	}
    
    }

    4、测试

    public class MainTest {
    	public static void main(String[] args) {
    		
    		Environment environment=new Environment(new AddStrategy());
    		int result=environment.calculate(20, 5);
    		System.out.println(result);
    		
    		Environment environment1=new Environment(new SubstractStrategy());
    		int result1=environment1.calculate(20, 5);
    		System.out.println(result1);
    	}
    
    }
    

     

    13 模板模式

    定义:定义一个操作中算法的骨架,而将一些步骤延迟到子类中,模板方法使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤。

    通俗点的理解就是 :完成一件事情,有固定的数个步骤,但是每个步骤根据对象的不同,而实现细节不同;就可以在父类中定义一个完成该事情的总方法,按照完成事件需要的步骤去调用其每个步骤的实现方法。每个步骤的具体实现,由子类完成。

    13.1 模式结构和代码示例

     

    抽象父类(AbstractClass):实现了模板方法,定义了算法的骨架。

    具体类(ConcreteClass):实现抽象类中的抽象方法,即不同的对象的具体实现细节。

    举例( 我们做菜可以分为三个步骤 (1)备料 (2)具体做菜 (3)盛菜端给客人享用,这三部就是算法的骨架 ;然而做不同菜需要的料,做的方法,以及如何盛装给客人享用都是不同的这个就是不同的实现细节。)。类图如下:

    a. 先来写一个抽象的做菜父类: 

    public abstract class Dish {    
        /**
         * 具体的整个过程
         */
        protected void dodish(){
            this.preparation();
            this.doing();
            this.carriedDishes();
        }
        /**
         * 备料
         */
        public abstract void preparation();
        /**
         * 做菜
         */
        public abstract void doing();
        /**
         * 上菜
         */
        public abstract void carriedDishes ();
    }

    b. 下来做两个番茄炒蛋(EggsWithTomato)和红烧肉(Bouilli)实现父类中的抽象方法

    public class EggsWithTomato extends Dish {
    
    	@Override
    	public void preparation() {
    		System.out.println("洗并切西红柿,打鸡蛋。");
    	}
    
    	@Override
    	public void doing() {
    		System.out.println("鸡蛋倒入锅里,然后倒入西红柿一起炒。");
    	}
    
    	@Override
    	public void carriedDishes() {
    		System.out.println("将炒好的西红寺鸡蛋装入碟子里,端给客人吃。");
    	}
    
    }
    public class Bouilli extends Dish{
    
        @Override
        public void preparation() {
            System.out.println("切猪肉和土豆。");
        }
    
        @Override
        public void doing() {
            System.out.println("将切好的猪肉倒入锅中炒一会然后倒入土豆连炒带炖。");
        }
    
        @Override
        public void carriedDishes() {
            System.out.println("将做好的红烧肉盛进碗里端给客人吃。");
        }
    
    }

    c. 在测试类中我们来做菜:

    public class MainTest {
    	public static void main(String[] args) {
    		Dish eggsWithTomato = new EggsWithTomato();
    		eggsWithTomato.dodish();
    
    		System.out.println("-----------------------------");
    
    		Dish bouilli = new Bouilli();
    		bouilli.dodish();
    	}
    
    }

    13.2  模板模式的优点和缺点

    优点:

     (1)具体细节步骤实现定义在子类中,子类定义详细处理算法是不会改变算法整体结构。

     (2)代码复用的基本技术,在数据库设计中尤为重要。

     (3)存在一种反向的控制结构,通过一个父类调用其子类的操作,通过子类对父类进行扩展增加新的行为,符合“开闭原则”。

    缺点:

        每个不同的实现都需要定义一个子类,会导致类的个数增加,系统更加庞大。

     

    14 观察者模式

    定义: 定义对象间的一种一对多的依赖关系,当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并被自动更新。

    主要解决:一个对象状态改变给其他对象通知的问题,而且要考虑到易用和低耦合,保证高度的协作。

    何时使用:一个对象(目标对象)的状态发生改变,所有的依赖对象(观察者对象)都将得到通知,进行广播通知。

    如何解决:使用面向对象技术,可以将这种依赖关系弱化。

    关键代码:在抽象类里有一个 ArrayList 存放观察者们。

    优点: 1、观察者和被观察者是抽象耦合的。 2、建立一套触发机制。

    缺点: 1、如果一个被观察者对象有很多的直接和间接的观察者的话,将所有的观察者都通知到会花费很多时间。 2、如果在观察者和观察目标之间有循环依赖的话,观察目标会触发它们之间进行循环调用,可能导致系统崩溃。 3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的,而仅仅只是知道观察目标发生了变化。

    14.1 模式结构图和代码示例

    • 抽象被观察者角色:也就是一个抽象主题,它把所有对观察者对象的引用保存在一个集合中,每个主题都可以有任意数量的观察者。抽象主题提供一个接口,可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

    • 抽象观察者角色:为所有的具体观察者定义一个接口,在得到主题通知时更新自己。

    • 具体被观察者角色:也就是一个具体的主题,在集体主题的内部状态改变时,所有登记过的观察者发出通知。

    • 具体观察者角色:实现抽象观察者角色所需要的更新接口,一边使本身的状态与制图的状态相协调。

    举例(有一个微信公众号服务,不定时发布一些消息,关注公众号就可以收到推送消息,取消关注就收不到推送消息。)类图如下:

     

    1、定义一个抽象被观察者接口

    public interface Subject {
    	
    	  public void registerObserver(Observer o);
    	  public void removeObserver(Observer o);
    	  public void notifyObserver();
    
    }
    

    2、定义一个抽象观察者接口

    public interface Observer {
    	
    	public void update(String message);
    
    }
    

    3、定义被观察者,实现了Observerable接口,对Observerable接口的三个方法进行了具体实现,同时有一个List集合,用以保存注册的观察者,等需要通知观察者时,遍历该集合即可。

    public class WechatServer implements Subject {
    
    	private List<Observer> list;
    	private String message;
    
    	public WechatServer() {
    		list = new ArrayList<Observer>();
    	}
    
    	@Override
    	public void registerObserver(Observer o) {
    		// TODO Auto-generated method stub
    		list.add(o);
    	}
    
    	@Override
    	public void removeObserver(Observer o) {
    		// TODO Auto-generated method stub
    		if (!list.isEmpty()) {
    			list.remove(o);
    		}
    	}
    
    	@Override
    	public void notifyObserver() {
    		// TODO Auto-generated method stub
    		for (Observer o : list) {
    			o.update(message);
    		}
    	}
    
    	public void setInfomation(String s) {
    		this.message = s;
    		System.out.println("微信服务更新消息: " + s);
    		// 消息更新,通知所有观察者
    		notifyObserver();
    	}
    
    }

    4、定义具体观察者,微信公众号的具体观察者为用户User

    public class User implements Observer {
    
    	private String name;
    	private String message;
    
    	public User(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public void update(String message) {
    		this.message = message;
    		read();
    	}
    
    	public void read() {
    		System.out.println(name + " 收到推送消息: " + message);
    	}
    
    }

    5、编写一个测试类

    public class MainTest {
    	
    	 public static void main(String[] args) {
    		 
    	        WechatServer server = new WechatServer();
    	        
    	        Observer userZhang = new User("ZhangSan");
    	        Observer userLi = new User("LiSi");
    	        Observer userWang = new User("WangWu");
    	        
    	        server.registerObserver(userZhang);
    	        server.registerObserver(userLi);
    	        server.registerObserver(userWang);
    	        server.setInfomation("PHP是世界上最好用的语言!");
    	        
    	        System.out.println("----------------------------------------------");
    	        server.removeObserver(userZhang);
    	        server.setInfomation("JAVA是世界上最好用的语言!");
    	        
    	    }
    
    }
    

     

    15 迭代器模式

    定义:提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。

    简单来说,不同种类的对象可能需要不同的遍历方式,我们对每一种类型的对象配一个迭代器,最后多个迭代器合成一个。

    主要解决:不同的方式来遍历整个整合对象。

    何时使用:遍历一个聚合对象。

    如何解决:把在元素之间游走的责任交给迭代器,而不是聚合对象。

    关键代码:定义接口:hasNext, next。

    应用实例:JAVA 中的 iterator。

    优点: 1、它支持以不同的方式遍历一个聚合对象。 2、迭代器简化了聚合类。 3、在同一个聚合上可以有多个遍历。 4、在迭代器模式中,增加新的聚合类和迭代器类都很方便,无须修改原有代码。

    缺点:由于迭代器模式将存储数据和遍历数据的职责分离,增加新的聚合类需要对应增加新的迭代器类,类的个数成对增加,这在一定程度上增加了系统的复杂性。

    15.1 模式结构和代码示例

    (1)迭代器角色(Iterator):定义遍历元素所需要的方法,一般来说会有这么三个方法:取得下一个元素的方法next(),判断是否遍历结束的方法hasNext()),移出当前对象的方法remove(),

    (2)具体迭代器角色(Concrete Iterator):实现迭代器接口中定义的方法,完成集合的迭代。

    (3)容器角色(Aggregate):  一般是一个接口,提供一个iterator()方法,例如java中的Collection接口,List接口,Set接口等

    (4)具体容器角色(ConcreteAggregate):就是抽象容器的具体实现类,比如List接口的有序列表实现ArrayList,List接口的链表实现LinkList,Set接口的哈希列表的实现HashSet等。

    举例(咖啡厅和中餐厅合并,他们两个餐厅的菜单一个是数组保存的,一个是ArrayList保存的。遍历方式不一样,使用迭代器聚合访问,只需要一种方式)

    1 迭代器接口

    public interface Iterator {
    	
    	public boolean hasNext();
    	public Object next();
    	
    }
    

    2 咖啡店菜单和咖啡店菜单遍历器

    public class CakeHouseMenu {
    	private ArrayList<MenuItem> menuItems;
    	
    	
    	public CakeHouseMenu() {
    		menuItems = new ArrayList<MenuItem>();
    		
    		addItem("KFC Cake Breakfast","boiled eggs&toast&cabbage",true,3.99f);
    		addItem("MDL Cake Breakfast","fried eggs&toast",false,3.59f);
    		addItem("Stawberry Cake","fresh stawberry",true,3.29f);
    		addItem("Regular Cake Breakfast","toast&sausage",true,2.59f);
    	}
    
    	private void addItem(String name, String description, boolean vegetable,
    			float price) {
    		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
    		menuItems.add(menuItem);
    	}
    	
    
    	
    	public Iterator getIterator()
    	{
    		return new CakeHouseIterator() ;
    	}
    	
    	class CakeHouseIterator implements  Iterator
    	 {		
    		private int position=0;
    		public CakeHouseIterator()
    		{
    			  position=0;
    		}
    		
    		 	@Override
    			public boolean hasNext() {
    			// TODO Auto-generated method stub
    			if(position<menuItems.size())
    			{
    				return true;
    			}
    			
    			return false;
    		}
    
    		@Override
    		public Object next() {
    			// TODO Auto-generated method stub
    			MenuItem menuItem =menuItems.get(position);
    			position++;
    			return menuItem;
    		}};
    	//鍏朵粬鍔熻兘浠g爜
    	
    }

    3 中餐厅菜单和中餐厅菜单遍历器

    public class DinerMenu {
    	private final static int Max_Items = 5;
    	private int numberOfItems = 0;
    	private MenuItem[] menuItems;
    
    	public DinerMenu() {
    		menuItems = new MenuItem[Max_Items];
    		addItem("vegetable Blt", "bacon&lettuce&tomato&cabbage", true, 3.58f);
    		addItem("Blt", "bacon&lettuce&tomato", false, 3.00f);
    		addItem("bean soup", "bean&potato salad", true, 3.28f);
    		addItem("hotdog", "onions&cheese&bread", false, 3.05f);
    
    	}
    
    	private void addItem(String name, String description, boolean vegetable,
    			float price) {
    		MenuItem menuItem = new MenuItem(name, description, vegetable, price);
    		if (numberOfItems >= Max_Items) {
    			System.err.println("sorry,menu is full!can not add another item");
    		} else {
    			menuItems[numberOfItems] = menuItem;
    			numberOfItems++;
    		}
    
    	}
    
    	public Iterator getIterator() {
    		return new DinerIterator();
    	}
    
    	class DinerIterator implements Iterator {
    		private int position;
    
    		public DinerIterator() {
    			position = 0;
    		}
    
    		@Override
    		public boolean hasNext() {
    			// TODO Auto-generated method stub
    			if (position < numberOfItems) {
    				return true;
    			}
    			
    			return false;
    		}
    
    		@Override
    		public Object next() {
    			// TODO Auto-generated method stub
    			MenuItem menuItem = menuItems[position];
    			position++;
    			return menuItem;
    		}
    	};
    }
    

    4 女服务员

    public class Waitress {
    	private ArrayList<Iterator> iterators = new ArrayList<Iterator>();
    
    	public Waitress() {
    
    	}
    
    	public void addIterator(Iterator iterator) {
    		iterators.add(iterator);
    
    	}
    
    	public void printMenu() {
    		Iterator iterator;
    		MenuItem menuItem;
    		for (int i = 0, len = iterators.size(); i < len; i++) {
    			iterator = iterators.get(i);
    
    			while (iterator.hasNext()) {
    				menuItem = (MenuItem) iterator.next();
    				System.out
    						.println(menuItem.getName() + "***" + menuItem.getPrice() + "***" + menuItem.getDescription());
    
    			}
    
    		}
    
    	}
    
    	public void printBreakfastMenu() {
    
    	}
    
    	public void printLunchMenu() {
    
    	}
    
    	public void printVegetableMenu() {
    
    	}
    }
    

    16 责任链模式

    定义:如果有多个对象有机会处理请求,责任链可使请求的发送者和接受者解耦,请求沿着责任链传递,直到有一个对象处理了它为止。

    主要解决:职责链上的处理者负责处理请求,客户只需要将请求发送到职责链上即可,无须关心请求的处理细节和请求的传递,所以职责链将请求的发送者和请求的处理者解耦了。

    何时使用:在处理消息的时候以过滤很多道。

    如何解决:拦截的类都实现统一接口。

    关键代码:Handler 里面聚合它自己,在 HandlerRequest 里判断是否合适,如果没达到条件则向下传递,向谁传递之前 set 进去。

    16.1 模式的结构和代码示例

    1. 抽象处理者(Handler)角色:定义一个处理请求的接口,包含抽象处理方法和一个后继连接。

    2. 具体处理者(Concrete Handler)角色:实现抽象处理者的处理方法,判断能否处理本次请求,如果可以处理请求则处理,否则将该请求转给它的后继者。

    3. 客户类(Client)角色:创建处理链,并向链头的具体处理者对象提交请求,它不关心处理细节和请求的传递过程。

    举例(购买请求决策,价格不同要由不同的级别决定:组长、部长、副部、总裁)。类图如下:

    1 决策者抽象类,包含对请求处理的函数,同时还包含指定下一个决策者的函数

    public abstract class Approver {
    	 Approver successor;
    	 String Name;
    	public Approver(String Name)
    	{
    		this.Name=Name;
    	}
    	public abstract void ProcessRequest( PurchaseRequest request);
    	public void SetSuccessor(Approver successor) {
    		// TODO Auto-generated method stub
    		this.successor=successor;
    	}
    }
    

    2 客户端以及请求

    public class PurchaseRequest {
    	private int Type = 0;
    	private int Number = 0;
    	private float Price = 0;
    	private int ID = 0;
    
    	public PurchaseRequest(int Type, int Number, float Price) {
    		this.Type = Type;
    		this.Number = Number;
    		this.Price = Price;
    	}
    
    	public int GetType() {
    		return Type;
    	}
    
    	public float GetSum() {
    		return Number * Price;
    	}
    
    	public int GetID() {
    		return (int) (Math.random() * 1000);
    	}
    }
    public class Client {
    
    	public Client() {
    
    	}
    
    	public PurchaseRequest sendRequst(int Type, int Number, float Price) {
    		return new PurchaseRequest(Type, Number, Price);
    	}
    
    }
    

    3 组长、部长。。。继承决策者抽象类

    public class GroupApprover extends Approver {
    
    	public GroupApprover(String Name) {
    		super(Name + " GroupLeader");
    		// TODO Auto-generated constructor stub
    
    	}
    
    	@Override
    	public void ProcessRequest(PurchaseRequest request) {
    		// TODO Auto-generated method stub
    
    		if (request.GetSum() < 5000) {
    			System.out.println("**This request " + request.GetID() + " will be handled by " + this.Name + " **");
    		} else {
    			successor.ProcessRequest(request);
    		}
    	}
    
    }
    public class DepartmentApprover extends Approver {
    
    	public DepartmentApprover(String Name) {
    		super(Name + " DepartmentLeader");
    
    	}
    
    	@Override
    	public void ProcessRequest(PurchaseRequest request) {
    		// TODO Auto-generated method stub
    
    		if ((5000 <= request.GetSum()) && (request.GetSum() < 10000)) {
    			System.out.println("**This request " + request.GetID()
    					+ " will be handled by " + this.Name + " **");
    		} else {
    			successor.ProcessRequest(request);
    		}
    
    	}
    
    }

    4测试

    public class MainTest {
    
    	public static void main(String[] args) {
    
    		Client mClient = new Client();
    		Approver GroupLeader = new GroupApprover("Tom");
    		Approver DepartmentLeader = new DepartmentApprover("Jerry");
    		Approver VicePresident = new VicePresidentApprover("Kate");
    		Approver President = new PresidentApprover("Bush");
    
    		GroupLeader.SetSuccessor(VicePresident);
    		DepartmentLeader.SetSuccessor(President);
    		VicePresident.SetSuccessor(DepartmentLeader);
    		President.SetSuccessor(GroupLeader);
    
    		GroupLeader.ProcessRequest(mClient.sendRequst(1, 10000, 40));
    
    	}
    
    }

     

    17 命令模式

    定义:将一个请求封装为一个对象,使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通,这样方便将命令对象进行储存、传递、调用、增加与管理。

    意图:将一个请求封装成一个对象,从而使您可以用不同的请求对客户进行参数化。

    主要解决:在软件系统中,行为请求者与行为实现者通常是一种紧耦合的关系,但某些场合,比如需要对行为进行记录、撤销或重做、事务等处理时,这种无法抵御变化的紧耦合的设计就不太合适。

    何时使用:在某些场合,比如要对行为进行"记录、撤销/重做、事务"等处理,这种无法抵御变化的紧耦合是不合适的。在这种情况下,如何将"行为请求者"与"行为实现者"解耦?将一组行为抽象为对象,可以实现二者之间的松耦合。

    如何解决:通过调用者调用接受者执行命令,顺序:调用者→接受者→命令。

    17.1模式结构和代码示例

    1. 抽象命令类(Command)角色:声明执行命令的接口,拥有执行命令的抽象方法 execute()。
    2. 具体命令角色(Concrete    Command)角色:是抽象命令类的具体实现类,它拥有接收者对象,并通过调用接收者的功能来完成命令要执行的操作。
    3. 实现者/接收者(Receiver)角色:执行命令功能的相关操作,是具体命令对象业务的真正实现者。
    4. 调用者/请求者(Invoker)角色:是请求的发送者,它通常拥有很多的命令对象,并通过访问命令对象来执行相关请求,它不直接访问接收者。

    代码举例(开灯和关灯),类图如下:

    1 命令抽象类

    public interface Command {
    	
    	public void excute();
    	public void undo();
    
    }
    

    2 具体命令对象

    public class TurnOffLight implements Command {
    
    	private Light light;
    
    	public TurnOffLight(Light light) {
    		this.light = light;
    	}
    
    	@Override
    	public void excute() {
    		// TODO Auto-generated method stub
    		light.Off();
    	}
    
    	@Override
    	public void undo() {
    		// TODO Auto-generated method stub
    		light.On();
    	}
    
    }

    3 实现者

    public class Light {
    
    	String loc = "";
    
    	public Light(String loc) {
    		this.loc = loc;
    	}
    
    	public void On() {
    
    		System.out.println(loc + " On");
    	}
    
    	public void Off() {
    
    		System.out.println(loc + " Off");
    	}
    
    }

    4 请求者

    public class Contral{
    
    	public void CommandExcute(Command command) {
    		// TODO Auto-generated method stub
    		command.excute();
    	}
    
    	public void CommandUndo(Command command) {
    		// TODO Auto-generated method stub
    		command.undo();
    	}
    
    }
    

     

    18 状态模式

    定义: 在状态模式中,我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。

    简单理解,一个拥有状态的context对象,在不同的状态下,其行为会发生改变。

    意图:允许对象在内部状态发生改变时改变它的行为,对象看起来好像修改了它的类。

    主要解决:对象的行为依赖于它的状态(属性),并且可以根据它的状态改变而改变它的相关行为。

    何时使用:代码中包含大量与对象状态有关的条件语句。

    如何解决:将各种具体的状态类抽象出来。

    关键代码:通常命令模式的接口中只有一个方法。而状态模式的接口中有一个或者多个方法。而且,状态模式的实现类的方法,一般返回值,或者是改变实例变量的值。也就是说,状态模式一般和对象的状态有关。实现类的方法有不同的功能,覆盖接口中的方法。状态模式和命令模式一样,也可以用于消除 if...else 等条件选择语句。

    优点: 1、封装了转换规则。 2、枚举可能的状态,在枚举状态之前需要确定状态种类。 3、将所有与某个状态有关的行为放到一个类中,并且可以方便地增加新的状态,只需要改变对象状态即可改变对象的行为。 4、允许状态转换逻辑与状态对象合成一体,而不是某一个巨大的条件语句块。 5、可以让多个环境对象共享一个状态对象,从而减少系统中对象的个数。

    缺点: 1、状态模式的使用必然会增加系统类和对象的个数。 2、状态模式的结构与实现都较为复杂,如果使用不当将导致程序结构和代码的混乱。 3、状态模式对"开闭原则"的支持并不太好,对于可以切换状态的状态模式,增加新的状态类需要修改那些负责状态转换的源代码,否则无法切换到新增状态,而且修改某个状态类的行为也需修改对应类的源代码。

    18.1 模式结构和代码示例

     

    • State抽象状态角色

      接口或抽象类,负责对象状态定义,并且封装环境角色以实现状态切换。

    • ConcreteState具体状态角色

      具体状态主要有两个职责:一是处理本状态下的事情,二是从本状态如何过渡到其他状态。

    • Context环境角色

      定义客户端需要的接口,并且负责具体状态的切换。

    举例(人物在地点A向地点B移动,在地点B向地点A移动)。类图如下:

    1 state接口

    public interface State {
    	public void stop();
    	public void move();
    
    }
    

    2 状态实例

    public class PlaceA implements State {
    
    	private Player context;
    
    	public PlaceA(Player context) {
    		this.context = context;
    	}
    
    	@Override
    	public void move() {
    		System.out.println("处于地点A,开始向B移动");
    		System.out.println("--------");
    		context.setDirection("AB");
    		context.setState(context.onMove);
    
    	}
    
    	@Override
    	public void stop() {
    		// TODO Auto-generated method stub
    		System.out.println("正处在地点A,不用停止移动");
    		System.out.println("--------");
    	}
    
    }
    

    3 context(player)拥有状态的对象

    public class Player {
    
    	State placeA;
    	State placeB;
    	State onMove;
    	private State state;
    	private String direction;
    
    	public Player() {
    		direction = "AB";
    		placeA = new PlaceA(this);
    		placeB = new PlaceB(this);
    		onMove = new OnMove(this);
    		this.state = placeA;
    	}
    
    	public void move() {
    		System.out.println("指令:开始移动");
    		state.move();
    	}
    
    	public void stop() {
    		System.out.println("指令:停止移动");
    		state.stop();
    	}
    
    	public State getState() {
    		return state;
    	}
    
    	public void setState(State state) {
    		this.state = state;
    	}
    
    	public void setDirection(String direction) {
    		this.direction = direction;
    	}
    
    	public String getDirection() {
    		return direction;
    	}
    
    }

     

    19 备忘录模式

    定义: 在不破坏封装性的前提下,捕获一个对象的内部状态,并在该对象之外保存这个状态,以便以后当需要时能将该对象恢复到原先保存的状态。该模式又叫快照模式。

    备忘录模式是一种对象行为型模式,其主要优点如下。

    • 提供了一种可以恢复状态的机制。当用户需要时能够比较方便地将数据恢复到某个历史的状态。

    • 实现了内部状态的封装。除了创建它的发起人之外,其他对象都不能够访问这些状态信息。

    • 简化了发起人类。发起人不需要管理和保存其内部状态的各个备份,所有状态信息都保存在备忘录中,并由管理者进行管理,这符合单一职责原则。

    其主要缺点是:资源消耗大。如果要保存的内部状态信息过多或者特别频繁,将会占用比较大的内存资源。

    19.1 模式结构图和代码示例

    1. 发起人(Originator)角色:记录当前时刻的内部状态信息,提供创建备忘录和恢复备忘录数据的功能,实现其他业务功能,它可以访问备忘录里的所有信息。

    2. 备忘录(Memento)角色:负责存储发起人的内部状态,在需要的时候提供这些内部状态给发起人。

    3. 管理者(Caretaker)角色:对备忘录进行管理,提供保存与获取备忘录的功能,但其不能对备忘录的内容进行访问与修改。

     

    举例(发起者通过备忘录存储信息和获取信息),类图如下:

     

    1 备忘录接口

    public interface MementoIF {
    
    }
    

    2 备忘录

    public class Memento implements MementoIF{
    	
    	private String state;
    
    	public Memento(String state) {
    		this.state = state;
    	}
    	
    	public String getState(){
    		return state;
    	}
    	
    
    }
    

    3 发起者

    public class Originator {
    
    	private String state;
    
    	public String getState() {
    		return state;
    	}
    
    	public void setState(String state) {
    		this.state = state;
    	}
    
    	public Memento saveToMemento() {
    		return new Memento(state);
    	}
    
    	public String getStateFromMemento(MementoIF memento) {
    		return ((Memento) memento).getState();
    	}
    
    }

    4 管理者

    public class CareTaker {
    	
    	private List<MementoIF> mementoList = new ArrayList<MementoIF>();
    
    	public void add(MementoIF memento) {
    		mementoList.add(memento);
    	}
    
    	public MementoIF get(int index) {
    		return mementoList.get(index);
    	}
    
    }
    

     

    20 访问者模式

    定义:将作用于某种数据结构中的各元素的操作分离出来封装成独立的类,使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作,为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离。

    访问者(Visitor)模式是一种对象行为型模式,其主要优点如下。

    1. 扩展性好。能够在不修改对象结构中的元素的情况下,为对象结构中的元素添加新的功能。

    2. 复用性好。可以通过访问者来定义整个对象结构通用的功能,从而提高系统的复用程度。

    3. 灵活性好。访问者模式将数据结构与作用于结构上的操作解耦,使得操作集合可相对自由地演化而不影响系统的数据结构。

    4. 符合单一职责原则。访问者模式把相关的行为封装在一起,构成一个访问者,使每一个访问者的功能都比较单一。

    访问者(Visitor)模式的主要缺点如下。

    1. 增加新的元素类很困难。在访问者模式中,每增加一个新的元素类,都要在每一个具体访问者类中增加相应的具体操作,这违背了“开闭原则”。

    2. 破坏封装。访问者模式中具体元素对访问者公布细节,这破坏了对象的封装性。

    3. 违反了依赖倒置原则。访问者模式依赖了具体类,而没有依赖抽象类。

    20.1 模式结构和代码示例

    访问者模式包含以下主要角色。

    1. 抽象访问者(Visitor)角色:定义一个访问具体元素的接口,为每个具体元素类对应一个访问操作 visit() ,该操作中的参数类型标识了被访问的具体元素。

    2. 具体访问者(ConcreteVisitor)角色:实现抽象访问者角色中声明的各个访问操作,确定访问者访问一个元素时该做什么。

    3. 抽象元素(Element)角色:声明一个包含接受操作 accept() 的接口,被接受的访问者对象作为 accept() 方法的参数。

    4. 具体元素(ConcreteElement)角色:实现抽象元素角色提供的 accept() 操作,其方法体通常都是 visitor.visit(this) ,另外具体元素中可能还包含本身业务逻辑的相关操作。

    5. 对象结构(Object Structure)角色:是一个包含元素角色的容器,提供让访问者对象遍历容器中的所有元素的方法,通常由 List、Set、Map 等聚合类实现。

    1 抽象访问者

    public interface Visitor {
    
    	abstract public void Visit(Element element);
    }
    

    2 具体访问者

    public class CompensationVisitor implements Visitor {
    
    	@Override
    	public void Visit(Element element) {
    		// TODO Auto-generated method stub
    		Employee employee = ((Employee) element);
    
    		System.out.println(
    				employee.getName() + "'s Compensation is " + (employee.getDegree() * employee.getVacationDays() * 10));
    	}
    
    }
    

    3 抽象元素

    public interface Element {
    	abstract public void Accept(Visitor visitor);
    
    }
    

    4 具体元素

    public class CompensationVisitor implements Visitor {
    
    	@Override
    	public void Visit(Element element) {
    		// TODO Auto-generated method stub
    		Employee employee = ((Employee) element);
    
    		System.out.println(
    				employee.getName() + "'s Compensation is " + (employee.getDegree() * employee.getVacationDays() * 10));
    	}
    
    }
    

    5 对象结构

    public class ObjectStructure {
    	private HashMap<String, Employee> employees;
    
    	public ObjectStructure() {
    		employees = new HashMap();
    	}
    
    	public void Attach(Employee employee) {
    		employees.put(employee.getName(), employee);
    	}
    
    	public void Detach(Employee employee) {
    		employees.remove(employee);
    	}
    
    	public Employee getEmployee(String name) {
    		return employees.get(name);
    	}
    
    	public void Accept(Visitor visitor) {
    		for (Employee e : employees.values()) {
    			e.Accept(visitor);
    		}
    	}
    
    }

     

    21 中介者模式

    定义:定义一个中介对象来封装一系列对象之间的交互,使原有对象之间的耦合松散,且可以独立地改变它们之间的交互。中介者模式又叫调停模式,它是迪米特法则的典型应用。

    中介者模式是一种对象行为型模式,其主要优点如下。

    1. 降低了对象之间的耦合性,使得对象易于独立地被复用。

    2. 将对象间的一对多关联转变为一对一的关联,提高系统的灵活性,使得系统易于维护和扩展。

    其主要缺点是:当同事类太多时,中介者的职责将很大,它会变得复杂而庞大,以至于系统难以维护。

    21.1 模式结构和代码示例

    1. 抽象中介者(Mediator)角色:它是中介者的接口,提供了同事对象注册与转发同事对象信息的抽象方法。

    2. 具体中介者(ConcreteMediator)角色:实现中介者接口,定义一个 List 来管理同事对象,协调各个同事角色之间的交互关系,因此它依赖于同事角色。

    3. 抽象同事类(Colleague)角色:定义同事类的接口,保存中介者对象,提供同事对象交互的抽象方法,实现所有相互影响的同事类的公共功能。

    4. 具体同事类(Concrete Colleague)角色:是抽象同事类的实现者,当需要与其他同事对象交互时,由中介者对象负责后续的交互。

    举例(通过中介卖方),类图如下:

    1 抽象中介者

    public interface Mediator {
    
    	void register(Colleague colleague); // 客户注册
    
    	void relay(String from, String to,String ad); // 转发
    
    }
    

    2 具体中介者

    public class ConcreteMediator implements Mediator {
    
    	private List<Colleague> colleagues = new ArrayList<Colleague>();
    
    	@Override
    	public void register(Colleague colleague) {
    		// TODO Auto-generated method stub
    		if (!colleagues.contains(colleague)) {
    			colleagues.add(colleague);
    			colleague.setMedium(this);
    		}
    	}
    
    	@Override
    	public void relay(String from, String to, String ad) {
    		// TODO Auto-generated method stub
    		for (Colleague cl : colleagues) {
    
    			String name = cl.getName();
    			if (name.equals(to)) {
    				cl.receive(from, ad);
    			}
    
    		}
    
    	}
    
    }

    3 抽象同事类

    public abstract class Colleague {
    
    	protected Mediator mediator;
    	protected String name;
    
    	public Colleague(String name) {
    		this.name = name;
    	}
    
    	public void setMedium(Mediator mediator) {
    
    		this.mediator = mediator;
    
    	}
    
    	public String getName() {
    		return name;
    	}
    
    	public abstract void Send(String to, String ad);
    
    	public abstract void receive(String from, String ad);
    
    }

    4 具体同事类

    public class Buyer extends Colleague {
    
    	public Buyer(String name) {
    
    		super(name);
    
    	}
    
    	@Override
    	public void Send(String to, String ad) {
    		// TODO Auto-generated method stub
    		mediator.relay(name, to, ad);
    	}
    
    	@Override
    	public void receive(String from, String ad) {
    		// TODO Auto-generated method stub
    		System.out.println(name + "接收到来自" + from + "的消息:" + ad);
    	}
    
    }

     

    展开全文
  • 本资源是本人学习需要,通过网上查询,摘取网上有关设计模式好的解释,再由个人整理而得,绝对详解,看代码时最好结合word文档的图解一起,学习使用。
  • Java的23种设计模式详解, 结合代码详细说明, 容易理解, 强烈推荐
  • Java开发中的23种设计模式详解
  • 23种设计模式详解及编程思想
  • 23种设计模式详解.ppt

    2021-02-19 17:42:58
    23种设计模式详解.ppt
  • 设计模式23种设计模式,非常有用,里面的东西非常实用,适合初学者,大家可以好好学习下
  • 设计模式”这个术语最初并不是出现在软件设计中,而是被用于建筑领域的设计中。 1977 年,美国著名建筑大师、加利福尼亚大学伯克利分校环境结构中心主任克里斯托
  • Java开发中的23种设计模式详解.doc
  • java23种设计模式详解+源码,java23种设计模式详解+源码,java23种设计模式详解+源码
  • 设计模式精解,GoF 23种设计模式解析附C++实现源码 ,当工具书用,设计模式是程序开发的兵法。
  • 非常全的23种设计模式详解,收藏了

    万次阅读 多人点赞 2016-09-12 14:21:34
    非常全的23种设计模式详解,收藏了,以后忘记了。可以看。

    源博文出处:http://blog.csdn.net/lovelion/article/details/17517213

    非常详细的设计模式。 收藏了,以后需要慢慢研究。     


    基础知识

     

    设计模式概述

    从招式与内功谈起——设计模式概述(一):设计模式从何而来?

    从招式与内功谈起——设计模式概述(二):设计模式是什么?

    从招式与内功谈起——设计模式概述(三):设计模式有什么用?附:个人观点

     

    面向对象设计原则

    面向对象设计原则概述

    面向对象设计原则之单一职责原则

    面向对象设计原则之开闭原则

    面向对象设计原则之里氏代换原则

    面向对象设计原则之依赖倒转原则

    面向对象设计原则之接口隔离原则

    面向对象设计原则之合成复用原则

    面向对象设计原则之迪米特法则

     

    六个创建型模式

     

    简单工厂模-Simple Factory Pattern

    工厂三兄弟之简单工厂模式(一):图表库的设计

    工厂三兄弟之简单工厂模式(二):简单工厂模式概述

    工厂三兄弟之简单工厂模式(三):图表库的简单工厂模式解决方案

    工厂三兄弟之简单工厂模式(四):图表库解决方案的改进,简单工厂模式的简化,简单工厂模式总结

     

    工厂方法模式-Factory Method Pattern

    工厂三兄弟之工厂方法模式(一):日志记录器的设计

    工厂三兄弟之工厂方法模式(二):工厂方法模式概述

    工厂三兄弟之工厂方法模式(三):日志记录器的工厂方法模式解决方案,反射与配置文件

    工厂三兄弟之工厂方法模式(四):重载的工厂方法,工厂方法的隐藏,工厂方法模式总结

     

    抽象工厂模式-Abstract  Factory Pattern

    工厂三兄弟之抽象工厂模式(一):界面皮肤库的初始设计

    工厂三兄弟之抽象工厂模式(二):产品等级结构与产品族

    工厂三兄弟之抽象工厂模式(三):抽象工厂模式概述

    工厂三兄弟之抽象工厂模式(四):界面皮肤库的抽象工厂模式解决方案

    工厂三兄弟之抽象工厂模式(五):“开闭原则”的倾斜性,抽象工厂模式总结

     

    单例模式-Singleton Pattern

    确保对象的唯一性——单例模式 (一):单例模式的动机,单例模式概述

    确保对象的唯一性——单例模式 (二):负载均衡器的设计与实现

    确保对象的唯一性——单例模式 (三):饿汉式单例与懒汉式单例的讨论

    确保对象的唯一性——单例模式 (四):一种更好的单例实现方法(静态内部类)

    确保对象的唯一性——单例模式 (五):单例模式总结

     

    原型模式-Prototype Pattern

    对象的克隆——原型模式(一):大同小异的工作周报,原型模式概述

    对象的克隆——原型模式(二):工作周报的原型模式解决方案

    对象的克隆——原型模式(三):带附件的周报【浅克隆,深克隆】

    对象的克隆——原型模式(四):原型管理器的引入和实现,原型模式总结

     

    建造者模式-Builder Pattern

    复杂对象的组装与创建——建造者模式(一):游戏角色设计,建造者模式概述

    复杂对象的组装与创建——建造者模式(二):游戏角色设计的建造者模式解决方案

    复杂对象的组装与创建——建造者模式(三):关于Director的进一步讨论,建造者模式总结

     

    七个结构型模式

     

    适配器模式-Adapter Pattern

    不兼容结构的协调——适配器模式(一):没有源码的算法库,适配器模式概述

    不兼容结构的协调——适配器模式(二):没有源码的算法库的适配器模式解决方案

    不兼容结构的协调——适配器模式(三):类适配器,双向适配器

    不兼容结构的协调——适配器模式(四):缺省适配器,适配器模式总结


    桥接模式-Bridge Pattern

    处理多维度变化——桥接模式(一):跨平台图像浏览系统

    处理多维度变化——桥接模式(二):桥接模式概述

    处理多维度变化——桥接模式(三):跨平台图像浏览系统的桥接模式解决方案

    处理多维度变化——桥接模式(四):适配器模式与桥接模式的联用,桥接模式总结


    组合模式-Composite Pattern

    树形结构的处理——组合模式(一):设计杀毒软件的框架结构

    树形结构的处理——组合模式(二):组合模式概述

    树形结构的处理——组合模式(三):杀毒软件的框架结构的组合模式解决方案

    树形结构的处理——组合模式(四):透明组合模式与安全组合模式

    树形结构的处理——组合模式(五):公司组织结构,组合模式总结


    装饰模式-Decorator Pattern

    扩展系统功能——装饰模式(一):图形界面构件库的设计

    扩展系统功能——装饰模式(二):装饰模式概述

    扩展系统功能——装饰模式(三):图形界面构件库的装饰模式解决方案

    扩展系统功能——装饰模式(四):透明装饰模式与半透明装饰模式,装饰模式注意事项,装饰模式总结


    外观模式-Facade Pattern

    深入浅出外观模式(一):外观模式概述,外观模式结构与实现

    深入浅出外观模式(二):外观模式应用实例(文件加密模块)

    深入浅出外观模式(三):抽象外观类,外观模式效果与适用场景


    享元模式-Flyweight Pattern

    实现对象的复用——享元模式(一):围棋棋子的设计,享元模式概述(上)

    实现对象的复用——享元模式(二):享元模式概述(下)

    实现对象的复用——享元模式(三):围棋棋子的享元模式解决方案

    实现对象的复用——享元模式(四):带外部状态的围棋棋子解决方案

    实现对象的复用——享元模式(五):单纯享元模式和复合享元模式,关于享元模式的几点补充,享元模式总结


    代理模式-Proxy Pattern

    代理模式(一):代理模式概述,代理模式结构与实现

    代理模式(二):代理模式应用实例(收费商务信息查询系统)

    代理模式(三):远程代理,虚拟代理,缓冲代理

    代理模式(四):代理模式效果与适用场景


    十一个行为型模式

     

    职责链模式-Chain of Responsibility Pattern

    请求的链式处理——职责链模式(一):采购单的分级审批

    请求的链式处理——职责链模式(二):职责链模式概述

    请求的链式处理——职责链模式(三):采购单分级审批的职责链模式解决方案

    请求的链式处理——职责链模式(四):纯与不纯的职责链模式,职责链模式总结


    命令模式-Command Pattern

    请求发送者与接收者解耦——命令模式(一):自定义功能键,命令模式概述

    请求发送者与接收者解耦——命令模式(二):自定义功能键的命令模式解决方案

    请求发送者与接收者解耦——命令模式(三):命令队列的实现

    请求发送者与接收者解耦——命令模式(四):撤销操作的简单实现

    请求发送者与接收者解耦——命令模式(五):请求日志

    请求发送者与接收者解耦——命令模式(六):宏命令,命令模式总结


    解释器模式-Interpreter Pattern

    自定义语言的实现——解释器模式(一):机器人控制程序

    自定义语言的实现——解释器模式(二):文法规则和抽象语法树

    自定义语言的实现——解释器模式(三):解释器模式概述

    自定义语言的实现——解释器模式(四):机器人控制程序的解释器模式解决方案

    自定义语言的实现——解释器模式(五):再谈Context的作用

    自定义语言的实现——解释器模式(六):解释器模式总结


    迭代器模式-Iterator Pattern

    遍历聚合对象中的元素——迭代器模式(一):销售管理系统中数据的遍历

    遍历聚合对象中的元素——迭代器模式(二):迭代器模式概述

    遍历聚合对象中的元素——迭代器模式(三):销售管理系统中数据的遍历的迭代器模式解决方案

    遍历聚合对象中的元素——迭代器模式(四):使用内部类实现迭代器

    遍历聚合对象中的元素——迭代器模式(五):JDK内置迭代器的使用

    遍历聚合对象中的元素——迭代器模式(六):迭代器模式总结


    中介者模式-Mediator Pattern

    协调多个对象之间的交互——中介者模式(一):客户信息管理窗口的初始设计

    协调多个对象之间的交互——中介者模式(二):中介者模式概述

    协调多个对象之间的交互——中介者模式(三):客户信息管理窗口的中介者模式解决方案

    协调多个对象之间的交互——中介者模式(四):中介者与同事类的扩展

    协调多个对象之间的交互——中介者模式(五):中介者模式总结


    备忘录模式-Memento Pattern

    撤销功能的实现——备忘录模式(一):可悔棋的中国象棋

    撤销功能的实现——备忘录模式(二):备忘录模式概述

    撤销功能的实现——备忘录模式(三):中国象棋的备忘录模式解决方案

    撤销功能的实现——备忘录模式(四):实现多次撤销

    撤销功能的实现——备忘录模式(五):再谈备忘录的封装,备忘录模式总结


    观察者模式-Observer Pattern

    对象间的联动——观察者模式(一):多人联机对战游戏的设计

    对象间的联动——观察者模式(二):观察者模式概述

    对象间的联动——观察者模式(三):多人联机对战游戏的观察者模式解决方案

    对象间的联动——观察者模式(四):JDK对观察者模式的支持

    对象间的联动——观察者模式(五):观察者模式与Java事件处理

    对象间的联动——观察者模式(六):观察者模式与MVC,观察者模式总结


    状态模式-State Pattern

    处理对象的多种状态及其相互转换——状态模式(一):银行系统中的账户类设计

    处理对象的多种状态及其相互转换——状态模式(二):状态模式概述

    处理对象的多种状态及其相互转换——状态模式(三):账户类的状态模式解决方案

    处理对象的多种状态及其相互转换——状态模式(四):共享状态的实现

    处理对象的多种状态及其相互转换——状态模式(五):使用环境类实现状态转换

    处理对象的多种状态及其相互转换——状态模式(六):状态模式总结


    策略模式-Strategy Pattern

    算法的封装与切换——策略模式(一):电影票打折方案

    算法的封装与切换——策略模式(二):策略模式概述

    算法的封装与切换——策略模式(三):电影票打折方案的策略模式解决方案

    算法的封装与切换——策略模式(四):策略模式的两个典型应用,策略模式总结


    模板方法模式-Template Method Pattern

    模板方法模式深度解析(一):模板方法模式概述,模板方法模式结构与实现

    模板方法模式深度解析(二):模板方法模式应用实例(银行利息计算模块)

    模板方法模式深度解析(三):钩子方法的使用,模板方法模式效果与适用场景


    访问者模式-Visitor Pattern

    操作复杂对象结构——访问者模式(一):OA系统中员工数据汇总

    操作复杂对象结构——访问者模式(二):访问者模式概述

    操作复杂对象结构——访问者模式(三):OA系统中员工数据汇总的访问者模式解决方案

    操作复杂对象结构——访问者模式(四):访问者模式与组合模式联用,访问者模式总结


    设计模式趣味学习(复习)


    设计模式与足球(一):创建型模式

    设计模式与足球(二):结构型模式

    设计模式与足球(三):行为型模式(上)

    设计模式与足球(四):行为型模式(下)


    设计模式综合应用实例


    多人联机射击游戏

    多人联机射击游戏中的设计模式应用(一):抽象工厂模式,建造者模式,工厂方法模式,迭代器模式,命令模式

    多人联机射击游戏中的设计模式应用(二):观察者模式,单例模式,状态模式,适配器模式


    数据库同步系统

    设计模式综合实例分析之数据库同步系统(一):数据库同步系统概述,建造者模式,简单工厂模式

    设计模式综合实例分析之数据库同步系统(二):享元模式,单例模式,观察者模式,模板方法模式

    设计模式综合实例分析之数据库同步系统(三):策略模式,组合模式,命令模式,职责链模式


    友情提示:请尊重作者劳动成果,如需转载本博客文章请注明出处!谢谢合作!

    源博文出处:http://blog.csdn.net/lovelion/article/details/17517213

    展开全文
  • JAVA23种设计模式详解

    2013-07-24 21:33:02
    JAVA 23种设计模式 详解 word格式
  • Java23种设计模式详解

    2014-08-29 23:04:51
    Java23种设计模式详解
  • 23种常见设计模式详解

    千次阅读 多人点赞 2021-12-03 22:05:12
    23中常见设计模式详解

    设计模式


    推荐一个学习设计模式的网站:https://refactoring.guru/design-patterns

    参考视频:https://www.bilibili.com/video/BV1Np4y1z7BU

    一、设计模式概述

    1.1、设计模式的产生背景

    ”设计模式“是谁发明的?

    设计模式的概念最早由 克里斯托弗·亚历山大(Christopher Alexander) 在 《建筑模式语言:城镇、建筑、构造》描述。这本书描述了一种设计城市环境的“语言”。这种语言的单位是模式。他们可能会描述窗户应该有多高、建筑物应该有多少层、社区应该有多大的绿地等等。

    这个想法被四位作者采纳:Erich Gamma、John Vlissides、Ralph Johnson 和 Richard Helm (Gang of Four,四人帮)。1994 年,他们出版了《设计模式:可服用面向对象软件的基础》,此书收录了23种设计模式。这是设计模式领域里程碑的事件,导致了软件设计模式的突破,人人称[GoF设计模式]

    在这里插入图片描述

    1.2、什么是设计模式?

    **设计模式(Design Pattern)**是软件设计中常见问题的典型解决方案。它们就像预制的蓝图,您可以对其进行自定义以解决代码中反复出现的设计问题。(设计模式是前辈们对代码开发经验的总结,是解决特定问题的一系列套路。它不是语法规定,而是一套用来提高代码可复用性、可维护性、可读行、稳健性以及安全性的解决方案。)

    您不能像使用现成的函数或库那样,仅仅找到一个模式并将其复制到您的程序中。模式不是一段特定的代码,而是用于解决特定问题的一般概念。您可以遵循模式细节并实施适合您自己程序实际情况的解决方案。

    模式经常与算法混淆,因为这两个概念都描述了一些已知问题的典型解决方案。虽然算法总是定义一组可以实现某个目标的明确动作,但模式是对解决方案的更高级的描述。相同模式应用于两个不同程序的代码可能不同。

    算法的类比是烹饪食谱:两者都有实现目标的明确步骤。另一方面,模式更像是一个蓝图:您可以看到结果及其特征,但具体的实现顺序取决于您。

    1.3、学习设计模式的意义

    我为什么要学习模式?

    事实是,您可能会在不了解单一模式的情况下从事多年的程序员工作。很多人就是这样做的。但是,即使在这种情况下,您也可能在不知情的情况下实现了一些模式。那么你为什么要花时间学习它们呢?

    设计模式的本质是面向对象设计原则的实际运用,是对类的封装性、继承性和多态性以及类的关联关系和组合关系的充分理解。

    正确使用设计模式具有以下优点:

    • 可以提高程序员的思维能力、编程能力和设计能力。
    • 使程序设计更加标准化、代码编制更加工程化,使软件开发效率大大提高,从而缩短软件的开发周期。
    • 使设计的代码可重用性高、可读性强、可靠性高、灵活性好、可维护性强。

    1.4、设计模式的分类

    创建型模式:

    这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式,而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

    • 单例模式(Singleton Pattern)
    • 工厂模式(Factory Pattern)
    • 抽象工厂模式(Abstract Factory Pattern)
    • 建造者模式(Builder Pattern)
    • 原型模式(Prototype Pattern)

    结构型模式:

    这些模式解释了如何将对象和类组装成更大的结构,同时保持这些结构的灵活性和效率。

    • 适配器模式(Adapter Pattern)
    • 桥接模式(Bridge Pattern)
    • 组合模式(Composite Pattern)
    • 装饰器模式(Decorator Pattern)
    • 外观模式(Facade Pattern)
    • 享元模式(Flyweight Pattern)
    • 代理模式(Proxy Pattern)

    行为型模式:

    这些设计模式特别关注对象之间的通信。

    • 责任链模式(Chain of Responsibility Pattern)
    • 命令模式(Command Pattern)
    • 解释器模式(Interpreter Pattern)
    • 迭代器模式(Iterator Pattern)
    • 中介者模式(Mediator Pattern)
    • 备忘录模式(Memento Pattern)
    • 观察者模式(Observer Pattern)
    • 状态模式(State Pattern)
    • 策略模式(Strategy Pattern)
    • 模板模式(Template Pattern)
    • 访问者模式(Visitor Pattern)

    下面用一个图片来整体描述一下设计模式之间的关系:

    设计模式之间的关系

    1.5、设计模式的七大原则

    1、开闭原则(Open Close Principle)

    开闭原则的意思是:对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。简言之,是为了使程序的扩展性好,易于维护和升级。想要达到这样的效果,我们需要使用接口和抽象类,后面的具体设计中我们会提到这点。

    2、单一职责原则(Single Responsibility Principle)

    一个类只负责一个功能领域中的相应职责,或者可以定义为:就一个类而言,应该只有一个引起它变化的原因。

    控制类的粒度大小、将对象解耦、提高其内聚性。

    3、里氏代换原则(Liskov Substitution Principle)

    里氏代换原则是面向对象设计的基本原则之一。 里氏代换原则中说,任何基类可以出现的地方,子类一定可以出现。LSP 是继承复用的基石,只有当派生类可以替换掉基类,且软件单位的功能不受到影响时,基类才能真正被复用,而派生类也能够在基类的基础上增加新的行为。里氏代换原则是对开闭原则的补充。实现开闭原则的关键步骤就是抽象化,而基类与子类的继承关系就是抽象化的具体实现,所以里氏代换原则是对实现抽象化的具体步骤的规范。(继承必须确保超类所拥有的性质在子类中仍然成立

    4、依赖倒转原则(Dependence Inversion Principle)

    这个原则是开闭原则的基础,具体内容:面向接口编程,依赖于抽象而不依赖于具体(不要面向实现编程)。

    5、接口隔离原则(Interface Segregation Principle)

    这个原则的意思是:使用多个隔离的接口,比使用单个接口要好。(要为各个类建立他们需要的专用接口)它还有另外一个意思是:降低类之间的耦合度。由此可见,其实设计模式就是从大型软件架构出发、便于升级和维护的软件设计思想,它强调降低依赖,降低耦合。

    6、迪米特法则,又称最少知道原则(Demeter Principle)

    最少知道原则是指:一个实体应当尽量少地与其他实体之间发生相互作用,使得系统功能模块相对独立。

    7、合成复用原则(Composite Reuse Principle)

    合成复用原则是指:尽量先使用合成/聚合的方式,其次才考虑使用继承。

    二、UML

    统一建模语言(Unified Modeling Language,UML)是用来设计软件的可视化建模语言。它的特点是简单、统一、图形化、能表达软件设计中的动态与静态信息。

    UML 从目标系统的不同角度出发,定义了用例图、类图、对象图、状态图、活动图、时序图、协作图、构件图、部署图等 9 种图。

    2.1、类图概述

    类图(Class diagram)是显示了模型的静态结构,特别是模型中存在的类、类的内部结构以及它们与其他类的关系等。类图不显示暂时性的信息。类图是面向对象建模的主要组成部分。

    2.2、类图的作用

    • 在软件工程中,类图是一种静态的结构图,描述了系统的类的集合,类的属性和类之间的关系,可以简化了人们对系统的理解;
    • 类图是系统分析和设计阶段的重要产物,是系统编码和测试的重要模型。

    2.3、类图表示法

    2.3.1、类的表示方式

    在UML类图中,类使用包含类名、属性(field) 和方法(method) 且带有分割线的矩形来表示,比如下图表示一个Employee类,它包含name,age和address这3个属性,以及work()方法。

    在这里插入图片描述

    属性/方法名称前加的加号和减号表示了这个属性/方法的可见性,UML类图中表示可见性的符号有三种:

    • +:表示public

    • -:表示private

    • #:表示protected

    属性的完整表示方式是: 可见性 名称 :类型 [ = 缺省值]

    方法的完整表示方式是: 可见性 名称(参数列表) [ : 返回类型]

    注意:

    ​ 1,中括号中的内容表示是可选的

    ​ 2,也有将类型放在变量名前面,返回值类型放在方法名前面

    举个栗子:

    在这里插入图片描述

    上图Demo类定义了三个方法:

    • method()方法:修饰符为public,没有参数,没有返回值。
    • method1()方法:修饰符为private,没有参数,返回值类型为String。
    • method2()方法:修饰符为protected,接收两个参数,第一个参数类型为int,第二个参数类型为String,返回值类型是int。

    2.3.2、类与类之间关系的表示方式

    2.3.2.1、关联关系

    关联关系是对象之间的一种引用关系,用于表示一类对象与另一类对象之间的联系,如老师和学生、师傅和徒弟、丈夫和妻子等。关联关系是类与类之间最常用的一种关系,分为一般关联关系、聚合关系和组合关系。我们先介绍一般关联。

    关联又可以分为单向关联,双向关联,自关联。

    1,单向关联

    在这里插入图片描述

    在UML类图中单向关联用一个带箭头的实线表示。上图表示每个顾客都有一个地址,这通过让Customer类持有一个类型为Address的成员变量类实现。

    2,双向关联

    在这里插入图片描述

    从上图中我们很容易看出,所谓的双向关联就是双方各自持有对方类型的成员变量。

    在UML类图中,双向关联用一个不带箭头的直线表示。上图中在Customer类中维护一个List<Product>,表示一个顾客可以购买多个商品;在Product类中维护一个Customer类型的成员变量表示这个产品被哪个顾客所购买。

    3,自关联

    在这里插入图片描述

    自关联在UML类图中用一个带有箭头且指向自身的线表示。上图的意思就是Node类包含类型为Node的成员变量,也就是“自己包含自己”。

    2.3.2.2、聚合关系

    聚合关系是关联关系的一种,是强关联关系,是整体和部分之间的关系。

    聚合关系也是通过成员对象来实现的,其中成员对象是整体对象的一部分,但是成员对象可以脱离整体对象而独立存在。例如,学校与老师的关系,学校包含老师,但如果学校停办了,老师依然存在。

    在 UML 类图中,聚合关系可以用带空心菱形的实线来表示,菱形指向整体。下图所示是大学和教师的关系图:

    在这里插入图片描述

    2.3.2.3、组合关系

    组合表示类之间的整体与部分的关系,但它是一种更强烈的聚合关系。

    在组合关系中,整体对象可以控制部分对象的生命周期,一旦整体对象不存在,部分对象也将不存在,部分对象不能脱离整体对象而存在。例如,头和嘴的关系,没有了头,嘴也就不存在了。

    在 UML 类图中,组合关系用带实心菱形的实线来表示,菱形指向整体。下图所示是头和嘴的关系图:

    在这里插入图片描述

    2.3.2.4、依赖关系

    依赖关系是一种使用关系,它是对象之间耦合度最弱的一种关联方式,是临时性的关联。在代码中,某个类的方法通过局部变量、方法的参数或者对静态方法的调用来访问另一个类(被依赖类)中的某些方法来完成一些职责。

    在 UML 类图中,依赖关系使用带箭头的虚线来表示,箭头从使用类指向被依赖的类。下图所示是司机和汽车的关系图,司机驾驶汽车:

    在这里插入图片描述

    2.3.2.5、继承关系

    继承关系是对象之间耦合度最大的一种关系,表示一般与特殊的关系,是父类与子类之间的关系,是一种继承关系。

    在 UML 类图中,泛化关系用带空心三角箭头的实线来表示,箭头从子类指向父类。在代码实现时,使用面向对象的继承机制来实现泛化关系。例如,Student 类和 Teacher 类都是 Person 类的子类,其类图如下图所示:

    在这里插入图片描述

    2.3.2.6、实现关系

    实现关系是接口与实现类之间的关系。在这种关系中,类实现了接口,类中的操作实现了接口中所声明的所有的抽象操作。

    在 UML 类图中,实现关系使用带空心三角箭头的虚线来表示,箭头从实现类指向接口。例如,汽车和船实现了交通工具,其类图如图 9 所示。

    在这里插入图片描述

    三、软件设计原则

    在软件开发中,为了提高软件系统的可维护性和可复用性,增加软件的可扩展性和灵活性,程序员要尽量根据6条原则来开发程序,从而提高软件开发效率、节约软件开发成本和维护成本。

    3.1、开闭原则

    对扩展开放,对修改关闭。在程序需要进行拓展的时候,不能去修改原有的代码,实现一个热插拔的效果。简言之,是为了使程序的扩展性好,易于维护和升级。

    想要达到这样的效果,我们需要使用接口和抽象类。

    因为抽象灵活性好,适应性广,只要抽象的合理,可以基本保持软件架构的稳定。而软件中易变的细节可以从抽象派生来的实现类来进行扩展,当软件需要发生变化时,只需要根据需求重新派生一个实现类来扩展就可以了。

    下面以 搜狗输入法 的皮肤为例介绍开闭原则的应用。

    【例】搜狗输入法 的皮肤设计。

    分析:搜狗输入法 的皮肤是输入法背景图片、窗口颜色和声音等元素的组合。用户可以根据自己的喜爱更换自己的输入法的皮肤,也可以从网上下载新的皮肤。这些皮肤有共同的特点,可以为其定义一个抽象类(AbstractSkin),而每个具体的皮肤(DefaultSpecificSkin和HeimaSpecificSkin)是其子类。用户窗体可以根据需要选择或者增加新的主题,而不需要修改原代码,所以它是满足开闭原则的。

    在这里插入图片描述

    代码实现:

    // 抽象皮肤类
    public abstract class AbstractSkin {
    	public abstract void display();
    }
    
    // 默认皮肤类
    public class DefaultSkin extends AbstractSkin {
    	@Override
    	public void display() {
    		System.out.println("默认皮肤");
    	}
    }
    
    // 自定义皮肤
    public class HeiSkin extends AbstractSkin {
    	@Override
    	public void display() {
    		System.out.println("自定义皮肤");
    	}
    }
    
    // 搜狗输入法
    public class SougouInput {
    	private AbstractSkin skin;
    
    	public void setSkin(AbstractSkin skin) {
    		this.skin = skin;
    	}
    
    	public void display() {
    		skin.display();
    	}
    }
    
    public class Client {
    	public static void main(String[] args) {
    		// 1. 创建搜狗输入法对象
    		SougouInput sougouInput = new SougouInput();
    		// 2. 创建皮肤对象
    		// DefaultSkin skin = new DefaultSkin();
    		HeiSkin skin = new HeiSkin();
    		// 3. 将皮肤设置到输入法中
    		sougouInput.setSkin(skin);
    
    		// 4. 显示皮肤
    		sougouInput.display();
    	}
    }
    

    在这里插入图片描述

    3.2、单一职责原则

    一个类只负责一个功能领域中的相应职责,或者可以定义为:就一个类而言,应该只有一个引起它变化的原因。

    控制类的粒度大小、将对象解耦、提高其内聚性。

    3.3、里氏代换原则

    里氏代换原则是面向对象设计的基本原则之一。

    里氏代换原则:任何基类可以出现的地方,子类一定可以出现。通俗理解:子类可以扩展父类的功能,但不能改变父类原有的功能。换句话说,子类继承父类时,除添加新的方法完成新增功能外,尽量不要重写父类的方法。

    如果通过重写父类的方法来完成新的功能,这样写起来虽然简单,但是整个继承体系的可复用性会比较差,特别是运用多态比较频繁时,程序运行出错的概率会非常大。

    下面看一个里氏替换原则中经典的一个例子

    【例】正方形不是长方形。

    在数学领域里,正方形毫无疑问是长方形,它是一个长宽相等的长方形。所以,我们开发的一个与几何图形相关的软件系统,就可以顺理成章的让正方形继承自长方形。

    在这里插入图片描述

    代码如下:

    长方形类(Rectangle):

    public class Rectangle {
    
    	private double length;
    	private double width;
    
    	public double getLength() {
    		return length;
    	}
    
    	public void setLength(double length) {
    		this.length = length;
    	}
    
    	public double getWidth() {
    		return width;
    	}
    
    	public void setWidth(double width) {
    		this.width = width;
    	}
    }
    

    正方形(Square):

    由于正方形的长和宽相同,所以在方法setLength和setWidth中,对长度和宽度都需要赋相同值。

    public class Square extends Rectangle {
    
        @Override
        public void setLength(double length) {
            super.setLength(length);
            super.setWidth(length);
        }
    
        @Override
        public void setWidth(double width) {
            super.setWidth(width);
            super.setLength(width);
        }
    }
    

    类RectangleDemo是我们的软件系统中的一个组件,它有一个resize方法依赖基类Rectangle,resize方法是RectandleDemo类中的一个方法,用来实现宽度逐渐增长的效果。

    public class RectangleDemo {
    	public static void main(String[] args) {
    		// 创建长方形
    		Rectangle rectangle = new Rectangle();
    
    		rectangle.setLength(20);
    		rectangle.setWidth(10);
    
    		resize(rectangle);
    		printLengthAndWidth(rectangle);
    
    		System.out.println("=============");
            
    		// 创建正方形
    		Square square = new Square();
    		square.setLength(10);
    		resize(square);
    		printLengthAndWidth(square);
    	}
    
    	// 扩宽方法
    	public static void resize(Rectangle rectangle) {
    		// 判断宽如果比长小,进行扩宽的操作
    		if (rectangle.getWidth() <= rectangle.getLength()) {
    			rectangle.setWidth(rectangle.getLength() + 1);
    		}
    	}
    
    	// 打印长和宽
    	public static void printLengthAndWidth(Rectangle rectangle) {
    		System.out.println(rectangle.getLength());
    		System.out.println(rectangle.getWidth());
    	}
    }
    

    我们运行一下这段代码就会发现,假如我们把一个普通长方形作为参数传入resize方法,就会看到长方形宽度逐渐增长的效果,当宽度大于长度,代码就会停止,这种行为的结果符合我们的预期;假如我们再把一个正方形作为参数传入resize方法后,就会看到正方形的宽度和长度都在不断增长,代码会一直运行下去,直至系统产生溢出错误。所以,普通的长方形是适合这段代码的,正方形不适合。

    我们得出结论:在resize方法中,Rectangle类型的参数是不能被Square类型的参数所代替,如果进行了替换就得不到预期结果。因此,Square类和Rectangle类之间的继承关系违反了里氏代换原则,它们之间的继承关系不成立,正方形不是长方形。

    如何改进呢?此时我们需要重新设计他们之间的关系。抽象出来一个四边形接口(Quadrilateral),让Rectangle类和Square类实现Quadrilateral接口

    在这里插入图片描述

    public interface Quadrilateral {
    
       double getLength();
    
       double getWidth();
    }
    
    public class Square implements Quadrilateral {
    
       private double side;
    
       public double getSide() {
          return side;
       }
    
       public void setSide(double side) {
          this.side = side;
       }
    
       @Override
       public double getLength() {
          return side;
       }
    
       @Override
       public double getWidth() {
          return side;
       }
    }
    
    public class Rectangle implements Quadrilateral {
    
       private double length;
       private double width;
    
       public void setLength(double length) {
          this.length = length;
       }
    
       public void setWidth(double width) {
          this.width = width;
       }
    
       @Override
       public double getLength() {
          return length;
       }
    
       @Override
       public double getWidth() {
          return width;
       }
    }
    
    public class RectangleDemo {
       public static void main(String[] args) {
          // 创建长方形
          Rectangle rectangle = new Rectangle();
          rectangle.setLength(20);
          rectangle.setWidth(10);
          resize(rectangle);
          printLengthAndWidth(rectangle);
       }
    
       // 扩宽方法
       public static void resize(Rectangle rectangle) {
          // 判断宽如果比长小,进行扩宽的操作
          if (rectangle.getWidth() <= rectangle.getLength()) {
             rectangle.setWidth(rectangle.getLength() + 1);
          }
       }
    
       // 打印长和宽
       public static void printLengthAndWidth(Quadrilateral quadrilateral) {
          System.out.println(quadrilateral.getLength());
          System.out.println(quadrilateral.getWidth());
       }
    }
    

    3.4、依赖倒转原则

    高层模块不应该依赖低层模块,两者都应该依赖其抽象;抽象不应该依赖细节,细节应该依赖抽象。简单的说就是要求对抽象进行编程,不要对实现进行编程,这样就降低了客户与实现模块间的耦合。

    下面看一个例子来理解依赖倒转原则

    【例】组装电脑

    现要组装一台电脑,需要配件cpu,硬盘,内存条。只有这些配置都有了,计算机才能正常的运行。选择cpu有很多选择,如Intel,AMD等,硬盘可以选择希捷,西数等,内存条可以选择金士顿,海盗船等。

    类图如下:

    在这里插入图片描述

    代码如下:

    希捷硬盘类(XiJieHardDisk):

    public class XiJieHardDisk implements HardDisk {
    
        public void save(String data) {
            System.out.println("使用希捷硬盘存储数据" + data);
        }
    
        public String get() {
            System.out.println("使用希捷希捷硬盘取数据");
            return "数据";
        }
    }
    

    Intel处理器(IntelCpu):

    public class IntelCpu implements Cpu {
    
        public void run() {
            System.out.println("使用Intel处理器");
        }
    }
    

    金士顿内存条(KingstonMemory):

    public class KingstonMemory implements Memory {
    
        public void save() {
            System.out.println("使用金士顿作为内存条");
        }
    }
    

    电脑(Computer):

    public class Computer {
    
        private XiJieHardDisk hardDisk;
        private IntelCpu cpu;
        private KingstonMemory memory;
    
        public IntelCpu getCpu() {
            return cpu;
        }
    
        public void setCpu(IntelCpu cpu) {
            this.cpu = cpu;
        }
    
        public KingstonMemory getMemory() {
            return memory;
        }
    
        public void setMemory(KingstonMemory memory) {
            this.memory = memory;
        }
    
        public XiJieHardDisk getHardDisk() {
            return hardDisk;
        }
    
        public void setHardDisk(XiJieHardDisk hardDisk) {
            this.hardDisk = hardDisk;
        }
    
        public void run() {
            System.out.println("计算机工作");
            cpu.run();
            memory.save();
            String data = hardDisk.get();
            System.out.println("从硬盘中获取的数据为:" + data);
        }
    }
    

    测试类(TestComputer):

    测试类用来组装电脑。

    public class TestComputer {
        public static void main(String[] args) {
            Computer computer = new Computer();
            computer.setHardDisk(new XiJieHardDisk());
            computer.setCpu(new IntelCpu());
            computer.setMemory(new KingstonMemory());
    
            computer.run();
        }
    }
    

    上面代码可以看到已经组装了一台电脑,但是似乎组装的电脑的cpu只能是Intel的,内存条只能是金士顿的,硬盘只能是希捷的,这对用户肯定是不友好的,用户有了机箱肯定是想按照自己的喜好,选择自己喜欢的配件。

    根据依赖倒转原则进行改进:

    代码我们只需要修改Computer类,让Computer类依赖抽象(各个配件的接口),而不是依赖于各个组件具体的实现类。

    类图如下:

    在这里插入图片描述

    电脑(Computer):

    public class Computer {
    
        private HardDisk hardDisk;
        private Cpu cpu;
        private Memory memory;
    
        public HardDisk getHardDisk() {
            return hardDisk;
        }
    
        public void setHardDisk(HardDisk hardDisk) {
            this.hardDisk = hardDisk;
        }
    
        public Cpu getCpu() {
            return cpu;
        }
    
        public void setCpu(Cpu cpu) {
            this.cpu = cpu;
        }
    
        public Memory getMemory() {
            return memory;
        }
    
        public void setMemory(Memory memory) {
            this.memory = memory;
        }
    
        public void run() {
            System.out.println("计算机工作");
        }
    }
    

    面向对象的开发很好的解决了这个问题,一般情况下抽象的变化概率很小,让用户程序依赖于抽象, 实现的细节也依赖于抽象。即使实现细节不断变动,只要抽象不变,客户程序就不需要变化。这大大降低了客户程序与实现细节的耦合度。

    3.5、接口隔离原则

    客户端不应该被迫依赖于它不使用的方法;一个类对另一个类的依赖应该建立在最小的接口上。

    下面看一个例子来理解接口隔离原则

    【例】安全门案例

    我们需要创建一个黑马 品牌的安全门,该安全门具有防火、防水、防盗的功能。可以将防火,防水,防盗功能提取成一个接口,形成一套规范。类图如下:

    在这里插入图片描述

    public interface SafetyDoor {
    
       // 防盗
       void antiTheft();
    
       // 防火
       void fireProof();
    
       // 防水
       void waterProof();
    }
    
    public class HeimaSafetyDoor implements SafetyDoor {
       @Override
       public void antiTheft() {
          System.out.println("防盗");
       }
    
       @Override
       public void fireProof() {
          System.out.println("防火");
       }
    
       @Override
       public void waterProof() {
          System.out.println("防水");
       }
    }
    
    public class Client {
       public static void main(String[] args) {
          HeimaSafetyDoor door = new HeimaSafetyDoor();
          door.antiTheft();
          door.fireProof();
          door.waterProof();
       }
    }
    

    上面的设计我们发现了它存在的问题,黑马品牌的安全门具有防盗,防水,防火的功能。现在如果我们还需要再创建一个传智品牌的安全门,而该安全门只具有防盗、防水功能呢?很显然如果实现SafetyDoor接口就违背了接口隔离原则,那么我们如何进行修改呢?看如下类图:

    在这里插入图片描述

    代码如下:

    AntiTheft(接口):

    public interface AntiTheft {
        void antiTheft();
    }
    

    Fireproof(接口):

    public interface Fireproof {
        void fireproof();
    }
    

    Waterproof(接口):

    public interface Waterproof {
        void waterproof();
    }
    

    HeiMaSafetyDoor(类):

    public class HeiMaSafetyDoor implements AntiTheft,Fireproof,Waterproof {
        public void antiTheft() {
            System.out.println("防盗");
        }
    
        public void fireproof() {
            System.out.println("防火");
        }
    
        public void waterproof() {
            System.out.println("防水");
        }
    }
    

    ItcastSafetyDoor(类):

    public class ItcastSafetyDoor implements AntiTheft,Fireproof {
        public void antiTheft() {
            System.out.println("防盗");
        }
    
        public void fireproof() {
            System.out.println("防火");
        }
    }
    

    3.6、迪米特法则

    迪米特法则又叫最少知识原则。

    只和你的直接朋友交谈,不跟“陌生人”说话(Talk only to your immediate friends and not to strangers)。

    其含义是:如果两个软件实体无须直接通信,那么就不应当发生直接的相互调用,可以通过第三方转发该调用。其目的是降低类之间的耦合度,提高模块的相对独立性。

    迪米特法则中的“朋友”是指:当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等,这些对象同当前对象存在关联、聚合或组合关系,可以直接访问这些对象的方法。

    下面看一个例子来理解迪米特法则

    【例】明星与经纪人的关系实例

    明星由于全身心投入艺术,所以许多日常事务由经纪人负责处理,如和粉丝的见面会,和媒体公司的业务洽淡等。这里的经纪人是明星的朋友,而粉丝和媒体公司是陌生人,所以适合使用迪米特法则。

    类图如下:

    在这里插入图片描述

    代码如下:

    明星类(Star)

    public class Star {
        private String name;
    
        public Star(String name) {
            this.name=name;
        }
    
        public String getName() {
            return name;
        }
    }
    

    粉丝类(Fans)

    public class Fans {
        private String name;
    
        public Fans(String name) {
            this.name=name;
        }
    
        public String getName() {
            return name;
        }
    }
    

    媒体公司类(Company)

    public class Company {
        private String name;
    
        public Company(String name) {
            this.name=name;
        }
    
        public String getName() {
            return name;
        }
    }
    

    经纪人类(Agent)

    public class Agent {
        private Star star;
        private Fans fans;
        private Company company;
    
        public void setStar(Star star) {
            this.star = star;
        }
    
        public void setFans(Fans fans) {
            this.fans = fans;
        }
    
        public void setCompany(Company company) {
            this.company = company;
        }
    
        public void meeting() {
            System.out.println(fans.getName() + "与明星" + star.getName() + "见面了。");
        }
    
        public void business() {
            System.out.println(company.getName() + "与明星" + star.getName() + "洽淡业务。");
        }
    }
    
    public class Client {
       public static void main(String[] args) {
          Agent agent = new Agent();
    
          Star star = new Star("林青霞");
          agent.setStar(star);
    
          Fans fans = new Fans("李四");
          agent.setFans(fans);
    
          Company company = new Company("黑马公司");
          agent.setCompany(company);
    
          agent.meeting();
          agent.business();
       }
    }
    

    3.7、合成复用原则

    合成复用原则是指:尽量先使用组合或者聚合等关联关系来实现,其次才考虑使用继承关系来实现。

    通常类的复用分为继承复用和合成复用两种。

    继承复用虽然有简单和易实现的优点,但它也存在以下缺点:

    1. 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类,父类对子类是透明的,所以这种复用又称为“白箱”复用。
    2. 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化,这不利于类的扩展与维护。
    3. 它限制了复用的灵活性。从父类继承而来的实现是静态的,在编译时已经定义,所以在运行时不可能发生变化。

    采用组合或聚合复用时,可以将已有对象纳入新对象中,使之成为新对象的一部分,新对象可以调用已有对象的功能,它有以下优点:

    1. 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的,所以这种复用又称为“黑箱”复用。
    2. 对象间的耦合度低。可以在类的成员位置声明抽象。
    3. 复用的灵活性高。这种复用可以在运行时动态进行,新对象可以动态地引用与成分对象类型相同的对象。

    下面看一个例子来理解合成复用原则

    【例】汽车分类管理程序

    汽车按“动力源”划分可分为汽油汽车、电动汽车等;按“颜色”划分可分为白色汽车、黑色汽车和红色汽车等。如果同时考虑这两种分类,其组合就很多。类图如下:

    在这里插入图片描述

    从上面类图我们可以看到使用继承复用产生了很多子类,如果现在又有新的动力源或者新的颜色的话,就需要再定义新的类。我们试着将继承复用改为聚合复用看一下。

    在这里插入图片描述

    四、创建者模式

    创建型模式的主要关注点是“怎样创建对象?”,它的主要特点是“将对象的创建与使用分离”。

    这样可以降低系统的耦合度,使用者不需要关注对象的创建细节。

    创建型模式分为:

    • 单例模式
    • 工厂方法模式
    • 抽象工程模式
    • 原型模式
    • 建造者模式

    4.1、单例模式

    单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

    这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。

    4.1.1、单例模式的结构

    单例模式的主要有以下角色:

    • 单例类。只能创建一个实例的类
    • 访问类。使用单例类

    在这里插入图片描述

    4.1.2、单例模式的实现

    单例设计模式分类两种:

    ​ 饿汉式:类加载就会导致该单实例对象被创建

    ​ 懒汉式:类加载不会导致该单实例对象被创建,而是首次使用该对象时才会创建

    1. 饿汉式-方式1(静态变量方式)

      /**
       * 饿汉式
       *      静态变量创建类的对象
       */
      public class Hungry {
      
      	//私有构造方法
      	public Hungry() {
      	}
      
      	//在成员位置创建该类的对象
      	private final static Hungry HUNGRY = new Hungry();
      
      	//对外提供静态方法获取该对象
      	public static Hungry getInstance() {
      		return HUNGRY;
      	}
      }
      

      说明:

      ​ 该方式在成员位置声明Hungry类型的静态变量,并创建Hungry类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话,而一直没有使用就会造成内存的浪费。

    2. 饿汉式-方式2(静态代码块方式)

      /**
       * 恶汉式
       *      在静态代码块中创建该类对象
       */
      public class Hungry {
      
          //私有构造方法
          private Hungry() {}
      
          //在成员位置创建该类的对象
          private static Hungry instance;
      
          static {
              instance = new Hungry();
          }
      
          //对外提供静态方法获取该对象
          public static Hungry getInstance() {
              return instance;
          }
      }
      

      说明:

      ​ 该方式在成员位置声明Hungry类型的静态变量,而对象的创建是在静态代码块中,也是对着类的加载而创建。所以和饿汉式的方式1基本上一样,当然该方式也存在内存浪费问题。

    3. 懒汉式-方式1(线程不安全)

      /**
       * 懒汉式
       *  线程不安全
       */
      public class Singleton {
          //私有构造方法
          private Singleton() {}
      
          //在成员位置创建该类的对象
          private static Singleton instance;
      
          //对外提供静态方法获取该对象
          public static Singleton getInstance() {
      
              if(instance == null) {
                  instance = new Singleton();
              }
              return instance;
          }
      }
      

      说明:

      ​ 从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量,并没有进行对象的赋值操作,那么什么时候赋值的呢?当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象,这样就实现了懒加载的效果。但是,如果是多线程环境,会出现线程安全问题。

    4. 懒汉式-方式2(线程安全)

      /**
       * 懒汉式
       *  线程安全
       */
      public class Singleton {
          //私有构造方法
          private Singleton() {}
      
          //在成员位置创建该类的对象
          private static Singleton instance;
      
          //对外提供静态方法获取该对象
          public static synchronized Singleton getInstance() {
              if(instance == null) {
                  instance = new Singleton();
              }
              return instance;
          }
      }
      

      说明:

      ​ 该方式也实现了懒加载效果,同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字,导致该方法的执行效果特别低。从上面代码我们可以看出,其实就是在初始化instance的时候才会出现线程安全问题,一旦初始化完成就不存在了。

    5. 懒汉式-方式3(双重检查锁)

      再来讨论一下懒汉模式中加锁的问题,对于 getInstance() 方法来说,绝大部分的操作都是读操作,读操作是线程安全的,所以我们没必让每个线程必须持有锁才能调用该方法,我们需要调整加锁的时机。由此也产 生了一种新的实现模式:双重检查锁模式

      /**
       * 双重检查方式
       */
      public class Singleton { 
      
          //私有构造方法
          private Singleton() {}
      
          private static Singleton instance;
      
         //对外提供静态方法获取该对象
          public static Singleton getInstance() {
      		//第一次判断,如果instance不为null,不进入抢锁阶段,直接返回实例
              if(instance == null) {
                  synchronized (Singleton.class) {
                      //抢到锁之后再次判断是否为null
                      if(instance == null) {
                          instance = new Singleton();
                      }
                  }
              }
              return instance;
          }
      }
      

      双重检查锁模式是一种非常好的单例实现模式,解决了单例、性能、线程安全问题,上面的双重检测锁模式看上去完美无缺,其实是存在问题,在多线程的情况下,可能会出现空指针问题,出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

      要解决双重检查锁模式带来空指针异常的问题,只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

      /**
       * 双重检查方式
       */
      public class Singleton {
      
          //私有构造方法
          private Singleton() {}
      
          private static volatile Singleton instance;
      
         //对外提供静态方法获取该对象
          public static Singleton getInstance() {
      		//第一次判断,如果instance不为null,不进入抢锁阶段,直接返回实际
              if(instance == null) {
                  synchronized (Singleton.class) {
                      //抢到锁之后再次判断是否为空
                      if(instance == null) {
                          instance = new Singleton();
                      }
                  }
              }
              return instance;
          }
      }
      

      小结:

      添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式,能够保证在多线程的情况下线程安全也不会有性能问题。

    6. 懒汉式-方式4(静态内部类方式)

      静态内部类单例模式中实例由内部类创建,由于 JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。静态属性由于被 static 修饰,保证只被实例化一次,并且严格保证实例化顺序。

      /**
       * 静态内部类方式
       */
      public class Singleton {
      
          //私有构造方法
          private Singleton() {}
      
          private static class SingletonHolder {
              private static final Singleton INSTANCE = new Singleton();
          }
      
          //对外提供静态方法获取该对象
          public static Singleton getInstance() {
              return SingletonHolder.INSTANCE;
          }
      }
      

      说明:

      ​ 第一次加载Singleton类时不会去初始化INSTANCE,只有第一次调用getInstance,虚拟机加载SingletonHolder

      并初始化INSTANCE,这样不仅能确保线程安全,也能保证 Singleton 类的唯一性。

      小结:

      ​ 静态内部类单例模式是一种优秀的单例模式,是开源项目中比较常用的一种单例模式。在没有加任何锁的情况下,保证了多线程下的安全,并且没有任何性能影响和空间的浪费。

    7. 枚举方式

      枚举类实现单例模式是极力推荐的单例实现模式,因为枚举类型是线程安全的,并且只会装载一次,设计者充分的利用了枚举的这个特性来实现单例模式,枚举的写法非常简单,而且枚举类型是所用单例实现中唯一一种不会被破坏的单例实现模式。

      /**
       * 枚举方式
       */
      public enum Singleton {
          INSTANCE;
      }
      

      说明:

      ​ 枚举方式属于恶汉式方式。

    4.1.3、存在的问题

    4.1.3.1、问题演示

    破坏单例模式:

    使上面定义的单例类(Singleton)可以创建多个对象,枚举方式除外。有两种方式,分别是序列化和反射。

    • 序列化反序列化

      Singleton类:

      public class Singleton implements Serializable {
      
          //私有构造方法
          private Singleton() {}
      
          private static class SingletonHolder {
              private static final Singleton INSTANCE = new Singleton();
          }
      
          //对外提供静态方法获取该对象
          public static Singleton getInstance() {
              return SingletonHolder.INSTANCE;
          }
      }
      

      Test类:

      public class Test {
          public static void main(String[] args) throws Exception {
              //往文件中写对象
              //writeObject2File();
              //从文件中读取对象
              Singleton s1 = readObjectFromFile();
              Singleton s2 = readObjectFromFile();
      
              //判断两个反序列化后的对象是否是同一个对象
              System.out.println(s1 == s2);
          }
      
          private static Singleton readObjectFromFile() throws Exception {
              //创建对象输入流对象
              ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\a.txt"));
              //第一个读取Singleton对象
              Singleton instance = (Singleton) ois.readObject();
      
              return instance;
          }
      
          public static void writeObject2File() throws Exception {
              //获取Singleton类的对象
              Singleton instance = Singleton.getInstance();
              //创建对象输出流
              ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\a.txt"));
              //将instance对象写出到文件中
              oos.writeObject(instance);
          }
      }
      

      上面代码运行结果是false,表明序列化和反序列化已经破坏了单例设计模式。

    • 反射

      Singleton类:

      public class Singleton {
      
          //私有构造方法
          private Singleton() {}
          
          private static volatile Singleton instance;
      
          //对外提供静态方法获取该对象
          public static Singleton getInstance() {
      
              if(instance != null) {
                  return instance;
              }
      
              synchronized (Singleton.class) {
                  if(instance != null) {
                      return instance;
                  }
                  instance = new Singleton();
                  return instance;
              }
          }
      }
      

      Test类:

      public class Test {
          public static void main(String[] args) throws Exception {
              //获取Singleton类的字节码对象
              Class clazz = Singleton.class;
              //获取Singleton类的私有无参构造方法对象
              Constructor constructor = clazz.getDeclaredConstructor();
              //取消访问检查
              constructor.setAccessible(true);
      
              //创建Singleton类的对象s1
              Singleton s1 = (Singleton) constructor.newInstance();
              //创建Singleton类的对象s2
              Singleton s2 = (Singleton) constructor.newInstance();
      
              //判断通过反射创建的两个Singleton对象是否是同一个对象
              System.out.println(s1 == s2);
          }
      }
      

      上面代码运行结果是false,表明序列化和反序列化已经破坏了单例设计模式

    注意:枚举方式不会出现这两个问题。

    4.1.3.2、问题的解决

    • 序列化、反序列方式破坏单例模式的解决方法

      在Singleton类中添加readResolve()方法,在反序列化时被反射调用,如果定义了这个方法,就返回这个方法的值,如果没有定义,则返回新new出来的对象。

      Singleton类:

      public class Singleton implements Serializable {
      
          //私有构造方法
          private Singleton() {}
      
          private static class SingletonHolder {
              private static final Singleton INSTANCE = new Singleton();
          }
      
          //对外提供静态方法获取该对象
          public static Singleton getInstance() {
              return SingletonHolder.INSTANCE;
          }
          
          /**
           * 下面是为了解决序列化反序列化破解单例模式
           */
          private Object readResolve() {
              return SingletonHolder.INSTANCE;
          }
      }
      

      源码解析:

      ObjectInputStream类

      public final Object readObject() throws IOException, ClassNotFoundException{
          ...
          // if nested read, passHandle contains handle of enclosing object
          int outerHandle = passHandle;
          try {
              Object obj = readObject0(false);//重点查看readObject0方法
          .....
      }
          
      private Object readObject0(boolean unshared) throws IOException {
      	...
          try {
      		switch (tc) {
      			...
      			case TC_OBJECT:
      				return checkResolve(readOrdinaryObject(unshared));//重点查看readOrdinaryObject方法
      			...
              }
          } finally {
              depth--;
              bin.setBlockDataMode(oldMode);
          }    
      }
          
      private Object readOrdinaryObject(boolean unshared) throws IOException {
      	...
      	//isInstantiable 返回true,执行 desc.newInstance(),通过反射创建新的单例类,
          obj = desc.isInstantiable() ? desc.newInstance() : null; 
          ...
          // 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为true
          if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {
          	// 通过反射调用 Singleton 类中的 readResolve 方法,将返回值赋值给rep变量
          	// 这样多次调用ObjectInputStream类中的readObject方法,继而就会调用我们定义的readResolve方法,所以返回的是同一个对象。
          	Object rep = desc.invokeReadResolve(obj);
           	...
          }
          return obj;
      }
      
    • 反射方式破解单例的解决方法

      public class Singleton {
      
          //私有构造方法
          private Singleton() {
              /*
                 反射破解单例模式需要添加的代码
              */
              if(instance != null) {
                  throw new RuntimeException();
              }
          }
          
          private static volatile Singleton instance;
      
          //对外提供静态方法获取该对象
          public static Singleton getInstance() {
      
              if(instance != null) {
                  return instance;
              }
      
              synchronized (Singleton.class) {
                  if(instance != null) {
                      return instance;
                  }
                  instance = new Singleton();
                  return instance;
              }
          }
      }
      

      说明:

      ​ 这种方式比较好理解。当通过反射方式调用构造方法进行创建对象时,直接抛异常。不运行此中操作。

    4.1.4、JDK源码解析-Runtime类

    Runtime类就是使用的单例设计模式。

    1. 通过源代码查看使用的是哪儿种单例模式

      public class Runtime {
          private static Runtime currentRuntime = new Runtime();
      
          /**
           * Returns the runtime object associated with the current Java application.
           * Most of the methods of class <code>Runtime</code> are instance
           * methods and must be invoked with respect to the current runtime object.
           *
           * @return  the <code>Runtime</code> object associated with the current
           *          Java application.
           */
          public static Runtime getRuntime() {
              return currentRuntime;
          }
      
          /** Don't let anyone else instantiate this class */
          private Runtime() {}
          ...
      }
      

      从上面源代码中可以看出Runtime类使用的是恶汉式(静态属性)方式来实现单例模式的。

    2. 使用Runtime类中的方法

      public class RuntimeDemo {
          public static void main(String[] args) throws IOException {
              //获取Runtime类对象
              Runtime runtime = Runtime.getRuntime();
      
              //返回 Java 虚拟机中的内存总量。
              System.out.println(runtime.totalMemory());
              //返回 Java 虚拟机试图使用的最大内存量。
              System.out.println(runtime.maxMemory());
      
              //创建一个新的进程执行指定的字符串命令,返回进程对象
              Process process = runtime.exec("ipconfig");
              //获取命令执行后的结果,通过输入流获取
              InputStream inputStream = process.getInputStream();
              byte[] arr = new byte[1024 * 1024* 100];
              int b = inputStream.read(arr);
              System.out.println(new String(arr,0,b,"gbk"));
          }
      }
      

    4.2、工厂模式

    4.2.1、概述

    需求:设计一个咖啡店点餐系统。

    设计一个咖啡类(Coffee),并定义其两个子类(美式咖啡【AmericanCoffee】和拿铁咖啡【LatteCoffee】);再设计一个咖啡店类(CoffeeStore),咖啡店具有点咖啡的功能。

    具体类的设计如下:

    在这里插入图片描述

    public abstract class Coffee {
    
       public abstract String getName();
    
       public void addSugar() {
          System.out.println("加糖");
       }
    
       public void addMilk() {
          System.out.println("加奶");
       }
    }
    
    public class AmericanCoffee extends Coffee {
    
       @Override
       public String getName() {
          return "美式咖啡";
       }
    }
    
    public class LatteCoffee extends Coffee {
       @Override
       public String getName() {
          return "拿铁咖啡";
       }
        
    }
    
    public class CoffeeStore {
    
        public Coffee orderCoffee(String type) {
            Coffee coffee = null;
            if("americano".equals(type)) {
                coffee = new AmericanoCoffee();
            } else if("latte".equals(type)) {
                coffee = new LatteCoffee();
            }
            return coffee;
        }
    }
    

    在java中,万物皆对象,这些对象都需要创建,如果创建的时候直接new该对象,就会对该对象耦合严重,假如我们要更换对象,所有new对象的地方都需要修改一遍,这显然违背了软件设计的开闭原则。如果我们使用工厂来生产对象,我们就只和工厂打交道就可以了,彻底和对象解耦,如果要更换对象,直接在工厂里更换该对象即可,达到了与对象解耦的目的;所以说,工厂模式最大的优点就是:解耦

    在本教程中会介绍三种工厂的使用

    • 简单工厂模式(不属于GOF的23种经典设计模式)
    • 工厂方法模式
    • 抽象工厂模式

    4.2.2、简单工厂模式

    简单工厂不是一种设计模式,反而比较像是一种编程习惯。

    4.2.2.1、结构

    简单工厂包含如下角色:

    • 抽象产品 :定义了产品的规范,描述了产品的主要特性和功能。
    • 具体产品 :实现或者继承抽象产品的子类
    • 具体工厂 :提供了创建产品的方法,调用者通过该方法来获取产品。

    4.2.2.2、实现

    现在使用简单工厂对上面案例进行改进,类图如下:

    在这里插入图片描述

    工厂类代码如下:

    public class SimpleCoffeeFactory {
    
        public Coffee createCoffee(String type) {
            Coffee coffee = null;
            if("americano".equals(type)) {
                coffee = new AmericanoCoffee();
            } else if("latte".equals(type)) {
                coffee = new LatteCoffee();
            }
            return coffee;
        }
    }
    

    工厂(factory)处理创建对象的细节,一旦有了SimpleCoffeeFactory,CoffeeStore类中的orderCoffee()就变成此对象的客户,后期如果需要Coffee对象直接从工厂中获取即可。这样也就解除了和Coffee实现类的耦合,同时又产生了新的耦合,CoffeeStore对象和SimpleCoffeeFactory工厂对象的耦合,工厂对象和商品对象的耦合。

    后期如果再加新品种的咖啡,我们势必要需求修改SimpleCoffeeFactory的代码,违反了开闭原则。工厂类的客户端可能有很多,比如创建美团外卖等,这样只需要修改工厂类的代码,省去其他的修改操作。

    4.2.2.4 优缺点

    优点:

    封装了创建对象的过程,可以通过参数直接获取对象。把对象的创建和业务逻辑层分开,这样以后就避免了修改客户代码,如果要实现新产品直接修改工厂类,而不需要在原代码中修改,这样就降低了客户代码修改的可能性,更加容易扩展。

    缺点:

    增加新产品时还是需要修改工厂类的代码,违背了“开闭原则”。

    4.2.2.3 扩展

    静态工厂

    在开发中也有一部分人将工厂类中的创建对象的功能定义为静态的,这个就是静态工厂模式,它也不是23种设计模式中的。代码如下:

    public class SimpleCoffeeFactory {
    
        public static Coffee createCoffee(String type) {
            Coffee coffee = null;
            if("americano".equals(type)) {
                coffee = new AmericanoCoffee();
            } else if("latte".equals(type)) {
                coffee = new LatteCoffee();
            }
            return coffe;
        }
    }
    

    4.2.3、工厂方法模式

    针对上例中的缺点,使用工厂方法模式就可以完美的解决,完全遵循开闭原则。

    4.2.3.1、概念

    定义一个用于创建对象的接口,让子类决定实例化哪个产品类对象。工厂方法使一个产品类的实例化延迟到其工厂的子类。

    4.2.3.2、结构

    工厂方法模式的主要角色:

    • 抽象工厂(Abstract Factory):提供了创建产品的接口,调用者通过它访问具体工厂的工厂方法来创建产品。
    • 具体工厂(ConcreteFactory):主要是实现抽象工厂中的抽象方法,完成具体产品的创建。
    • 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能。
    • 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它同具体工厂之间一一对应。

    4.2.3.3、实现

    使用工厂方法模式对上例进行改进,类图如下:

    在这里插入图片描述

    代码如下:

    抽象工厂:

    public interface CoffeeFactory {
        Coffee createCoffee();
    }
    

    具体工厂:

    public class LatteCoffeeFactory implements CoffeeFactory {
    
        public Coffee createCoffee() {
            return new LatteCoffee();
        }
    }
    
    public class AmericanCoffeeFactory implements CoffeeFactory {
    
        public Coffee createCoffee() {
            return new AmericanCoffee();
        }
    }
    

    咖啡店类:

    public class CoffeeStore {
    
        private CoffeeFactory factory;
    
        public CoffeeStore(CoffeeFactory factory) {
            this.factory = factory;
        }
    
        public Coffee orderCoffee(String type) {
            Coffee coffee = factory.createCoffee();
            coffee.addMilk();
            coffee.addsugar();
            return coffee;
        }
    }
    

    从以上的编写的代码可以看到,要增加产品类时也要相应地增加工厂类,不需要修改工厂类的代码了,这样就解决了简单工厂模式的缺点。

    工厂方法模式是简单工厂模式的进一步抽象。由于使用了多态性,工厂方法模式保持了简单工厂模式的优点,而且克服了它的缺点。

    4.2.3.4 优缺点

    优点:

    • 用户只需要知道具体工厂的名称就可得到所要的产品,无须知道产品的具体创建过程;
    • 在系统增加新的产品时只需要添加具体产品类和对应的具体工厂类,无须对原工厂进行任何修改,满足开闭原则;

    缺点:

    • 每增加一个产品就要增加一个具体产品类和一个对应的具体工厂类,这增加了系统的复杂度。

    4.2.4、抽象工厂模式

    前面介绍的工厂方法模式中考虑的是一类产品的生产,如畜牧场只养动物、电视机厂只生产电视机等。

    这些工厂只生产同种类产品,同种类产品称为同等级产品,也就是说:工厂方法模式只考虑生产同等级的产品,但是在现实生活中许多工厂是综合型的工厂,能生产多等级(种类) 的产品,如电器厂既生产电视机又生产洗衣机或空调,大学既有软件专业又有生物专业等。

    本节要介绍的抽象工厂模式将考虑多等级产品的生产,将同一个具体工厂所生产的位于不同等级的一组产品称为一个产品族,下图所示横轴是产品等级,也就是同一类产品;纵轴是产品族,也就是同一品牌的产品,同一品牌的产品产自同一个工厂。

    在这里插入图片描述

    在这里插入图片描述

    4.2.4.1、概念

    是一种为访问类提供一个创建一组相关或相互依赖对象的接口,且访问类无须指定所要产品的具体类就能得到同族的不同等级的产品的模式结构。

    抽象工厂模式是工厂方法模式的升级版本,工厂方法模式只生产一个等级的产品,而抽象工厂模式可生产多个等级的产品。

    4.2.4.2、结构

    抽象工厂模式的主要角色如下:

    • 抽象工厂(Abstract Factory):提供了创建产品的接口,它包含多个创建产品的方法,可以创建多个不同等级的产品。
    • 具体工厂(Concrete Factory):主要是实现抽象工厂中的多个抽象方法,完成具体产品的创建。
    • 抽象产品(Product):定义了产品的规范,描述了产品的主要特性和功能,抽象工厂模式有多个抽象产品。
    • 具体产品(ConcreteProduct):实现了抽象产品角色所定义的接口,由具体工厂来创建,它 同具体工厂之间是多对一的关系。

    4.2.4.2、实现

    现咖啡店业务发生改变,不仅要生产咖啡还要生产甜点,如提拉米苏、抹茶慕斯等,要是按照工厂方法模式,需要定义提拉米苏类、抹茶慕斯类、提拉米苏工厂、抹茶慕斯工厂、甜点工厂类,很容易发生类爆炸情况。其中拿铁咖啡、美式咖啡是一个产品等级,都是咖啡;提拉米苏、抹茶慕斯也是一个产品等级;拿铁咖啡和提拉米苏是同一产品族(也就是都属于意大利风味),美式咖啡和抹茶慕斯是同一产品族(也就是都属于美式风味)。所以这个案例可以使用抽象工厂模式实现。类图如下:

    在这里插入图片描述

    代码如下:

    抽象工厂:

    public interface DessertFactory {
    
        Coffee createCoffee();
    
        Dessert createDessert();
    }
    

    具体工厂:

    //美式甜点工厂
    public class AmericanDessertFactory implements DessertFactory {
    
        public Coffee createCoffee() {
            return new AmericanCoffee();
        }
    
        public Dessert createDessert() {
            return new MatchaMousse();
        }
    }
    //意大利风味甜点工厂
    public class ItalyDessertFactory implements DessertFactory {
    
        public Coffee createCoffee() {
            return new LatteCoffee();
        }
    
        public Dessert createDessert() {
            return new Tiramisu();
        }
    }
    

    如果要加同一个产品族的话,只需要再加一个对应的工厂类即可,不需要修改其他的类。

    4.2.4.3、优缺点

    优点:

    当一个产品族中的多个对象被设计成一起工作时,它能保证客户端始终只使用同一个产品族中的对象。

    缺点:

    当产品族中需要增加一个新的产品时,所有的工厂类都需要进行修改。

    4.2.4.4、使用场景

    • 当需要创建的对象是一系列相互关联或相互依赖的产品族时,如电器工厂中的电视机、洗衣机、空调等。

    • 系统中有多个产品族,但每次只使用其中的某一族产品。如有人只喜欢穿某一个品牌的衣服和鞋。

    • 系统中提供了产品的类库,且所有产品的接口相同,客户端不依赖产品实例的创建细节和内部结构。

    如:输入法换皮肤,一整套一起换。生成不同操作系统的程序。

    4.2.5、模式扩展

    简单工厂+ 配置文件解除耦合

    可以通过工厂模式+配置文件的方式解除工厂对象和产品对象的耦合。在工厂类中加载配置文件中的全类名,并创建对象进行存储,客户端如果需要对象,直接进行获取即可。

    第一步:定义配置文件

    名称为bean.properties

    american=com.itheima.pattern.factory.config_factory.AmericanCoffee
    latte=com.itheima.pattern.factory.config_factory.LatteCoffee
    

    第二步:改进工厂类

    public class CoffeeFactory {
    
        private static Map<String,Coffee> map = new HashMap();
    
        static {
            Properties p = new Properties();
            InputStream is = CoffeeFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            try {
                p.load(is);
                //遍历Properties集合对象
                Set<Object> keys = p.keySet();
                for (Object key : keys) {
                    //根据键获取值(全类名)
                    String className = p.getProperty((String) key);
                    //获取字节码对象
                    Class clazz = Class.forName(className);
                    Coffee obj = (Coffee) clazz.newInstance();
                    map.put((String)key,obj);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        public static Coffee createCoffee(String name) {
    
            return map.get(name);
        }
    }
    

    静态成员变量用来存储创建的对象(键存储的是名称,值存储的是对应的对象),而读取配置文件以及创建对象写在静态代码块中,目的就是只需要执行一次。

    4.2.6 JDK源码解析-Collection.iterator方法

    public class Demo {
        public static void main(String[] args) {
            List<String> list = new ArrayList<>();
            list.add("令狐冲");
            list.add("风清扬");
            list.add("任我行");
    
            //获取迭代器对象
            Iterator<String> it = list.iterator();
            //使用迭代器遍历
            while(it.hasNext()) {
                String ele = it.next();
                System.out.println(ele);
            }
        }
    }
    

    对上面的代码大家应该很熟,使用迭代器遍历集合,获取集合中的元素。而单列集合获取迭代器的方法就使用到了工厂方法模式。我们看通过类图看看结构:

    在这里插入图片描述

    public interface Iterator<E> {
        boolean hasNext();
    
        E next();
    
        default void remove() {
            throw new UnsupportedOperationException("remove");
        }
    
        default void forEachRemaining(Consumer<? super E> var1) {
            Objects.requireNonNull(var1);
    
            while(this.hasNext()) {
                var1.accept(this.next());
            }
    
        }
    }
    
    public interface Collection<E> extends Iterable<E> {
        int size();
    
        boolean isEmpty();
    
        boolean contains(Object var1);
    
        Iterator<E> iterator();
        
        ...
    }
    
    public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, Serializable {
    
        ...
            public Iterator<E> iterator() {
            return new ArrayList.Itr();
        }
    
        private class Itr implements Iterator<E> {
            int cursor;
            int lastRet;
            int expectedModCount;
    
            private Itr() {
                this.lastRet = -1;
                this.expectedModCount = ArrayList.this.modCount;
            }
    
            public boolean hasNext() {
                return this.cursor != ArrayList.this.size;
            }
    
            public E next() {
                this.checkForComodification();
                int var1 = this.cursor;
                if (var1 >= ArrayList.this.size) {
                    throw new NoSuchElementException();
                } else {
                    Object[] var2 = ArrayList.this.elementData;
                    if (var1 >= var2.length) {
                        throw new ConcurrentModificationException();
                    } else {
                        this.cursor = var1 + 1;
                        return var2[this.lastRet = var1];
                    }
                }
            }
    
            public void remove() {
                if (this.lastRet < 0) {
                    throw new IllegalStateException();
                } else {
                    this.checkForComodification();
    
                    try {
                        ArrayList.this.remove(this.lastRet);
                        this.cursor = this.lastRet;
                        this.lastRet = -1;
                        this.expectedModCount = ArrayList.this.modCount;
                    } catch (IndexOutOfBoundsException var2) {
                        throw new ConcurrentModificationException();
                    }
                }
            }
    
            public void forEachRemaining(Consumer<? super E> var1) {
                Objects.requireNonNull(var1);
                int var2 = ArrayList.this.size;
                int var3 = this.cursor;
                if (var3 < var2) {
                    Object[] var4 = ArrayList.this.elementData;
                    if (var3 >= var4.length) {
                        throw new ConcurrentModificationException();
                    } else {
                        while(var3 != var2 && ArrayList.this.modCount == this.expectedModCount) {
                            var1.accept(var4[var3++]);
                        }
    
                        this.cursor = var3;
                        this.lastRet = var3 - 1;
                        this.checkForComodification();
                    }
                }
            }
    
            final void checkForComodification() {
                if (ArrayList.this.modCount != this.expectedModCount) {
                    throw new ConcurrentModificationException();
                }
            }
        }
        ...
    }
    

    Collection接口是抽象工厂类,ArrayList是具体的工厂类;Iterator接口是抽象商品类,ArrayList类中的Iter内部类是具体的商品类。在具体的工厂类中iterator()方法创建具体的商品类的对象。

    另:

    ​ 1,DateForamt类中的getInstance()方法使用的是工厂模式;

    ​ 2,Calendar类中的getInstance()方法使用的是工厂模式;

    4.3、原型模式

    4.3.1、概述

    用一个已经创建的实例作为原型,通过复制该原型对象来创建一个和原型对象相同的新对象。

    4.3.2、结构

    原型模式包含如下角色:

    • 抽象原型类:规定了具体原型对象必须实现的的 clone() 方法。
    • 具体原型类:实现抽象原型类的 clone() 方法,它是可被复制的对象。
    • 访问类:使用具体原型类中的 clone() 方法来复制新的对象。

    接口类图如下:

    在这里插入图片描述

    4.3.3、实现

    原型模式的克隆分为浅克隆和深克隆。

    浅克隆:创建一个新对象,新对象的属性和原来对象完全相同,对于非基本类型属性,仍指向原有属性所指向的对象的内存地址。

    深克隆:创建一个新对象,属性中引用的其他对象也会被克隆,不再指向原有对象地址。

    Java中的Object类中提供了 clone() 方法来实现浅克隆。 Cloneable 接口是上面的类图中的抽象原型类,而实现了Cloneable接口的子实现类就是具体的原型类。代码如下:

    Realizetype(具体的原型类):

    public class Realizetype implements Cloneable {
    
        public Realizetype() {
            System.out.println("具体的原型对象创建完成!");
        }
    
        @Override
        protected Realizetype clone() throws CloneNotSupportedException {
            System.out.println("具体原型复制成功!");
            return (Realizetype) super.clone();
        }
    }
    

    PrototypeTest(测试访问类):

    public class PrototypeTest {
        public static void main(String[] args) throws CloneNotSupportedException {
            Realizetype r1 = new Realizetype();
            Realizetype r2 = r1.clone();
    
            System.out.println("对象r1和r2是同一个对象?" + (r1 == r2));   // false
        }
    }
    

    4.3.4、案例

    用原型模式生成“三好学生”奖状

    同一学校的“三好学生”奖状除了获奖人姓名不同,其他都相同,可以使用原型模式复制多个“三好学生”奖状出来,然后在修改奖状上的名字即可。

    类图如下:

    在这里插入图片描述

    代码如下:

    //奖状类
    public class Citation implements Cloneable {
        private String name;
    
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return (this.name);
        }
    
        public void show() {
            System.out.println(name + "同学:在2020学年第一学期中表现优秀,被评为三好学生。特发此状!");
        }
    
        @Override
        public Citation clone() throws CloneNotSupportedException {
            return (Citation) super.clone();
        }
    }
    
    //测试访问类
    public class CitationTest {
        public static void main(String[] args) throws CloneNotSupportedException {
            Citation c1 = new Citation();
            c1.setName("张三");
    
            //复制奖状
            Citation c2 = c1.clone();
            //将奖状的名字修改李四
            c2.setName("李四");
    
            c1.show();
            c2.show();
        }
    }
    

    在这里插入图片描述

    4.3.5、使用场景

    • 对象的创建非常复杂,可以使用原型模式快捷的创建对象。
    • 性能和安全要求比较高。

    4.3.6、扩展(深克隆)

    将上面的“三好学生”奖状的案例中Citation类的name属性修改为Student类型的属性。代码如下:

    //奖状类
    public class Citation implements Cloneable {
        private Student stu;
    
        public Student getStu() {
            return stu;
        }
    
        public void setStu(Student stu) {
            this.stu = stu;
        }
    
        void show() {
            System.out.println(stu.getName() + "同学:在2020学年第一学期中表现优秀,被评为三好学生。特发此状!");
        }
    
        @Override
        public Citation clone() throws CloneNotSupportedException {
            return (Citation) super.clone();
        }
    }
    
    //学生类
    public class Student {
        private String name;
    
        public Student(String name) {
            this.name = name;
        }
    
        public Student() {
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
    }
    
    //测试类
    public class CitationTest {
        public static void main(String[] args) throws CloneNotSupportedException {
    
            Citation c1 = new Citation();
            Student stu = new Student("张三");
            c1.setStu(stu);
    
            //复制奖状
            Citation c2 = c1.clone();
            //获取c2奖状所属学生对象
            Student stu1 = c2.getStu();
            stu1.setName("李四");
    
            //判断stu对象和stu1对象是否是同一个对象
            System.out.println("stu和stu1是同一个对象?" + (stu == stu1));
    
            c1.show();
            c2.show();
        }
    }
    

    运行结果为:

    在这里插入图片描述

    说明:

    ​ stu对象和stu1对象是同一个对象,就会产生将stu1对象中name属性值改为“李四”,两个Citation(奖状)对象中显示的都是李四。这就是浅克隆的效果,对具体原型类(Citation)中的引用类型的属性进行引用的复制。这种情况需要使用深克隆,而进行深克隆需要使用对象流。代码如下:

    public class CitationTest1 {
        public static void main(String[] args) throws Exception {
            Citation c1 = new Citation();
            Student stu = new Student("张三");
            c1.setStu(stu);
    
            //创建对象输出流对象
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\Think\\Desktop\\b.txt"));
            //将c1对象写出到文件中
            oos.writeObject(c1);
            oos.close();
    
            //创建对象出入流对象
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\Think\\Desktop\\b.txt"));
            //读取对象
            Citation c2 = (Citation) ois.readObject();
            //获取c2奖状所属学生对象
            Student stu1 = c2.getStu();
            stu1.setName("李四");
    
            //判断stu对象和stu1对象是否是同一个对象
            System.out.println("stu和stu1是同一个对象?" + (stu == stu1));
    
            c1.show();
            c2.show();
        }
    }
    

    运行结果为:

    在这里插入图片描述

    注意:Citation类和Student类必须实现Serializable接口,否则会抛NotSerializableException异常。

    4.4、建造者(生成器)模式

    4.4.1、概述

    将一个复杂对象的构建与表示分离,使得同样的构建过程可以创建不同的表示。

    在这里插入图片描述

    • 分离了部件的构造(由Builder来负责)和装配(由Director负责)。 从而可以构造出复杂的对象。这个模式适用于:某个对象的构建过程复杂的情况。
    • 由于实现了构建和装配的解耦。不同的构建器,相同的装配,也可以做出不同的对象;相同的构建器,不同的装配顺序也可以做出不同的对象。也就是实现了构建算法、装配算法的解耦,实现了更好的复用。
    • 建造者模式可以将部件和其组装过程分开,一步一步创建一个复杂的对象。用户只需要指定复杂对象的类型就可以得到该对象,而无须知道其内部的具体构造细节。

    4.4.2、结构

    建造者(Builder)模式包含如下角色:

    • 抽象建造者类(Builder):这个接口规定要实现复杂对象的那些部分的创建,并不涉及具体的部件对象的创建。

    • 具体建造者类(ConcreteBuilder):实现 Builder 接口,完成复杂产品的各个部件的具体创建方法。在构造过程完成后,提供产品的实例。

    • 产品类(Product):要创建的复杂对象。

    • 指挥者类(Director):调用具体建造者来创建复杂对象的各个部分,在指导者中不涉及具体产品的信息,只负责保证对象各部分完整创建或按某种顺序创建。

    类图如下:

    在这里插入图片描述

    4.4.3、实例

    创建共享单车

    生产自行车是一个复杂的过程,它包含了车架,车座等组件的生产。而车架又有碳纤维,铝合金等材质的,车座有橡胶,真皮等材质。对于自行车的生产就可以使用建造者模式。

    这里Bike是产品,包含车架,车座等组件;Builder是抽象建造者,MobikeBuilder和OfoBuilder是具体的建造者;Director是指挥者。类图如下:

    在这里插入图片描述

    具体的代码如下:

    //自行车类
    public class Bike {
        private String frame;
        private String seat;
    
        public String getFrame() {
            return frame;
        }
    
        public void setFrame(String frame) {
            this.frame = frame;
        }
    
        public String getSeat() {
            return seat;
        }
    
        public void setSeat(String seat) {
            this.seat = seat;
        }
    }
    
    // 抽象 builder 类
    public abstract class Builder {
    
        protected Bike mBike = new Bike();
    
        public abstract void buildFrame();
        public abstract void buildSeat();
        public abstract Bike createBike();
    }
    
    //摩拜单车Builder类
    public class MobikeBuilder extends Builder {
    
        @Override
        public void buildFrame() {
            mBike.setFrame("铝合金车架");
        }
    
        @Override
        public void buildSeat() {
            mBike.setSeat("真皮车座");
        }
    
        @Override
        public Bike createBike() {
            return mBike;
        }
    }
    
    //ofo单车Builder类
    public class OfoBuilder extends Builder {
    
        @Override
        public void buildFrame() {
            mBike.setFrame("碳纤维车架");
        }
    
        @Override
        public void buildSeat() {
            mBike.setSeat("橡胶车座");
        }
    
        @Override
        public Bike createBike() {
            return mBike;
        }
    }
    
    //指挥者类
    public class Director {
        private Builder mBuilder;
    
        public Director(Builder builder) {
            mBuilder = builder;
        }
    
        public Bike construct() {
            mBuilder.buildFrame();
            mBuilder.buildSeat();
            return mBuilder.createBike();
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
          	Director director = new Director(new MobileBuilder());
    		Bike bike = director.construct();
    
    		System.out.println(bike.getFrame());
    		System.out.println(bike.getSeat());
        }
    }
    

    注意:

    上面示例是 Builder模式的常规用法,指挥者类 Director 在建造者模式中具有很重要的作用,它用于指导具体构建者如何构建产品,控制调用先后次序,并向调用者返回完整的产品类,但是有些情况下需要简化系统结构,可以把指挥者类和抽象建造者进行结合

    // 抽象 builder 类
    public abstract class Builder {
    
        protected Bike mBike = new Bike();
    
        public abstract void buildFrame();
        public abstract void buildSeat();
        public abstract Bike createBike();
        
        public Bike construct() {
            this.buildFrame();
            this.BuildSeat();
            return this.createBike();
        }
    }
    

    说明:

    这样做确实简化了系统结构,但同时也加重了抽象建造者类的职责,也不是太符合单一职责原则,如果construct() 过于复杂,建议还是封装到 Director 中。

    4.4.4、优缺点

    优点:

    • 建造者模式的封装性很好。使用建造者模式可以有效的封装变化,在使用建造者模式的场景中,一般产品类和建造者类是比较稳定的,因此,将主要的业务逻辑封装在指挥者类中对整体而言可以取得比较好的稳定性。
    • 在建造者模式中,客户端不必知道产品内部组成的细节,将产品本身与产品的创建过程解耦,使得相同的创建过程可以创建不同的产品对象。
    • 可以更加精细地控制产品的创建过程 。将复杂产品的创建步骤分解在不同的方法中,使得创建过程更加清晰,也更方便使用程序来控制创建过程。
    • 建造者模式很容易进行扩展。如果有新的需求,通过实现一个新的建造者类就可以完成,基本上不用修改之前已经测试通过的代码,因此也就不会对原有功能引入风险。符合开闭原则。

    缺点:

    造者模式所创建的产品一般具有较多的共同点,其组成部分相似,如果产品之间的差异性很大,则不适合使用建造者模式,因此其使用范围受到一定的限制。

    4.4.5、使用场景

    建造者(Builder)模式创建的是复杂对象,其产品的各个部分经常面临着剧烈的变化,但将它们组合在一起的算法却相对稳定,所以它通常在以下场合使用。

    • 创建的对象较复杂,由多个部件构成,各部件面临着复杂的变化,但构件间的建造顺序是稳定的。
    • 创建复杂对象的算法独立于该对象的组成部分以及它们的装配方式,即产品的构建过程和最终的表示是独立的。

    4.4.6、模式扩展

    建造者模式除了上面的用途外,在开发中还有一个常用的使用方式,就是当一个类构造器需要传入很多参数时,如果创建这个类的实例,代码可读性会非常差,而且很容易引入错误,此时就可以利用建造者模式进行重构。

    重构前代码如下:

    public class Phone {
        private String cpu;
        private String screen;
        private String memory;
        private String mainboard;
    
        public Phone(String cpu, String screen, String memory, String mainboard) {
            this.cpu = cpu;
            this.screen = screen;
            this.memory = memory;
            this.mainboard = mainboard;
        }
    
        public String getCpu() {
            return cpu;
        }
    
        public void setCpu(String cpu) {
            this.cpu = cpu;
        }
    
        public String getScreen() {
            return screen;
        }
    
        public void setScreen(String screen) {
            this.screen = screen;
        }
    
        public String getMemory() {
            return memory;
        }
    
        public void setMemory(String memory) {
            this.memory = memory;
        }
    
        public String getMainboard() {
            return mainboard;
        }
    
        public void setMainboard(String mainboard) {
            this.mainboard = mainboard;
        }
    
        @Override
        public String toString() {
            return "Phone{" +
                    "cpu='" + cpu + '\'' +
                    ", screen='" + screen + '\'' +
                    ", memory='" + memory + '\'' +
                    ", mainboard='" + mainboard + '\'' +
                    '}';
        }
    }
    
    public class Client {
        public static void main(String[] args) {
            //构建Phone对象
            Phone phone = new Phone("intel","三星屏幕","金士顿","华硕");
            System.out.println(phone);
        }
    }
    

    上面在客户端代码中构建Phone对象,传递了四个参数,如果参数更多呢?代码的可读性及使用的成本就是比较高。

    重构后代码:

    public class Phone {
    
        private String cpu;
        private String screen;
        private String memory;
        private String mainboard;
    
        private Phone(Builder builder) {
            cpu = builder.cpu;
            screen = builder.screen;
            memory = builder.memory;
            mainboard = builder.mainboard;
        }
    
        public static final class Builder {
            private String cpu;
            private String screen;
            private String memory;
            private String mainboard;
    
            public Builder() {}
    
            public Builder cpu(String val) {
                cpu = val;
                return this;
            }
            public Builder screen(String val) {
                screen = val;
                return this;
            }
            public Builder memory(String val) {
                memory = val;
                return this;
            }
            public Builder mainboard(String val) {
                mainboard = val;
                return this;
            }
            public Phone build() {
                return new Phone(this);}
        }
        @Override
        public String toString() {
            return "Phone{" +
                    "cpu='" + cpu + '\'' +
                    ", screen='" + screen + '\'' +
                    ", memory='" + memory + '\'' +
                    ", mainboard='" + mainboard + '\'' +
                    '}';
        }
    }
    
    public class Client {
        public static void main(String[] args) {
            Phone phone = new Phone.Builder()
                    .cpu("intel")
                    .mainboard("华硕")
                    .memory("金士顿")
                    .screen("三星")
                    .build();
            System.out.println(phone);
        }
    }
    

    重构后的代码在使用起来更方便,某种程度上也可以提高开发效率。从软件设计上,对程序员的要求比较高。

    4.5、创建者模式对比

    4.5.1、工厂方法模式VS建造者模式

    工厂方法模式专门用于生产一系列相关对象;而建造者模式注重的是部件构建的过程,意在通过一步一步地精确构造创建出一个复杂的对象。

    我们举个简单例子来说明两者的差异,如要制造一个超人,如果使用工厂方法模式,直接产生出来的就是一个力大无穷、能够飞翔、内裤外穿的超人;而如果使用建造者模式,则需要组装手、头、脚、躯干等部分,然后再把内裤外穿,于是一个超人就诞生了。

    4.5.2、抽象工厂模式VS建造者模式

    抽象工厂模式实现对产品家族的创建,一个产品家族是这样的一系列产品:具有不同分类维度的产品组合,采用抽象工厂模式则是不需要关心构建过程,只关心什么产品由什么工厂生产即可。

    建造者模式则是要求按照指定的蓝图建造产品,它的主要目的是通过组装零配件而产生一个新产品。

    如果将抽象工厂模式看成汽车配件生产工厂,生产一个产品族的产品,那么建造者模式就是一个汽车组装工厂,通过对部件的组装可以返回一辆完整的汽车。

    五、结构型模式

    结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式,前者采用继承机制来组织接口和类,后者釆用组合或聚合来组合对象。

    由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象结构型模式比类结构型模式具有更大的灵活性。

    结构型模式分为以下 7 种:

    • 代理模式
    • 适配器模式
    • 装饰者模式
    • 桥接模式
    • 外观模式
    • 组合模式
    • 享元模式

    5.1、代理模式

    5.1.1、概述

    由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时,访问对象不适合或者不能直接引用目标对象,代理对象作为访问对象和目标对象之间的中介。

    Java中的代理按照代理类生成时机不同又分为静态代理和动态代理。静态代理代理类在编译期就生成,而动态代理代理类则是在Java运行时动态生成。动态代理又有JDK代理和CGLib代理两种。

    5.1.2 结构

    代理(Proxy)模式分为三种角色:

    • 抽象主题(Subject)类: 通过接口或抽象类声明真实主题和代理对象实现的业务方法。
    • 真实主题(Real Subject)类: 实现了抽象主题中的具体业务,是代理对象所代表的真实对象,是最终要引用的对象。
    • 代理(Proxy)类 : 提供了与真实主题相同的接口,其内部含有对真实主题的引用,它可以访问、控制或扩展真实主题的功能。

    5.1.3 静态代理

    我们通过案例来感受一下静态代理。

    【例】火车站卖票

    如果要买火车票的话,需要去火车站买票,坐车到火车站,排队等一系列的操作,显然比较麻烦。而火车站在多个地方都有代售点,我们去代售点买票就方便很多了。这个例子其实就是典型的代理模式,火车站是目标对象,代售点是代理对象。类图如下:

    在这里插入图片描述

    代码如下:

    //卖票接口
    public interface SellTickets {
        void sell();
    }
    
    //火车站  火车站具有卖票功能,所以需要实现SellTickets接口
    public class TrainStation implements SellTickets {
    
        public void sell() {
            System.out.println("火车站卖票");
        }
    }
    
    //代售点
    public class ProxyPoint implements SellTickets {
    
        private TrainStation station = new TrainStation();
    
        public void sell() {
            System.out.println("代理点收取一些服务费用");
            station.sell();
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            ProxyPoint pp = new ProxyPoint();
            pp.sell();
        }
    }
    

    从上面代码中可以看出测试类直接访问的是ProxyPoint类对象,也就是说ProxyPoint作为访问对象和目标对象的中介。同时也对sell方法进行了增强(代理点收取一些服务费用)。

    5.1.4、JDK动态代理

    接下来我们使用动态代理实现上面案例,先说说 JDK 提供的动态代理。Java中提供了一个动态代理类Proxy,Proxy并不是我们上述所说的代理对象的类,而是提供了一个创建代理对象的静态方法(newProxyInstance方法)来获取代理对象。

    代码如下:

    //卖票接口
    public interface SellTickets {
        void sell();
    }
    
    //火车站  火车站具有卖票功能,所以需要实现SellTickets接口
    public class TrainStation implements SellTickets {
    
        public void sell() {
            System.out.println("火车站卖票");
        }
    }
    
    //代理工厂,用来创建代理对象
    public class ProxyFactory {
    
        private TrainStation station = new TrainStation();
    
        public SellTickets getProxyObject() {
            //使用Proxy获取代理对象
            /*
                newProxyInstance()方法参数说明:
                    ClassLoader loader : 类加载器,用于加载代理类,使用真实对象的类加载器即可
                    Class<?>[] interfaces : 真实对象所实现的接口,代理模式真实对象和代理对象实现相同的接口
                    InvocationHandler h : 代理对象的调用处理程序
             */
            SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
                    station.getClass().getInterfaces(),
                    new InvocationHandler() {
                        /*
                            InvocationHandler中invoke方法参数说明:
                                proxy : 代理对象
                                method : 对应于在代理对象上调用的接口方法的 Method 实例
                                args : 代理对象调用接口方法时传递的实际参数
                         */
                        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    
                            System.out.println("代理点收取一些服务费用(JDK动态代理方式)");
                            //执行真实对象
                            Object result = method.invoke(station, args);
                            return result;
                        }
                    });
            return sellTickets;
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            //获取代理对象
            ProxyFactory factory = new ProxyFactory();
            
            SellTickets proxyObject = factory.getProxyObject();
            proxyObject.sell();
        }
    }
    

    使用了动态代理,我们思考下面问题:

    • ProxyFactory是代理类吗?

      ProxyFactory不是代理模式中所说的代理类,而代理类是程序在运行过程中动态的在内存中生成的类。通过阿里巴巴开源的 Java 诊断工具(Arthas【阿尔萨斯】)查看代理类的结构:

      package com.sun.proxy;
      
      import com.itheima.proxy.dynamic.jdk.SellTickets;
      import java.lang.reflect.InvocationHandler;
      import java.lang.reflect.Method;
      import java.lang.reflect.Proxy;
      import java.lang.reflect.UndeclaredThrowableException;
      
      public final class $Proxy0 extends Proxy implements SellTickets {
          private static Method m1;
          private static Method m2;
          private static Method m3;
          private static Method m0;
      
          public $Proxy0(InvocationHandler invocationHandler) {
              super(invocationHandler);
          }
      
          static {
              try {
                  m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
                  m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
                  m3 = Class.forName("com.itheima.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]);
                  m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
                  return;
              }
              catch (NoSuchMethodException noSuchMethodException) {
                  throw new NoSuchMethodError(noSuchMethodException.getMessage());
              }
              catch (ClassNotFoundException classNotFoundException) {
                  throw new NoClassDefFoundError(classNotFoundException.getMessage());
              }
          }
      
          public final boolean equals(Object object) {
              try {
                  return (Boolean)this.h.invoke(this, m1, new Object[]{object});
              }
              catch (Error | RuntimeException throwable) {
                  throw throwable;
              }
              catch (Throwable throwable) {
                  throw new UndeclaredThrowableException(throwable);
              }
          }
      
          public final String toString() {
              try {
                  return (String)this.h.invoke(this, m2, null);
              }
              catch (Error | RuntimeException throwable) {
                  throw throwable;
              }
              catch (Throwable throwable) {
                  throw new UndeclaredThrowableException(throwable);
              }
          }
      
          public final int hashCode() {
              try {
                  return (Integer)this.h.invoke(this, m0, null);
              }
              catch (Error | RuntimeException throwable) {
                  throw throwable;
              }
              catch (Throwable throwable) {
                  throw new UndeclaredThrowableException(throwable);
              }
          }
      
          public final void sell() {
              try {
                  this.h.invoke(this, m3, null);
                  return;
              }
              catch (Error | RuntimeException throwable) {
                  throw throwable;
              }
              catch (Throwable throwable) {
                  throw new UndeclaredThrowableException(throwable);
              }
          }
      }
      

      从上面的类中,我们可以看到以下几个信息:

      • 代理类($Proxy0)实现了SellTickets接口。这也就印证了我们之前说的真实类和代理类实现同样的接口。
      • 代理类($Proxy0)将我们提供了的匿名内部类对象传递给了父类。
    • 动态代理的执行流程是什么样?

      下面是摘取的重点代码:

      //程序运行过程中动态生成的代理类
      public final class $Proxy0 extends Proxy implements SellTickets {
          private static Method m3;
      
          public $Proxy0(InvocationHandler invocationHandler) {
              super(invocationHandler);
          }
      
          static {
              m3 = Class.forName("com.itheima.proxy.dynamic.jdk.SellTickets").getMethod("sell", new Class[0]);
          }
      
          public final void sell() {
              this.h.invoke(this, m3, null);
          }
      }
      
      //Java提供的动态代理相关类
      public class Proxy implements java.io.Serializable {
      	protected InvocationHandler h;
      	 
      	protected Proxy(InvocationHandler h) {
              this.h = h;
          }
      }
      
      //代理工厂类
      public class ProxyFactory {
      
          private TrainStation station = new TrainStation();
      
          public SellTickets getProxyObject() {
              SellTickets sellTickets = (SellTickets) Proxy.newProxyInstance(station.getClass().getClassLoader(),
                      station.getClass().getInterfaces(),
                      new InvocationHandler() {
                          
                          public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                              System.out.println("代理点收取一些服务费用(JDK动态代理方式)");
                              Object result = method.invoke(station, args);
                              return result;
                          }
                      });
              return sellTickets;
          }
      }
      
      
      //测试访问类
      public class Client {
          public static void main(String[] args) {
              //获取代理对象
              ProxyFactory factory = new ProxyFactory();
              SellTickets proxyObject = factory.getProxyObject();
              proxyObject.sell();
          }
      }
      

    执行流程如下:

    1. 在测试类中通过代理对象调用sell()方法
    2. 根据多态的特性,执行的是代理类($Proxy0)中的sell()方法
    3. 代理类($Proxy0)中的sell()方法中又调用了InvocationHandler接口的子实现类对象的invoke方法
    4. invoke方法通过反射执行了真实对象所属类(TrainStation)中的sell()方法

    5.1.5、CGLIB动态代理

    同样是上面的案例,我们再次使用CGLIB代理实现。

    如果没有定义SellTickets接口,只定义了TrainStation(火车站类)。很显然JDK代理是无法使用了,因为JDK动态代理要求必须定义接口,对接口进行代理。

    CGLIB是一个功能强大,高性能的代码生成包。它为没有实现接口的类提供代理,为JDK的动态代理提供了很好的补充。

    CGLIB是第三方提供的包,所以需要引入jar包的坐标:

    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
    </dependency>
    

    代码如下:

    //火车站
    public class TrainStation {
    
        public void sell() {
            System.out.println("火车站卖票");
        }
    }
    
    //代理工厂
    public class ProxyFactory implements MethodInterceptor {
    
        private TrainStation target = new TrainStation();
    
        public TrainStation getProxyObject() {
            //创建Enhancer对象,类似于JDK动态代理的Proxy类,下一步就是设置几个参数
            Enhancer enhancer =new Enhancer();
            //设置父类的字节码对象
            enhancer.setSuperclass(target.getClass());
            //设置回调函数
            enhancer.setCallback(this);
            //创建代理对象
            TrainStation obj = (TrainStation) enhancer.create();
            return obj;
        }
    
        /*
            intercept方法参数说明:
                o : 代理对象
                method : 真实对象中的方法的Method实例
                args : 实际参数
                methodProxy :代理对象中的方法的method实例
         */
        public TrainStation intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
            System.out.println("代理点收取一些服务费用(CGLIB动态代理方式)");
            TrainStation result = (TrainStation) methodProxy.invokeSuper(o, args);
            return result;
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            //创建代理工厂对象
            ProxyFactory factory = new ProxyFactory();
            //获取代理对象
            TrainStation proxyObject = factory.getProxyObject();
    
            proxyObject.sell();
        }
    }
    

    5.1.6、三种代理的对比

    • jdk代理和CGLIB代理

      使用CGLib实现动态代理,CGLib底层采用ASM字节码生成框架,使用字节码技术生成代理类,在JDK1.6之前比使用Java反射效率要高。唯一需要注意的是,CGLib不能对声明为final的类或者方法进行代理,因为CGLib原理是动态生成被代理类的子类。

      在JDK1.6、JDK1.7、JDK1.8逐步对JDK动态代理优化之后,在调用次数较少的情况下,JDK代理效率高于CGLib代理效率,只有当进行大量调用的时候,JDK1.6和JDK1.7比CGLib代理效率低一点,但是到JDK1.8的时候,JDK代理效率高于CGLib代理。所以如果有接口使用JDK动态代理,如果没有接口使用CGLIB代理。

    • 动态代理和静态代理

      动态代理与静态代理相比较,最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvocationHandler.invoke)。这样,在接口方法数量比较多的时候,我们可以进行灵活处理,而不需要像静态代理那样每一个方法进行中转。

      如果接口增加一个方法,静态代理模式除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。而动态代理不会出现该问题

    5.1.7、优缺点

    优点:

    • 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用;
    • 代理对象可以扩展目标对象的功能;
    • 代理模式能将客户端与目标对象分离,在一定程度上降低了系统的耦合度;

    缺点:

    • 增加了系统的复杂度;

    5.1.8、使用场景

    • 远程(Remote)代理

      本地服务通过网络请求远程服务。为了实现本地到远程的通信,我们需要实现网络通信,处理其中可能的异常。为良好的代码设计和可维护性,我们将网络通信部分隐藏起来,只暴露给本地服务一个接口,通过该接口即可访问远程服务提供的功能,而不必过多关心通信部分的细节。

    • 防火墙(Firewall)代理

      当你将浏览器配置成使用代理功能时,防火墙就将你的浏览器的请求转给互联网;当互联网返回响应时,代理服务器再把它转给你的浏览器。

    • 保护(Protect or Access)代理

      控制对一个对象的访问,如果需要,可以给不同的用户提供不同级别的使用权限。

    5.2、适配器模式

    5.2.1、概述

    如果去欧洲国家去旅游的话,他们的插座如下图最左边,是欧洲标准。而我们使用的插头如下图最右边的。因此我们的笔记本电脑,手机在当地不能直接充电。所以就需要一个插座转换器,转换器第1面插入当地的插座,第2面供我们充电,这样使得我们的插头在当地能使用。生活中这样的例子很多,手机充电器(将220v转换为5v的电压),读卡器等,其实就是使用到了适配器模式。

    在这里插入图片描述

    定义:

    ​ 将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

    ​ 适配器模式分为类适配器模式和对象适配器模式,前者类之间的耦合度比后者高,且要求程序员了解现有组件库中的相关组件的内部结构,所以应用相对较少些。

    5.2.2、结构

    适配器模式(Adapter)包含以下主要角色:

    • 目标(Target)接口:当前系统业务所期待的接口,它可以是抽象类或接口。
    • 适配者(Adaptee)类:它是被访问和适配的现存组件库中的组件接口。
    • 适配器(Adapter)类:它是一个转换器,通过继承或引用适配者的对象,把适配者接口转换成目标接口,让客户按目标接口的格式访问适配者。

    5.2.3、 类适配器模式

    实现方式:定义一个适配器类来实现当前系统的业务接口,同时又继承现有组件库中已经存在的组件。

    【例】读卡器

    现有一台电脑只能读取SD卡,而要读取TF卡中的内容的话就需要使用到适配器模式。创建一个读卡器,将TF卡中的内容读取出来。

    类图如下:

    在这里插入图片描述

    代码如下:

    //SD卡的接口
    public interface SDCard {
        //读取SD卡方法
        String readSD();
        //写入SD卡功能
        void writeSD(String msg);
    }
    
    //SD卡实现类
    public class SDCardImpl implements SDCard {
        public String readSD() {
            String msg = "sd card read a msg :hello word SD";
            return msg;
        }
    
        public void writeSD(String msg) {
            System.out.println("sd card write msg : " + msg);
        }
    }
    
    //电脑类
    public class Computer {
    
        public String readSD(SDCard sdCard) {
            if(sdCard == null) {
                throw new NullPointerException("sd card null");
            }
            return sdCard.readSD();
        }
    }
    
    //TF卡接口
    public interface TFCard {
        //读取TF卡方法
        String readTF();
        //写入TF卡功能
        void writeTF(String msg);
    }
    
    //TF卡实现类
    public class TFCardImpl implements TFCard {
    
        public String readTF() {
            String msg ="tf card read msg : hello word tf card";
            return msg;
        }
    
        public void writeTF(String msg) {
            System.out.println("tf card write a msg : " + msg);
        }
    }
    
    //定义适配器类(SD兼容TF)
    public class SDAdapterTF extends TFCardImpl implements SDCard {
    
        public String readSD() {
            System.out.println("adapter read tf card ");
            return readTF();
        }
    
        public void writeSD(String msg) {
            System.out.println("adapter write tf card");
            writeTF(msg);
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            Computer computer = new Computer();
            SDCard sdCard = new SDCardImpl();
            System.out.println(computer.readSD(sdCard));
    
            System.out.println("------------");
    
            SDAdapterTF adapter = new SDAdapterTF();
            System.out.println(computer.readSD(adapter));
        }
    }
    

    类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可用,反之不可用。

    5.2.4、对象适配器模式

    实现方式:对象适配器模式可釆用将现有组件库中已经实现的组件引入适配器类中,该类同时实现当前系统的业务接口。

    【例】读卡器

    我们使用对象适配器模式将读卡器的案例进行改写。类图如下:

    在这里插入图片描述

    代码如下:

    类适配器模式的代码,我们只需要修改适配器类(SDAdapterTF)和测试类。

    //创建适配器对象(SD兼容TF)
    public class SDAdapterTF  implements SDCard {
    
        private TFCard tfCard;
    
        public SDAdapterTF(TFCard tfCard) {
            this.tfCard = tfCard;
        }
    
        public String readSD() {
            System.out.println("adapter read tf card ");
            return tfCard.readTF();
        }
    
        public void writeSD(String msg) {
            System.out.println("adapter write tf card");
            tfCard.writeTF(msg);
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            Computer computer = new Computer();
            SDCard sdCard = new SDCardImpl();
            System.out.println(computer.readSD(sdCard));
    
            System.out.println("------------");
    
            TFCard tfCard = new TFCardImpl();
            SDAdapterTF adapter = new SDAdapterTF(tfCard);
            System.out.println(computer.readSD(adapter));
        }
    }
    

    注意:还有一个适配器模式是接口适配器模式。当不希望实现一个接口中所有的方法时,可以创建一个抽象类Adapter ,实现所有方法。而此时我们只需要继承该抽象类即可。

    5.2.5、应用场景

    • 以前开发的系统存在满足新系统功能需求的类,但其接口同新系统的接口不一致。
    • 使用第三方提供的组件,但组件接口定义和自己要求的接口定义不同。

    5.2.6、JDK源码解析

    Reader(字符流)、InputStream(字节流)的适配使用的是InputStreamReader。

    InputStreamReader继承自java.io包中的Reader,对他中的抽象的未实现的方法给出实现。如:

    public int read() throws IOException {
        return sd.read();
    }
    
    public int read(char cbuf[], int offset, int length) throws IOException {
        return sd.read(cbuf, offset, length);
    }
    

    如上代码中的sd(StreamDecoder类对象),在Sun的JDK实现中,实际的方法实现是对sun.nio.cs.StreamDecoder类的同名方法的调用封装。类结构图如下:

    在这里插入图片描述

    从上图可以看出:

    • InputStreamReader是对同样实现了Reader的StreamDecoder的封装。
    • StreamDecoder不是Java SE API中的内容,是Sun JDK给出的自身实现。但我们知道他们对构造方法中的字节流类(InputStream)进行封装,并通过该类进行了字节流和字符流之间的解码转换。

    结论:

    ​ 从表层来看,InputStreamReader做了InputStream字节流类到Reader字符流之间的转换。而从如上Sun JDK中的实现类关系结构中可以看出,是StreamDecoder的设计实现在实际上采用了适配器模式。

    5.3、装饰者模式

    5.3.1、概述

    我们先来看一个快餐店的例子。

    快餐店有炒面、炒饭这些快餐,可以额外附加鸡蛋、火腿、培根这些配菜,当然加配菜需要额外加钱,每个配菜的价钱通常不太一样,那么计算总价就会显得比较麻烦。

    在这里插入图片描述

    使用继承的方式存在的问题:

    • 扩展性不好

      如果要再加一种配料(火腿肠),我们就会发现需要给FriedRice和FriedNoodles分别定义一个子类。如果要新增一个快餐品类(炒河粉)的话,就需要定义更多的子类。

    • 产生过多的子类

    定义:

    ​ 指在不改变现有对象结构的情况下,动态地给该对象增加一些职责(即增加其额外功能)的模式。

    5.3.2、结构

    装饰(Decorator)模式中的角色:

    • 抽象构件(Component)角色 :定义一个抽象接口以规范准备接收附加责任的对象。
    • 具体构件(Concrete Component)角色 :实现抽象构件,通过装饰角色为其添加一些职责。
    • 抽象装饰(Decorator)角色 : 继承或实现抽象构件,并包含具体构件的实例,可以通过其子类扩展具体构件的功能。
    • 具体装饰(Concrete Decorators)角色 :实现抽象装饰的相关方法,并给具体构件对象添加附加的责任。

    在这里插入图片描述

    5.3.3、案例

    我们使用装饰者模式对快餐店案例进行改进,体会装饰者模式的精髓。

    类图如下:

    在这里插入图片描述

    代码如下:

    //快餐接口
    public abstract class FastFood {
        private float price;
        private String desc;
    
        public FastFood() {
        }
    
        public FastFood(float price, String desc) {
            this.price = price;
            this.desc = desc;
        }
    
        public void setPrice(float price) {
            this.price = price;
        }
    
        public float getPrice() {
            return price;
        }
    
        public String getDesc() {
            return desc;
        }
    
        public void setDesc(String desc) {
            this.desc = desc;
        }
    
        public abstract float cost();  //获取价格
    }
    
    //炒饭
    public class FriedRice extends FastFood {
    
        public FriedRice() {
            super(10, "炒饭");
        }
    
        public float cost() {
            return getPrice();
        }
    }
    
    //炒面
    public class FriedNoodles extends FastFood {
    
        public FriedNoodles() {
            super(12, "炒面");
        }
    
        public float cost() {
            return getPrice();
        }
    }
    
    //配料类
    public abstract class Garnish extends FastFood {
    
        private FastFood fastFood;
    
        public FastFood getFastFood() {
            return fastFood;
        }
    
        public void setFastFood(FastFood fastFood) {
            this.fastFood = fastFood;
        }
    
        public Garnish(FastFood fastFood, float price, String desc) {
            super(price,desc);
            this.fastFood = fastFood;
        }
    }
    
    //鸡蛋配料
    public class Egg extends Garnish {
    
        public Egg(FastFood fastFood) {
            super(fastFood,1,"鸡蛋");
        }
    
        public float cost() {
            return getPrice() + getFastFood().getCost();
        }
    
        @Override
        public String getDesc() {
            return super.getDesc() + getFastFood().getDesc();
        }
    }
    
    //培根配料
    public class Bacon extends Garnish {
    
        public Bacon(FastFood fastFood) {
    
            super(fastFood,2,"培根");
        }
    
        @Override
        public float cost() {
            return getPrice() + getFastFood().getCost();
        }
    
        @Override
        public String getDesc() {
            return super.getDesc() + getFastFood().getDesc();
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            //点一份炒饭
            FastFood food = new FriedRice();
            //花费的价格
            System.out.println(food.getDesc() + " " + food.cost() + "元");
    
            System.out.println("========");
            //点一份加鸡蛋的炒饭
            FastFood food1 = new FriedRice();
    
            food1 = new Egg(food1);
            //花费的价格
            System.out.println(food1.getDesc() + " " + food1.cost() + "元");
    
            System.out.println("========");
            //点一份加培根的炒面
            FastFood food2 = new FriedNoodles();
            food2 = new Bacon(food2);
            //花费的价格
            System.out.println(food2.getDesc() + " " + food2.cost() + "元");
        }
    }
    

    好处:

    • 饰者模式可以带来比继承更加灵活性的扩展功能,使用更加方便,可以通过组合不同的装饰者对象来获取具有不同行为状态的多样化的结果。装饰者模式比继承更具良好的扩展性,完美的遵循开闭原则,继承是静态的附加责任,装饰者则是动态的附加责任。

    • 装饰类和被装饰类可以独立发展,不会相互耦合,装饰模式是继承的一个替代模式,装饰模式可以动态扩展一个实现类的功能。

    5.3.4、使用场景

    • 当不能采用继承的方式对系统进行扩充或者采用继承不利于系统扩展和维护时。

      不能采用继承的情况主要有两类:

      • 第一类是系统中存在大量独立的扩展,为支持每一种组合将产生大量的子类,使得子类数目呈爆炸性增长;
      • 第二类是因为类定义不能继承(如final类)
    • 在不影响其他对象的情况下,以动态、透明的方式给单个对象添加职责。

    • 当对象的功能要求可以动态地添加,也可以再动态地撤销时。

    5.3.5、JDK源码解析

    IO流中的包装类使用到了装饰者模式。BufferedInputStream,BufferedOutputStream,BufferedReader,BufferedWriter。

    我们以BufferedWriter举例来说明,先看看如何使用BufferedWriter

    public class Demo {
        public static void main(String[] args) throws Exception{
            //创建BufferedWriter对象
            //创建FileWriter对象
            FileWriter fw = new FileWriter("C:\\Users\\Think\\Desktop\\a.txt");
            BufferedWriter bw = new BufferedWriter(fw);
    
            //写数据
            bw.write("hello Buffered");
    
            bw.close();
        }
    }
    

    使用起来感觉确实像是装饰者模式,接下来看它们的结构:

    在这里插入图片描述

    小结:

    ​ BufferedWriter使用装饰者模式对Writer子实现类进行了增强,添加了缓冲区,提高了写数据的效率。

    5.3.6、代理和装饰者的区别

    静态代理和装饰者模式的区别:

    • 相同点:
      • 都要实现与目标类相同的业务接口
      • 在两个类中都要声明目标对象
      • 都可以在不修改目标类的前提下增强目标方法
    • 不同点:
      • 目的不同
        • 装饰者是为了增强目标对象
        • 静态代理是为了保护和隐藏目标对象
      • 获取目标对象构建的地方不同
        • 装饰者是由外界传递进来,可以通过构造方法传递
        • 静态代理是在代理类内部创建,以此来隐藏目标对象

    5.4、桥接模式

    5.4.1、概述

    现在有一个需求,需要创建不同的图形,并且每个图形都有可能会有不同的颜色。我们可以利用继承的方式来设计类的关系:

    在这里插入图片描述

    我们可以发现有很多的类,假如我们再增加一个形状或再增加一种颜色,就需要创建更多的类。

    试想,在一个有多种可能会变化的维度的系统中,用继承方式会造成类爆炸,扩展起来不灵活。每次在一个维度上新增一个具体实现都要增加多个子类。为了更加灵活的设计系统,我们此时可以考虑使用桥接模式。

    定义:

    ​ 将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合度。

    5.4.2、结构

    桥接(Bridge)模式包含以下主要角色:

    • 抽象化(Abstraction)角色 :定义抽象类,并包含一个对实现化对象的引用。
    • 扩展抽象化(Refined Abstraction)角色 :是抽象化角色的子类,实现父类中的业务方法,并通过组合关系调用实现化角色中的业务方法。
    • 实现化(Implementor)角色 :定义实现化角色的接口,供扩展抽象化角色调用。
    • 具体实现化(Concrete Implementor)角色 :给出实现化角色接口的具体实现。

    在这里插入图片描述

    5.4.3、案例

    【例】视频播放器

    需要开发一个跨平台视频播放器,可以在不同操作系统平台(如Windows、Mac、Linux等)上播放多种格式的视频文件,常见的视频格式包括RMVB、AVI、WMV等。该播放器包含了两个维度,适合使用桥接模式。

    类图如下:

    在这里插入图片描述

    代码如下:

    //视频文件
    public interface VideoFile {
        void decode(String fileName);
    }
    
    //avi文件
    public class AVIFile implements VideoFile {
        public void decode(String fileName) {
            System.out.println("avi视频文件:"+ fileName);
        }
    }
    
    //rmvb文件
    public class REVBBFile implements VideoFile {
    
        public void decode(String fileName) {
            System.out.println("rmvb文件:" + fileName);
        }
    }
    
    //操作系统版本
    public abstract class OperatingSystemVersion {
    
        protected VideoFile videoFile;
    
        public OperatingSystemVersion(VideoFile videoFile) {
            this.videoFile = videoFile;
        }
    
        public abstract void play(String fileName);
    }
    
    //Windows版本
    public class Windows extends OperatingSystem {
    
        public Windows(VideoFile videoFile) {
            super(videoFile);
        }
    
        public void play(String fileName) {
            videoFile.decode(fileName);
        }
    }
    
    //mac版本
    public class Mac extends OperatingSystemVersion {
    
        public Mac(VideoFile videoFile) {
            super(videoFile);
        }
    
        public void play(String fileName) {
    		videoFile.decode(fileName);
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            OperatingSystem os = new Windows(new AVIFile());
            os.play("战狼3");
        }
    }
    

    好处:

    • 桥接模式提高了系统的可扩充性,在两个变化维度中任意扩展一个维度,都不需要修改原有系统。

      如:如果现在还有一种视频文件类型wmv,我们只需要再定义一个类实现VideoFile接口即可,其他类不需要发生变化。

    • 实现细节对客户透明

    5.4.4、使用场景

    • 当一个类存在两个独立变化的维度,且这两个维度都需要进行扩展时。
    • 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。
    • 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。避免在两个层次之间建立静态的继承联系,通过桥接模式可以使它们在抽象层建立一个关联关系。

    5.5、外观模式

    门面模式

    5.5.1、概述

    有些人可能炒过股票,但其实大部分人都不太懂,这种没有足够了解证券知识的情况下做股票是很容易亏钱的,刚开始炒股肯定都会想,如果有个懂行的帮帮手就好,其实基金就是个好帮手,支付宝里就有许多的基金,它将投资者分散的资金集中起来,交由专业的经理人进行管理,投资于股票、债券、外汇等领域,而基金投资的收益归持有者所有,管理机构收取一定比例的托管管理费用。

    定义:

    ​ 又名门面模式,是一种通过为多个复杂的子系统提供一个一致的接口,而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口,外部应用程序不用关心内部子系统的具体的细节,这样会大大降低应用程序的复杂度,提高了程序的可维护性。

    ​ 外观(Facade)模式是“迪米特法则”的典型应用

    在这里插入图片描述

    5.5.2、结构

    外观(Facade)模式包含以下主要角色:

    • 外观(Facade)角色:为多个子系统对外提供一个共同的接口。
    • 子系统(Sub System)角色:实现系统的部分功能,客户可以通过外观角色访问它。

    在这里插入图片描述

    5.5.3、案例

    【例】智能家电控制

    小明的爷爷已经60岁了,一个人在家生活:每次都需要打开灯、打开电视、打开空调;睡觉时关闭灯、关闭电视、关闭空调;操作起来都比较麻烦。所以小明给爷爷买了智能音箱,可以通过语音直接控制这些智能家电的开启和关闭。类图如下:

    在这里插入图片描述

    代码如下:

    //灯类
    public class Light {
        public void on() {
            System.out.println("打开了灯....");
        }
    
        public void off() {
            System.out.println("关闭了灯....");
        }
    }
    
    //电视类
    public class TV {
        public void on() {
            System.out.println("打开了电视....");
        }
    
        public void off() {
            System.out.println("关闭了电视....");
        }
    }
    
    //控制类
    public class AirCondition {
        public void on() {
            System.out.println("打开了空调....");
        }
    
        public void off() {
            System.out.println("关闭了空调....");
        }
    }
    
    //智能音箱
    public class SmartAppliancesFacade {
    
        private Light light;
        private TV tv;
        private AirCondition airCondition;
    
        public SmartAppliancesFacade() {
            light = new Light();
            tv = new TV();
            airCondition = new AirCondition();
        }
    
        public void say(String message) {
            if(message.contains("打开")) {
                on();
            } else if(message.contains("关闭")) {
                off();
            } else {
                System.out.println("我还听不懂你说的!!!");
            }
        }
    
        //起床后一键开电器
        private void on() {
            System.out.println("起床了");
            light.on();
            tv.on();
            airCondition.on();
        }
    
        //睡觉一键关电器
        private void off() {
            System.out.println("睡觉了");
            light.off();
            tv.off();
            airCondition.off();
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            //创建外观对象
            SmartAppliancesFacade facade = new SmartAppliancesFacade();
            //客户端直接与外观对象进行交互
            facade.say("打开家电");
            facade.say("关闭家电");
        }
    }
    

    好处:

    • 降低了子系统与客户端之间的耦合度,使得子系统的变化不会影响调用它的客户类。
    • 对客户屏蔽了子系统组件,减少了客户处理的对象数目,并使得子系统使用起来更加容易。

    缺点:

    • 不符合开闭原则,修改很麻烦

    5.5.4、使用场景

    • 对分层结构系统构建时,使用外观模式定义子系统中每层的入口点可以简化子系统之间的依赖关系。
    • 当一个复杂系统的子系统很多时,外观模式可以为系统设计一个简单的接口供外界访问。
    • 当客户端与多个子系统之间存在很大的联系时,引入外观模式可将它们分离,从而提高子系统的独立性和可移植性。

    5.5.5、源码解析

    使用tomcat作为web容器时,接收浏览器发送过来的请求,tomcat会将请求信息封装成ServletRequest对象,如下图①处对象。但是大家想想ServletRequest是一个接口,它还有一个子接口HttpServletRequest,而我们知道该request对象肯定是一个HttpServletRequest对象的子实现类对象,到底是哪个类的对象呢?可以通过输出request对象,我们就会发现是一个名为RequestFacade的类的对象。

    在这里插入图片描述

    RequestFacade类就使用了外观模式。先看结构图:

    在这里插入图片描述

    为什么在此处使用外观模式呢?

    ​ 定义 RequestFacade 类,分别实现 ServletRequest ,同时定义私有成员变量 Request ,并且方法的实现调用 Request 的实现。然后,将 RequestFacade 上转为 ServletRequest 传给 servlet 的 service 方法,这样即使在 servlet 中被下转为 RequestFacade ,也不能访问私有成员变量对象中的方法。既用了 Request ,又能防止其中方法被不合理的访问。

    5.6、组合模式

    5.6.1、概述

    在这里插入图片描述

    ​ 对于这个图片肯定会非常熟悉,上图我们可以看做是一个文件系统,对于这样的结构我们称之为树形结构。在树形结构中可以通过调用某个方法来遍历整个树,当我们找到某个叶子节点后,就可以对叶子节点进行相关的操作。可以将这颗树理解成一个大的容器,容器里面包含很多的成员对象,这些成员对象即可是容器对象也可以是叶子对象。但是由于容器对象和叶子对象在功能上面的区别,使得我们在使用的过程中必须要区分容器对象和叶子对象,但是这样就会给客户带来不必要的麻烦,作为客户而已,它始终希望能够一致的对待容器对象和叶子对象。

    定义:

    ​ 又名部分整体模式,是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象,用来表示部分以及整体层次。这种类型的设计模式属于结构型模式,它创建了对象组的树形结构。

    5.6.2、结构

    组合模式主要包含三种角色:

    • 抽象根节点(Component):定义系统各层次对象的共有方法和属性,可以预先定义一些默认行为和属性。
    • 树枝节点(Composite):定义树枝节点的行为,存储子节点,组合树枝节点和叶子节点形成一个树形结构。
    • 叶子节点(Leaf):叶子节点对象,其下再无分支,是系统层次遍历的最小单位。

    在这里插入图片描述

    5.6.3、案例

    【例】软件菜单

    如下图,我们在访问别的一些管理系统时,经常可以看到类似的菜单。一个菜单可以包含菜单项(菜单项是指不再包含其他内容的菜单条目),也可以包含带有其他菜单项的菜单,因此使用组合模式描述菜单就很恰当,我们的需求是针对一个菜单,打印出其包含的所有菜单以及菜单项的名称。

    在这里插入图片描述

    要实现该案例,我们先画出类图:

    在这里插入图片描述

    代码实现:

    不管是菜单还是菜单项,都应该继承自统一的接口,这里姑且将这个统一的接口称为菜单组件。

    //菜单组件  不管是菜单还是菜单项,都应该继承该类
    public abstract class MenuComponent {
    
        protected String name;
        protected int level;
    
        //添加菜单
        public void add(MenuComponent menuComponent){
            throw new UnsupportedOperationException();
        }
    
        //移除菜单
        public void remove(MenuComponent menuComponent){
            throw new UnsupportedOperationException();
        }
    
        //获取指定的子菜单
        public MenuComponent getChild(int i){
            throw new UnsupportedOperationException();
        }
    
        //获取菜单名称
        public String getName(){
            return name;
        }
    
        public void print(){
            throw new UnsupportedOperationException();
        }
    }
    

    这里的MenuComponent定义为抽象类,因为有一些共有的属性和行为要在该类中实现,Menu和MenuItem类就可以只覆盖自己感兴趣的方法,而不用搭理不需要或者不感兴趣的方法,举例来说,Menu类可以包含子菜单,因此需要覆盖add()、remove()、getChild()方法,但是MenuItem就不应该有这些方法。这里给出的默认实现是抛出异常,你也可以根据自己的需要改写默认实现。

    public class Menu extends MenuComponent {
    
        private List<MenuComponent> menuComponentList;
    
        public Menu(String name,int level){
            this.level = level;
            this.name = name;
            menuComponentList = new ArrayList<MenuComponent>();
        }
    
        @Override
        public void add(MenuComponent menuComponent) {
            menuComponentList.add(menuComponent);
        }
    
        @Override
        public void remove(MenuComponent menuComponent) {
            menuComponentList.remove(menuComponent);
        }
    
        @Override
        public MenuComponent getChild(int i) {
            return menuComponentList.get(i);
        }
    
        @Override
        public void print() {
    
            for (int i = 1; i < level; i++) {
                System.out.print("--");
            }
            System.out.println(name);
            for (MenuComponent menuComponent : menuComponentList) {
                menuComponent.print();
            }
        }
    }
    

    Menu类已经实现了除了getName方法的其他所有方法,因为Menu类具有添加菜单,移除菜单和获取子菜单的功能。

    public class MenuItem extends MenuComponent {
    
        public MenuItem(String name,int level) {
            this.name = name;
            this.level = level;
        }
    
        @Override
        public void print() {
            for (int i = 1; i < level; i++) {
                System.out.print("--");
            }
            System.out.println(name);
        }
    }
    

    MenuItem是菜单项,不能再有子菜单,所以添加菜单,移除菜单和获取子菜单的功能并不能实现。

    5.6.4、组合模式的分类

    在使用组合模式时,根据抽象构件类的定义形式,我们可将组合模式分为透明组合模式和安全组合模式两种形式。

    • 透明组合模式

      透明组合模式中,抽象根节点角色中声明了所有用于管理成员对象的方法,比如在示例中 MenuComponent 声明了 addremovegetChild 方法,这样做的好处是确保所有的构件类都有相同的接口。透明组合模式也是组合模式的标准形式。

      透明组合模式的缺点是不够安全,因为叶子对象和容器对象在本质上是有区别的,叶子对象不可能有下一个层次的对象,即不可能包含成员对象,因此为其提供 add()、remove() 等方法是没有意义的,这在编译阶段不会出错,但在运行阶段如果调用这些方法可能会出错(如果没有提供相应的错误处理代码)

    • 安全组合模式

      在安全组合模式中,在抽象构件角色中没有声明任何用于管理成员对象的方法,而是在树枝节点 Menu 类中声明并实现这些方法。安全组合模式的缺点是不够透明,因为叶子构件和容器构件具有不同的方法,且容器构件中那些用于管理成员对象的方法没有在抽象构件类中定义,因此客户端不能完全针对抽象编程,必须有区别地对待叶子构件和容器构件。

      在这里插入图片描述

    5.6.5、优点

    • 组合模式可以清楚地定义分层次的复杂对象,表示对象的全部或部分层次,它让客户端忽略了层次的差异,方便对整个层次结构进行控制。
    • 客户端可以一致地使用一个组合结构或其中单个对象,不必关心处理的是单个对象还是整个组合结构,简化了客户端代码。
    • 在组合模式中增加新的树枝节点和叶子节点都很方便,无须对现有类库进行任何修改,符合“开闭原则”。
    • 组合模式为树形结构的面向对象实现提供了一种灵活的解决方案,通过叶子节点和树枝节点的递归组合,可以形成复杂的树形结构,但对树形结构的控制却非常简单。

    5.6.6、使用场景

    组合模式正是应树形结构而生,所以组合模式的使用场景就是出现树形结构的地方。比如:文件目录显示,多级目录呈现等树形结构数据的操作。

    5.7、享元模式

    5.7.1、概述

    定义:

    ​ 运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似对象的开销,从而提高系统资源的利用率。

    5.7.2、 结构

    享元(Flyweight )模式中存在以下两种状态:

    1. 内部状态,即不会随着环境的改变而改变的可共享部分。
    2. 外部状态,指随环境改变而改变的不可以共享的部分。享元模式的实现要领就是区分应用中的这两种状态,并将外部状态外部化。

    享元模式的主要有以下角色:

    • 抽象享元角色(Flyweight):通常是一个接口或抽象类,在抽象享元类中声明了具体享元类公共的方法,这些方法可以向外界提供享元对象的内部数据(内部状态),同时也可以通过这些方法来设置外部数据(外部状态)。
    • 具体享元(Concrete Flyweight)角色 :它实现了抽象享元类,称为享元对象;在具体享元类中为内部状态提供了存储空间。通常我们可以结合单例模式来设计具体享元类,为每一个具体享元类提供唯一的享元对象。
    • 非享元(Unsharable Flyweight)角色 :并不是所有的抽象享元类的子类都需要被共享,不能被共享的子类可设计为非共享具体享元类;当需要一个非共享具体享元类的对象时可以直接通过实例化创建。
    • 享元工厂(Flyweight Factory)角色 :负责创建和管理享元角色。当客户对象请求一个享元对象时,享元工厂检査系统中是否存在符合要求的享元对象,如果存在则提供给客户;如果不存在的话,则创建一个新的享元对象。

    在这里插入图片描述

    5.7.3、案例实现

    【例】俄罗斯方块

    下面的图片是众所周知的俄罗斯方块中的一个个方块,如果在俄罗斯方块这个游戏中,每个不同的方块都是一个实例对象,这些对象就要占用很多的内存空间,下面利用享元模式进行实现。

    在这里插入图片描述

    先来看类图:

    在这里插入图片描述

    代码如下:

    俄罗斯方块有不同的形状,我们可以对这些形状向上抽取出AbstractBox,用来定义共性的属性和行为。

    public abstract class AbstractBox {
        public abstract String getShape();
    
        public void display(String color) {
            System.out.println("方块形状:" + this.getShape() + " 颜色:" + color);
        }
    }
    

    接下来就是定义不同的形状了,IBox类、LBox类、OBox类等。

    public class IBox extends AbstractBox {
    
        @Override
        public String getShape() {
            return "I";
        }
    }
    
    public class LBox extends AbstractBox {
    
        @Override
        public String getShape() {
            return "L";
        }
    }
    
    public class OBox extends AbstractBox {
    
        @Override
        public String getShape() {
            return "O";
        }
    }
    

    提供了一个工厂类(BoxFactory),用来管理享元对象(也就是AbstractBox子类对象),该工厂类对象只需要一个,所以可以使用单例模式。并给工厂类提供一个获取形状的方法。

    public class BoxFactory {
    
        private static HashMap<String, AbstractBox> map;
    
        private BoxFactory() {
            map = new HashMap<String, AbstractBox>();
            AbstractBox iBox = new IBox();
            AbstractBox lBox = new LBox();
            AbstractBox oBox = new OBox();
            map.put("I", iBox);
            map.put("L", lBox);
            map.put("O", oBox);
        }
    
        public static final BoxFactory getInstance() {
            return SingletonHolder.INSTANCE;
        }
    
        private static class SingletonHolder {
            private static final BoxFactory INSTANCE = new BoxFactory();
        }
    
        public AbstractBox getBox(String key) {
            return map.get(key);
        }
    }
    

    测试

    public class Client {
       public static void main(String[] args) {
          AbstractBox box1 = BoxFacotry.getInstance().getShape("I");
          box1.display("灰色");
    
          AbstractBox box2 = BoxFacotry.getInstance().getShape("L");
          box2.display("绿色");
    
          AbstractBox box3 = BoxFacotry.getInstance().getShape("O");
          box3.display("绿色");
    
          AbstractBox box4 = BoxFacotry.getInstance().getShape("O");
          box4.display("红色");
    
          System.out.println("两次获取到的O图像对象是否是同一个对象:" + (box3 == box4));
       }
    }
    

    在这里插入图片描述

    5.7.5、优缺点和使用场景

    1,优点

    • 极大减少内存中相似或相同对象数量,节约系统资源,提供系统性能
    • 享元模式中的外部状态相对独立,且不影响内部状态

    2,缺点:

    为了使对象可以共享,需要将享元对象的部分状态外部化,分离内部状态和外部状态,使程序逻辑复杂

    3,使用场景:

    • 一个系统有大量相同或者相似的对象,造成内存的大量耗费。
    • 对象的大部分状态都可以外部化,可以将这些外部状态传入对象中。
    • 在使用享元模式时需要维护一个存储享元对象的享元池,而这需要耗费一定的系统资源,因此,应当在需要多次重复使用享元对象时才值得使用享元模式。

    5.7.6、JDK源码解析

    Integer类使用了享元模式。我们先看下面的例子:

    public class Demo {
        public static void main(String[] args) {
            Integer i1 = 127;
            Integer i2 = 127;
    
            System.out.println("i1和i2对象是否是同一个对象?" + (i1 == i2));
    
            Integer i3 = 128;
            Integer i4 = 128;
    
            System.out.println("i3和i4对象是否是同一个对象?" + (i3 == i4));
        }
    }
    

    运行上面代码,结果如下:

    在这里插入图片描述

    为什么第一个输出语句输出的是true,第二个输出语句输出的是false?通过反编译软件进行反编译,代码如下:

    public class Demo {
        public static void main(String[] args) {
            Integer i1 = Integer.valueOf((int)127);
            Integer i2 Integer.valueOf((int)127);
            System.out.println((String)new StringBuilder().append((String)"i1\u548ci2\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i1 == i2)).toString());
            Integer i3 = Integer.valueOf((int)128);
            Integer i4 = Integer.valueOf((int)128);
            System.out.println((String)new StringBuilder().append((String)"i3\u548ci4\u5bf9\u8c61\u662f\u5426\u662f\u540c\u4e00\u4e2a\u5bf9\u8c61\uff1f").append((boolean)(i3 == i4)).toString());
        }
    }
    

    上面代码可以看到,直接给Integer类型的变量赋值基本数据类型数据的操作底层使用的是 valueOf() ,所以只需要看该方法即可

    public final class Integer extends Number implements Comparable<Integer> {
        
    	public static Integer valueOf(int i) {
            if (i >= IntegerCache.low && i <= IntegerCache.high)
                return IntegerCache.cache[i + (-IntegerCache.low)];
            return new Integer(i);
        }
        
        private static class IntegerCache {
            static final int low = -128;
            static final int high;
            static final Integer cache[];
    
            static {
                int h = 127;
                String integerCacheHighPropValue =
                    sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
                if (integerCacheHighPropValue != null) {
                    try {
                        int i = parseInt(integerCacheHighPropValue);
                        i = Math.max(i, 127);
                        // Maximum array size is Integer.MAX_VALUE
                        h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
                    } catch( NumberFormatException nfe) {
                    }
                }
                high = h;
                cache = new Integer[(high - low) + 1];
                int j = low;
                for(int k = 0; k < cache.length; k++)
                    cache[k] = new Integer(j++);
                // range [-128, 127] must be interned (JLS7 5.1.7)
                assert IntegerCache.high >= 127;
            }
    
            private IntegerCache() {}
        }
    }
    

    可以看到 Integer 默认先创建并缓存 -128 ~ 127 之间数的 Integer 对象,当调用 valueOf 时如果参数在 -128 ~ 127 之间则计算下标并从缓存中返回,否则创建一个新的 Integer 对象。

    六,行为型模式

    行为型模式用于描述程序在运行时复杂的流程控制,即描述多个类或对象之间怎样相互协作共同完成单个对象都无法单独完成的任务,它涉及算法与对象间职责的分配。

    行为型模式分为类行为模式和对象行为模式,前者采用继承机制来在类间分派行为,后者采用组合或聚合在对象间分配行为。由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象行为模式比类行为模式具有更大的灵活性。

    行为型模式分为:

    • 模板方法模式
    • 策略模式
    • 命令模式
    • 职责链模式
    • 状态模式
    • 观察者模式
    • 中介者模式
    • 迭代器模式
    • 访问者模式
    • 备忘录模式
    • 解释器模式

    以上 11 种行为型模式,除了模板方法模式和解释器模式是类行为型模式,其他的全部属于对象行为型模式。

    6.1、模板方法模式

    6.1.1、概述

    在面向对象程序设计过程中,程序员常常会遇到这种情况:设计一个系统时知道了算法所需的关键步骤,而且确定了这些步骤的执行顺序,但某些步骤的具体实现还未知,或者说某些步骤的实现与具体的环境相关。

    例如,去银行办理业务一般要经过以下4个流程:取号、排队、办理具体业务、对银行工作人员进行评分等,其中取号、排队和对银行工作人员进行评分的业务对每个客户是一样的,可以在父类中实现,但是办理具体业务却因人而异,它可能是存款、取款或者转账等,可以延迟到子类中实现。

    定义:

    定义一个操作中的算法骨架,而将算法的一些步骤延迟到子类中,使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。

    6.1.2 结构

    模板方法(Template Method)模式包含以下主要角色:

    • 抽象类(Abstract Class):负责给出一个算法的轮廓和骨架。它由一个模板方法和若干个基本方法构成。

      • 模板方法:定义了算法的骨架,按某种顺序调用其包含的基本方法。

      • 基本方法:是实现算法各个步骤的方法,是模板方法的组成部分。基本方法又可以分为三种:

        • 抽象方法(Abstract Method) :一个抽象方法由抽象类声明、由其具体子类实现。

        • 具体方法(Concrete Method) :一个具体方法由一个抽象类或具体类声明并实现,其子类可以进行覆盖也可以直接继承。

        • 钩子方法(Hook Method) :在抽象类中已经实现,包括用于判断的逻辑方法和需要子类重写的空方法两种。

          一般钩子方法是用于判断的逻辑方法,这类方法名一般为isXxx,返回值类型为boolean类型。

    • 具体子类(Concrete Class):实现抽象类中所定义的抽象方法和钩子方法,它们是一个顶级逻辑的组成步骤。

    在这里插入图片描述

    6.1.3、案例

    【例】炒菜

    炒菜的步骤是固定的,分为倒油、热油、倒蔬菜、倒调料品、翻炒等步骤。现通过模板方法模式来用代码模拟。类图如下:

    在这里插入图片描述

    代码如下:

    public abstract class AbstractClass {
        
        public final void cookProcess() {
            //第一步:倒油
            this.pourOil();
            //第二步:热油
            this.heatOil();
            //第三步:倒蔬菜
            this.pourVegetable();
            //第四步:倒调味料
            this.pourSauce();
            //第五步:翻炒
            this.fry();
        }
    
        public void pourOil() {
            System.out.println("倒油");
        }
    
        //第二步:热油是一样的,所以直接实现
        public void heatOil() {
            System.out.println("热油");
        }
    
        //第三步:倒蔬菜是不一样的(一个下包菜,一个是下菜心)
        public abstract void pourVegetable();
    
        //第四步:倒调味料是不一样
        public abstract void pourSauce();
    
    
        //第五步:翻炒是一样的,所以直接实现
        public void fry(){
            System.out.println("炒啊炒啊炒到熟啊");
        }
    }
    
    public class ConcreteClass_BaoCai extends AbstractClass {
    
        @Override
        public void pourVegetable() {
            System.out.println("下锅的蔬菜是包菜");
        }
    
        @Override
        public void pourSauce() {
            System.out.println("下锅的酱料是辣椒");
        }
    }
    
    public class ConcreteClass_CaiXin extends AbstractClass {
        @Override
        public void pourVegetable() {
            System.out.println("下锅的蔬菜是菜心");
        }
    
        @Override
        public void pourSauce() {
            System.out.println("下锅的酱料是蒜蓉");
        }
    }
    
    public class Client {
        public static void main(String[] args) {
            //炒手撕包菜
            ConcreteClass_BaoCai baoCai = new ConcreteClass_BaoCai();
            baoCai.cookProcess();
    
            //炒蒜蓉菜心
            ConcreteClass_CaiXin caiXin = new ConcreteClass_CaiXin();
            caiXin.cookProcess();
        }
    }
    

    注意:为防止恶意操作,一般模板方法都加上 final 关键词。

    6.1.3、优缺点

    优点:

    • 提高代码复用性

      将相同部分的代码放在抽象的父类中,而将不同的代码放入不同的子类中。

    • 实现了反向控制

      通过一个父类调用其子类的操作,通过对子类的具体实现扩展不同的行为,实现了反向控制 ,并符合“开闭原则”。

    缺点:

    • 对每个不同的实现都需要定义一个子类,这会导致类的个数增加,系统更加庞大,设计也更加抽象。
    • 父类中的抽象方法由子类实现,子类执行的结果会影响父类的结果,这导致一种反向的控制结构,它提高了代码阅读的难度。

    6.1.4、适用场景

    • 算法的整体步骤很固定,但其中个别部分易变时,这时候可以使用模板方法模式,将容易变的部分抽象出来,供子类实现。
    • 需要通过子类来决定父类算法中某个步骤是否执行,实现子类对父类的反向控制。

    6.1.5、JDK源码解析

    InputStream类就使用了模板方法模式。在InputStream类中定义了多个 read() 方法,如下:

    public abstract class InputStream implements Closeable {
        //抽象方法,要求子类必须重写
        public abstract int read() throws IOException;
    
        public int read(byte b[]) throws IOException {
            return read(b, 0, b.length);
        }
    
        public int read(byte b[], int off, int len) throws IOException {
            if (b == null) {
                throw new NullPointerException();
            } else if (off < 0 || len < 0 || len > b.length - off) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return 0;
            }
    
            int c = read(); //调用了无参的read方法,该方法是每次读取一个字节数据
            if (c == -1) {
                return -1;
            }
            b[off] = (byte)c;
    
            int i = 1;
            try {
                for (; i < len ; i++) {
                    c = read();
                    if (c == -1) {
                        break;
                    }
                    b[off + i] = (byte)c;
                }
            } catch (IOException ee) {
            }
            return i;
        }
    }
    

    从上面代码可以看到,无参的 read() 方法是抽象方法,要求子类必须实现。而 read(byte b[]) 方法调用了 read(byte b[], int off, int len) 方法,所以在此处重点看的方法是带三个参数的方法。

    在该方法中第18行、27行,可以看到调用了无参的抽象的 read() 方法。

    总结如下: 在InputStream父类中已经定义好了读取一个字节数组数据的方法是每次读取一个字节,并将其存储到数组的第一个索引位置,读取len个字节数据。具体如何读取一个字节数据呢?由子类实现。

    6.2、策略模式

    6.2.1、概述

    假如你需要前往机场。 你可以选择乘坐公共汽车、 预约出租车或骑自行车。 这些就是你的出行策略。

    在这里插入图片描述

    作为一个程序猿,开发需要选择一款开发工具,当然可以进行代码开发的工具有很多,可以选择Idea进行开发,也可以使用eclipse进行开发,也可以使用其他的一些开发工具。

    在这里插入图片描述

    定义:

    ​ 该模式定义了一系列算法,并将每个算法封装起来,使它们可以相互替换,且算法的变化不会影响使用算法的客户。策略模式属于对象行为模式,它通过对算法进行封装,把使用算法的责任和算法的实现分割开来,并委派给不同的对象对这些算法进行管理。

    6.2.2、结构

    策略模式的主要角色如下:

    • 抽象策略(Strategy)类:这是一个抽象角色,通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。
    • 具体策略(Concrete Strategy)类:实现了抽象策略定义的接口,提供具体的算法实现或行为。
    • 环境(Context)类:持有一个策略类的引用,最终给客户端调用。

    在这里插入图片描述

    6.2.3、案例实现

    【例】促销活动

    一家百货公司在定年度的促销活动。针对不同的节日(春节、中秋节、圣诞节)推出不同的促销活动,由促销员将促销活动展示给客户。类图如下:

    在这里插入图片描述

    代码如下:

    定义百货公司所有促销活动的共同接口

    public interface Strategy {
        void show();
    }
    

    定义具体策略角色(Concrete Strategy):每个节日具体的促销活动

    //为春节准备的促销活动A
    public class StrategyA implements Strategy {
        @Override
        public void show() {
            System.out.println("买一送一");
        }
    }
    
    //为中秋准备的促销活动B
    public class StrategyB implements Strategy {
        @Override
        public void show() {
            System.out.println("满200元减50元");
        }
    }
    
    //为圣诞准备的促销活动C
    public class StrategyC implements Strategy {
        @Override
        public void show() {
            System.out.println("满1000元加一元换购任意200元以下商品");
        }
    }
    

    定义环境角色(Context):用于连接上下文,即把促销活动推销给客户,这里可以理解为销售员

    public class SalesMan {                        
        //持有抽象策略角色的引用                              
        private Strategy strategy;                 
    
        public SalesMan(Strategy strategy) {       
            this.strategy = strategy;              
        }                                          
    
        //向客户展示促销活动
        public void salesManShow(){                
            strategy.show();                       
        }                                          
    }                                              
    

    6.2.4、优缺点

    1,优点:

    • 策略类之间可以自由切换

      由于策略类都实现同一个接口,所以使它们之间可以自由切换。

    • 易于扩展

      增加一个新的策略只需要添加一个具体的策略类即可,基本不需要改变原有的代码,符合“开闭原则“

    • 避免使用多重条件选择语句(if else),充分体现面向对象设计思想。

    2,缺点:

    • 客户端必须知道所有的策略类,并自行决定使用哪一个策略类。
    • 策略模式将造成产生很多策略类,可以通过使用享元模式在一定程度上减少对象的数量。

    6.2.5、使用场景

    • 一个系统需要动态地在几种算法中选择一种时,可将每个算法封装到策略类中。
    • 一个类定义了多种行为,并且这些行为在这个类的操作中以多个条件语句的形式出现,可将每个条件分支移入它们各自的策略类中以代替这些条件语句。
    • 系统中各算法彼此完全独立,且要求对客户隐藏具体算法的实现细节时。
    • 系统要求使用算法的客户不应该知道其操作的数据时,可使用策略模式来隐藏与算法相关的数据结构。
    • 多个类只区别在表现行为不同,可以使用策略模式,在运行时动态选择具体要执行的行为。

    6.2.6、JDK源码解析

    Comparator 中的策略模式。在Arrays类中有一个 sort() 方法,如下:

    public class Arrays{
        public static <T> void sort(T[] a, Comparator<? super T> c) {
            if (c == null) {
                sort(a);
            } else {
                if (LegacyMergeSort.userRequested)
                    legacyMergeSort(a, c);
                else
                    TimSort.sort(a, 0, a.length, c, null, 0, 0);
            }
        }
    }
    

    Arrays就是一个环境角色类,这个sort方法可以传一个新策略让Arrays根据这个策略来进行排序。就比如下面的测试类。

    public class demo {
        public static void main(String[] args) {
    
            Integer[] data = {12, 2, 3, 2, 4, 5, 1};
            // 实现降序排序
            Arrays.sort(data, new Comparator<Integer>() {
                public int compare(Integer o1, Integer o2) {
                    return o2 - o1;
                }
            });
            System.out.println(Arrays.toString(data)); //[12, 5, 4, 3, 2, 2, 1]
        }
    }
    

    这里我们在调用Arrays的sort方法时,第二个参数传递的是Comparator接口的子实现类对象。所以Comparator充当的是抽象策略角色,而具体的子实现类充当的是具体策略角色。环境角色类(Arrays)应该持有抽象策略的引用来调用。那么,Arrays类的sort方法到底有没有使用Comparator子实现类中的 compare() 方法吗?让我们继续查看TimSort类的 sort() 方法,代码如下:

    class TimSort<T> {
        static <T> void sort(T[] a, int lo, int hi, Comparator<? super T> c,
                             T[] work, int workBase, int workLen) {
            assert c != null && a != null && lo >= 0 && lo <= hi && hi <= a.length;
    
            int nRemaining  = hi - lo;
            if (nRemaining < 2)
                return;  // Arrays of size 0 and 1 are always sorted
    
            // If array is small, do a "mini-TimSort" with no merges
            if (nRemaining < MIN_MERGE) {
                int initRunLen = countRunAndMakeAscending(a, lo, hi, c);
                binarySort(a, lo, hi, lo + initRunLen, c);
                return;
            }
            ...
        }   
            
        private static <T> int countRunAndMakeAscending(T[] a, int lo, int hi,Comparator<? super T> c) {
            assert lo < hi;
            int runHi = lo + 1;
            if (runHi == hi)
                return 1;
    
            // Find end of run, and reverse range if descending
            if (c.compare(a[runHi++], a[lo]) < 0) { // Descending
                while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) < 0)
                    runHi++;
                reverseRange(a, lo, runHi);
            } else {                              // Ascending
                while (runHi < hi && c.compare(a[runHi], a[runHi - 1]) >= 0)
                    runHi++;
            }
    
            return runHi - lo;
        }
    }
    

    上面的代码中最终会跑到 countRunAndMakeAscending() 这个方法中。我们可以看见,只用了compare方法,所以在调用Arrays.sort方法只传具体compare重写方法的类对象就行,这也是Comparator接口中必须要子类实现的一个方法。

    6.3、命令模式

    6.3.1、概述

    在市中心逛了很久的街后, 你找到了一家不错的餐厅, 坐在了临窗的座位上。 一名友善的服务员走近你, 迅速记下你点的食物, 写在一张纸上。 服务员来到厨房, 把订单贴在墙上。 过了一段时间, 厨师拿到了订单, 他根据订单来准备食物。 厨师将做好的食物和订单一起放在托盘上。 服务员看到托盘后对订单进行检查, 确保所有食物都是你要的, 然后将食物放到了你的桌上。

    在这里插入图片描述

    那张纸就是一个命令, 它在厨师开始烹饪前一直位于队列中。 命令中包含与烹饪这些食物相关的所有信息。 厨师能够根据它马上开始烹饪, 而无需跑来直接和你确认订单详情。

    定义:

    将一个请求封装为一个对象,使发出请求的责任和执行请求的责任分割开。这样两者之间通过命令对象进行沟通,这样方便将命令对象进行存储、传递、调用、增加与管理。

    6.3.2、结构

    命令模式包含以下主要角色:

    • 抽象命令类(Command)角色: 定义命令的接口,声明执行的方法。
    • 具体命令(Concrete Command)角色:具体的命令,实现命令接口;通常会持有接收者,并调用接收者的功能来完成命令要执行的操作。
    • 实现者/接收者(Receiver)角色: 接收者,真正执行命令的对象。任何类都可能成为一个接收者,只要它能够实现命令要求实现的相应功能。
    • 调用者/请求者(Invoker)角色: 要求命令对象执行请求,通常会持有命令对象,可以持有很多的命令对象。这个是客户端真正触发命令并要求命令执行相应操作的地方,也就是说相当于使用命令对象的入口。

    在这里插入图片描述

    6.3.3、案例实现

    将上面的案例用代码实现,那我们就需要分析命令模式的角色在该案例中由谁来充当。

    服务员: 就是调用者角色,由她来发起命令。

    资深大厨: 就是接收者角色,真正命令执行的对象。

    订单: 命令中包含订单。

    类图如下:

    在这里插入图片描述

    代码如下:

    public interface Command {
        void execute();//只需要定义一个统一的执行方法
    }
    
    public class OrderCommand implements Command {
    
        //持有接受者对象
        private SeniorChef receiver;
        private Order order;
    
        public OrderCommand(SeniorChef receiver, Order order){
            this.receiver = receiver;
            this.order = order;
        }
    
        public void execute()  {
            System.out.println(order.getDiningTable() + "桌的订单:");
            Set<String> keys = order.getFoodDic().keySet();
            for (String key : keys) {
                receiver.makeFood(order.getFoodDic().get(key),key);
            }
    
            try {
                Thread.sleep(100);//停顿一下 模拟做饭的过程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
    
    
            System.out.println(order.getDiningTable() + "桌的饭弄好了");
        }
    }
    
    public class Order {
        // 餐桌号码
        private int diningTable;
    
        // 用来存储餐名并记录份数
        private Map<String, Integer> foodDic = new HashMap<String, Integer>();
    
        public int getDiningTable() {
            return diningTable;
        }
    
        public void setDiningTable(int diningTable) {
            this.diningTable = diningTable;
        }
    
        public Map<String, Integer> getFoodDic() {
            return foodDic;
        }
    
        public void setFoodDic(String name, int num) {
            foodDic.put(name,num);
        }
    }
    
    // 资深大厨类 是命令的Receiver
    public class SeniorChef {
    
        public void makeFood(int num,String foodName) {
            System.out.println(num + "份" + foodName);
        }
    }
    
    public class Waitor {
    
        private ArrayList<Command> commands;//可以持有很多的命令对象
    
        public Waitor() {
            commands = new ArrayList();
        }
        
        public void setCommand(Command cmd){
            commands.add(cmd);
        }
    
        // 发出命令 喊 订单来了,厨师开始执行
        public void orderUp() {
            System.out.println("美女服务员:叮咚,大厨,新订单来了.......");
            for (int i = 0; i < commands.size(); i++) {
                Command cmd = commands.get(i);
                if (cmd != null) {
                    cmd.execute();
                }
            }
        }
    }
    
    public class Client {
        public static void main(String[] args) {
            //创建2个order
            Order order1 = new Order();
            order1.setDiningTable(1);
            order1.getFoodDic().put("西红柿鸡蛋面",1);
            order1.getFoodDic().put("小杯可乐",2);
    
            Order order2 = new Order();
            order2.setDiningTable(3);
            order2.getFoodDic().put("尖椒肉丝盖饭",1);
            order2.getFoodDic().put("小杯雪碧",1);
    
            //创建接收者
            SeniorChef receiver=new SeniorChef();
            //将订单和接收者封装成命令对象
            OrderCommand cmd1 = new OrderCommand(receiver, order1);
            OrderCommand cmd2 = new OrderCommand(receiver, order2);
            //创建调用者 waitor
            Waitor invoker = new Waitor();
            invoker.setCommand(cmd1);
            invoker.setCommand(cmd2);
    
            //将订单带到柜台 并向厨师喊 订单来了
            invoker.orderUp();
        }
    }
    

    6.3.4、优缺点

    1,优点:

    • 降低系统的耦合度。命令模式能将调用操作的对象与实现该操作的对象解耦。
    • 增加或删除命令非常方便。采用命令模式增加与删除命令不会影响其他类,它满足“开闭原则”,对扩展比较灵活。
    • 可以实现宏命令。命令模式可以与组合模式结合,将多个命令装配成一个组合命令,即宏命令。
    • 方便实现 Undo 和 Redo 操作。命令模式可以与后面介绍的备忘录模式结合,实现命令的撤销与恢复。

    2,缺点:

    • 使用命令模式可能会导致某些系统有过多的具体命令类。
    • 系统结构更加复杂。

    6.3.5、使用场景

    • 系统需要将请求调用者和请求接收者解耦,使得调用者和接收者不直接交互。
    • 系统需要在不同的时间指定请求、将请求排队和执行请求。
    • 系统需要支持命令的撤销(Undo)操作和恢复(Redo)操作。

    6.3.6、JDK源码解析

    Runable 是一个典型命令模式,Runnable担当命令的角色,Thread充当的是调用者,start方法就是其执行方法

    //命令接口(抽象命令角色)
    public interface Runnable {
    	public abstract void run();
    }
    
    //调用者
    public class Thread implements Runnable {
        private Runnable target;
        
        public synchronized void start() {
            if (threadStatus != 0)
                throw new IllegalThreadStateException();
    
            group.add(this);
    
            boolean started = false;
            try {
                start0();
                started = true;
            } finally {
                try {
                    if (!started) {
                        group.threadStartFailed(this);
                    }
                } catch (Throwable ignore) {
                }
            }
        }
        
        private native void start0();
    }
    

    会调用一个native 方法 start0(),调用系统方法,开启一个线程。而接收者是对程序员开放的,可以自己定义接收者。

    /**
     * jdk Runnable 命令模式
     *		TurnOffThread : 属于具体命令角色
     */
    public class TurnOffThread implements Runnable{
         private Receiver receiver;
        
         public TurnOffThread(Receiver receiver) {
         	this.receiver = receiver;
         }
         public void run() {
         	receiver.turnOFF();
         }
    }
    
    /**
     * 测试类
     */
    public class Demo {
         public static void main(String[] args) {
             Receiver receiver = new Receiver();
             TurnOffThread turnOffThread = new TurnOffThread(receiver);
             Thread thread = new Thread(turnOffThread);
             thread.start();
         }
    }
    

    6.4、责任链模式

    6.4.1、概述

    在现实生活中,常常会出现这样的事例:一个请求有多个对象可以处理,但每个对象的处理条件或权限不同。例如,公司员工请假,可批假的领导有部门负责人、副总经理、总经理等,但每个领导能批准的天数不同,员工必须根据自己要请假的天数去找不同的领导签名,也就是说员工必须记住每个领导的姓名、电话和地址等信息,这增加了难度。这样的例子还有很多,如找领导出差报销、生活中的“击鼓传花”游戏等。

    定义:

    又名职责链模式,为了避免请求发送者与多个请求处理者耦合在一起,将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链;当有请求发生时,可将请求沿着这条链传递,直到有对象处理它为止。

    6.4.2、结构

    职责链模式主要包含以下角色:

    • 抽象处理者(Handler)角色:定义一个处理请求的接口,包含抽象处理方法和一个后继连接。
    • 具体处理者(Concrete Handler)角色:实现抽象处理者的处理方法,判断能否处理本次请求,如果可以处理请求则处理,否则将该请求转给它的后继者。
    • 客户类(Client)角色:创建处理链,并向链头的具体处理者对象提交请求,它不关心处理细节和请求的传递过程。

    在这里插入图片描述

    6.4.3、案例实现

    现需要开发一个请假流程控制系统。请假一天以下的假只需要小组长同意即可;请假1天到3天的假还需要部门经理同意;请求3天到7天还需要总经理同意才行。

    类图如下:

    在这里插入图片描述

    代码如下:

    //请假条
    public class LeaveRequest {
        private String name;//姓名
        private int num;//请假天数
        private String content;//请假内容
    
        public LeaveRequest(String name, int num, String content) {
            this.name = name;
            this.num = num;
            this.content = content;
        }
    
        public String getName() {
            return name;
        }
    
        public int getNum() {
            return num;
        }
    
        public String getContent() {
            return content;
        }
    }
    
    //处理者抽象类
    public abstract class Handler {
        protected final static int NUM_ONE = 1;
        protected final static int NUM_THREE = 3;
        protected final static int NUM_SEVEN = 7;
    
        //该领导处理的请假天数区间
        private int numStart;
        private int numEnd;
    
        //领导上面还有领导
        private Handler nextHandler;
    
        //设置请假天数范围 上不封顶
        public Handler(int numStart) {
            this.numStart = numStart;
        }
    
        //设置请假天数范围
        public Handler(int numStart, int numEnd) {
            this.numStart = numStart;
            this.numEnd = numEnd;
        }
    
        //设置上级领导
        public void setNextHandler(Handler nextHandler){
            this.nextHandler = nextHandler;
        }
    
        //提交请假条
        public final void submit(LeaveRequest leave){
            //如果请假天数达到该领导者的处理要求
            if (leaveRequest.getNum() >= numStart && leaveRequest.getNum() <= numEnd) {
                handleLeave(leaveRequest);
                //如果还有上级 并且请假天数超过了当前领导的处理范围
            } else if (nextHandler != null && leaveRequest.getNum() > numEnd) {
                nextHandler.submit(leaveRequest);//继续提交
            } else {
                System.out.println("流程结束!");
            }
        }
    
        //各级领导处理请假条方法
        protected abstract void handleLeave(LeaveRequest leave);
    }
    
    //小组长
    public class GroupLeader extends Handler {
        public GroupLeader() {
            //小组长处理1-3天的请假
            super(Handler.NUM_ONE, Handler.NUM_THREE);
        }
    
        @Override
        protected void handleLeave(LeaveRequest leave) {
            System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
            System.out.println("小组长审批:同意。");
        }
    }
    
    //部门经理
    public class Manager extends Handler {
        public Manager() {
            //部门经理处理3-7天的请假
            super(Handler.NUM_THREE, Handler.NUM_SEVEN);
        }
    
        @Override
        protected void handleLeave(LeaveRequest leave) {
            System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
            System.out.println("部门经理审批:同意。");
        }
    }
    
    //总经理
    public class GeneralManager extends Handler {
        public GeneralManager() {
            //部门经理处理7天以上的请假
            super(Handler.NUM_SEVEN);
        }
    
        @Override
        protected void handleLeave(LeaveRequest leave) {
            System.out.println(leave.getName() + "请假" + leave.getNum() + "天," + leave.getContent() + "。");
            System.out.println("总经理审批:同意。");
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            //请假条来一张
            LeaveRequest leave = new LeaveRequest("小花",5,"身体不适");
    
            //各位领导
            GroupLeader groupLeader = new GroupLeader();
            Manager manager = new Manager();
            GeneralManager generalManager = new GeneralManager();
    
            groupLeader.setNextHandler(manager);//小组长的领导是部门经理
            manager.setNextHandler(generalManager);//部门经理的领导是总经理
            //之所以在这里设置上级领导,是因为可以根据实际需求来更改设置,如果实战中上级领导人都是固定的,则可以移到领导实现类中。
    
            //提交申请
            groupLeader.submit(leave);
        }
    }
    

    6.4.4、优缺点

    1,优点:

    • 降低了对象之间的耦合度

      该模式降低了请求发送者和接收者的耦合度。

    • 增强了系统的可扩展性

      可以根据需要增加新的请求处理类,满足开闭原则。

    • 增强了给对象指派职责的灵活性

      当工作流程发生变化,可以动态地改变链内的成员或者修改它们的次序,也可动态地新增或者删除责任。

    • 责任链简化了对象之间的连接

      一个对象只需保持一个指向其后继者的引用,不需保持其他所有处理者的引用,这避免了使用众多的 if 或者 if···else 语句。

    • 责任分担

      每个类只需要处理自己该处理的工作,不能处理的传递给下一个对象完成,明确各类的责任范围,符合类的单一职责原则。

    2,缺点:

    • 不能保证每个请求一定被处理。由于一个请求没有明确的接收者,所以不能保证它一定会被处理,该请求可能一直传到链的末端都得不到处理。
    • 对比较长的职责链,请求的处理可能涉及多个处理对象,系统性能将受到一定影响。
    • 职责链建立的合理性要靠客户端来保证,增加了客户端的复杂性,可能会由于职责链的错误设置而导致系统出错,如可能会造成循环调用。

    6.4.5、源码解析

    在javaWeb应用开发中,FilterChain是职责链(过滤器)模式的典型应用,以下是Filter的模拟实现分析:

    • 模拟web请求Request以及web响应Response

      public interface Request{
       
      }
      
      public interface Response{
       
      }
      
    • 模拟web过滤器Filter

       public interface Filter {
       	public void doFilter(Request req,Response res,FilterChain c);
       }
      
    • 模拟实现具体过滤器

      public class FirstFilter implements Filter {
          @Override
          public void doFilter(Request request, Response response, FilterChain chain) {
      
              System.out.println("过滤器1 前置处理");
      
              // 先执行所有request再倒序执行所有response
              chain.doFilter(request, response);
      
              System.out.println("过滤器1 后置处理");
          }
      }
      
      public class SecondFilter  implements Filter {
          @Override
          public void doFilter(Request request, Response response, FilterChain chain) {
      
              System.out.println("过滤器2 前置处理");
      
              // 先执行所有request再倒序执行所有response
              chain.doFilter(request, response);
      
              System.out.println("过滤器2 后置处理");
          }
      }
      
    • 模拟实现过滤器链FilterChain

      public class FilterChain {
      
          private List<Filter> filters = new ArrayList<Filter>();
      
          private int index = 0;
      
          // 链式调用
          public FilterChain addFilter(Filter filter) {
              this.filters.add(filter);
              return this;
          }
      
          public void doFilter(Request request, Response response) {
              if (index == filters.size()) {
                  return;
              }
              Filter filter = filters.get(index);
              index++;
              filter.doFilter(request, response, this);
          }
      }
      
    • 测试类

      public class Client {
          public static void main(String[] args) {
              Request  req = null;
              Response res = null ;
      
              FilterChain filterChain = new FilterChain();
              filterChain.addFilter(new FirstFilter()).addFilter(new SecondFilter());
              filterChain.doFilter(req,res);
          }
      }
      

    6.5、状态模式

    6.5.1、概述

    【例】通过按钮来控制一个电梯的状态,一个电梯有开门状态,关门状态,停止状态,运行状态。每一种状态改变,都有可能要根据其他状态来更新处理。例如,如果电梯门现在处于运行时状态,就不能进行开门操作,而如果电梯门是停止状态,就可以执行开门操作。

    类图如下:

    在这里插入图片描述

    代码如下:

    public interface ILift {
        //电梯的4个状态
        //开门状态
        public final static int OPENING_STATE = 1;
        //关门状态
        public final static int CLOSING_STATE = 2;
        //运行状态
        public final static int RUNNING_STATE = 3;
        //停止状态
        public final static int STOPPING_STATE = 4;
    
        //设置电梯的状态
        public void setState(int state);
    
        //电梯的动作
        public void open();
        public void close();
        public void run();
        public void stop();
    }
    
    public class Lift implements ILift {
        private int state;
    
        @Override
        public void setState(int state) {
            this.state = state;
        }
    
        //执行关门动作
        @Override
        public void close() {
            switch (this.state) {
                case OPENING_STATE:
                    System.out.println("电梯关门了。。。");//只有开门状态可以关闭电梯门,可以对应电梯状态表来看
                    this.setState(CLOSING_STATE);//关门之后电梯就是关闭状态了
                    break;
                case CLOSING_STATE:
                    //do nothing //已经是关门状态,不能关门
                    break;
                case RUNNING_STATE:
                    //do nothing //运行时电梯门是关着的,不能关门
                    break;
                case STOPPING_STATE:
                    //do nothing //停止时电梯也是关着的,不能关门
                    break;
            }
        }
    
        //执行开门动作
        @Override
        public void open() {
            switch (this.state) {
                case OPENING_STATE://门已经开了,不能再开门了
                    //do nothing
                    break;
                case CLOSING_STATE://关门状态,门打开:
                    System.out.println("电梯门打开了。。。");
                    this.setState(OPENING_STATE);
                    break;
                case RUNNING_STATE:
                    //do nothing 运行时电梯不能开门
                    break;
                case STOPPING_STATE:
                    System.out.println("电梯门开了。。。");//电梯停了,可以开门了
                    this.setState(OPENING_STATE);
                    break;
            }
        }
    
        //执行运行动作
        @Override
        public void run() {
            switch (this.state) {
                case OPENING_STATE://电梯不能开着门就走
                    //do nothing
                    break;
                case CLOSING_STATE://门关了,可以运行了
                    System.out.println("电梯开始运行了。。。");
                    this.setState(RUNNING_STATE);//现在是运行状态
                    break;
                case RUNNING_STATE:
                    //do nothing 已经是运行状态了
                    break;
                case STOPPING_STATE:
                    System.out.println("电梯开始运行了。。。");
                    this.setState(RUNNING_STATE);
                    break;
            }
        }
    
        //执行停止动作
        @Override
        public void stop() {
            switch (this.state) {
                case OPENING_STATE: //开门的电梯已经是是停止的了(正常情况下)
                    //do nothing
                    break;
                case CLOSING_STATE://关门时才可以停止
                    System.out.println("电梯停止了。。。");
                    this.setState(STOPPING_STATE);
                    break;
                case RUNNING_STATE://运行时当然可以停止了
                    System.out.println("电梯停止了。。。");
                    this.setState(STOPPING_STATE);
                    break;
                case STOPPING_STATE:
                    //do nothing
                    break;
            }
        }
    }
    
    public class Client {
        public static void main(String[] args) {
            Lift lift = new Lift();
            lift.setState(ILift.STOPPING_STATE);//电梯是停止的
            lift.open();//开门
            lift.close();//关门
            lift.run();//运行
            lift.stop();//停止
        }
    }
    

    问题分析:

    • 使用了大量的switch…case这样的判断(if…else也是一样),使程序的可阅读性变差。
    • 扩展性很差。如果新加了断电的状态,我们需要修改上面判断逻辑

    定义:

    对有状态的对象,把复杂的“判断逻辑”提取到不同的状态对象中,允许状态对象在其内部状态发生改变时改变其行为。

    6.5.2、结构

    状态模式包含以下主要角色。

    • 环境(Context)角色:也称为上下文,它定义了客户程序需要的接口,维护一个当前状态,并将与状态相关的操作委托给当前状态对象来处理。
    • 抽象状态(State)角色:定义一个接口,用以封装环境对象中的特定状态所对应的行为。
    • 具体状态(Concrete State)角色:实现抽象状态所对应的行为。

    在这里插入图片描述

    6.5.3、案例实现

    对上述电梯的案例使用状态模式进行改进。类图如下:

    在这里插入图片描述

    代码如下:

    //抽象状态类
    public abstract class LiftState {
        //定义一个环境角色,也就是封装状态的变化引起的功能变化
        protected Context context;
    
        public void setContext(Context context) {
            this.context = context;
        }
    
        //电梯开门动作
        public abstract void open();
    
        //电梯关门动作
        public abstract void close();
    
        //电梯运行动作
        public abstract void run();
    
        //电梯停止动作
        public abstract void stop();
    }
    
    //开启状态
    public class OpenningState extends LiftState {
    
        //开启当然可以关闭了,我就想测试一下电梯门开关功能
        @Override
        public void open() {
            System.out.println("电梯门开启...");
        }
    
        @Override
        public void close() {
            //状态修改
            super.context.setLiftState(Context.closeingState);
            //动作委托为CloseState来执行,也就是委托给了ClosingState子类执行这个动作
            super.context.getLiftState().close();
        }
    
        //电梯门不能开着就跑,这里什么也不做
        @Override
        public void run() {
            //do nothing
        }
    
        //开门状态已经是停止的了
        @Override
        public void stop() {
            //do nothing
        }
    }
    
    //运行状态
    public class RunningState extends LiftState {
    
        //运行的时候开电梯门?你疯了!电梯不会给你开的
        @Override
        public void open() {
            //do nothing
        }
    
        //电梯门关闭?这是肯定了
        @Override
        public void close() {//虽然可以关门,但这个动作不归我执行
            //do nothing
        }
    
        //这是在运行状态下要实现的方法
        @Override
        public void run() {
            System.out.println("电梯正在运行...");
        }
    
        //这个事绝对是合理的,光运行不停止还有谁敢做这个电梯?!估计只有上帝了
        @Override
        public void stop() {
            super.context.setLiftState(Context.stoppingState);
            super.context.stop();
        }
    }
    
    //停止状态
    public class StoppingState extends LiftState {
    
        //停止状态,开门,那是要的!
        @Override
        public void open() {
            //状态修改
            super.context.setLiftState(Context.openningState);
            //动作委托为CloseState来执行,也就是委托给了ClosingState子类执行这个动作
            super.context.getLiftState().open();
        }
    
        @Override
        public void close() {//虽然可以关门,但这个动作不归我执行
            //状态修改
            super.context.setLiftState(Context.closeingState);
            //动作委托为CloseState来执行,也就是委托给了ClosingState子类执行这个动作
            super.context.getLiftState().close();
        }
    
        //停止状态再跑起来,正常的很
        @Override
        public void run() {
            //状态修改
            super.context.setLiftState(Context.runningState);
            //动作委托为CloseState来执行,也就是委托给了ClosingState子类执行这个动作
            super.context.getLiftState().run();
        }
    
        //停止状态是怎么发生的呢?当然是停止方法执行了
        @Override
        public void stop() {
            System.out.println("电梯停止了...");
        }
    }
    
    //关闭状态
    public class ClosingState extends LiftState {
    
        @Override
        //电梯门关闭,这是关闭状态要实现的动作
        public void close() {
            System.out.println("电梯门关闭...");
        }
    
        //电梯门关了再打开,逗你玩呢,那这个允许呀
        @Override
        public void open() {
            super.context.setLiftState(Context.openningState);
            super.context.open();
        }
    
    
        //电梯门关了就跑,这是再正常不过了
        @Override
        public void run() {
            super.context.setLiftState(Context.runningState);
            super.context.run();
        }
    
        //电梯门关着,我就不按楼层
        @Override
        public void stop() {
            super.context.setLiftState(Context.stoppingState);
            super.context.stop();
        }
    }
    
    //环境角色
    public class Context {
        //定义出所有的电梯状态
        public final static OpenningState openningState = new OpenningState();//开门状态,这时候电梯只能关闭
        public final static ClosingState closeingState = new ClosingState();//关闭状态,这时候电梯可以运行、停止和开门
        public final static RunningState runningState = new RunningState();//运行状态,这时候电梯只能停止
        public final static StoppingState stoppingState = new StoppingState();//停止状态,这时候电梯可以开门、运行
    
    
        //定义一个当前电梯状态
        private LiftState liftState;
    
        public LiftState getLiftState() {
            return this.liftState;
        }
    
        public void setLiftState(LiftState liftState) {
            //当前环境改变
            this.liftState = liftState;
            //把当前的环境通知到各个实现类中
            this.liftState.setContext(this);
        }
    
        public void open() {
            this.liftState.open();
        }
    
        public void close() {
            this.liftState.close();
        }
    
        public void run() {
            this.liftState.run();
        }
    
        public void stop() {
            this.liftState.stop();
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            Context context = new Context();
            context.setLiftState(new ClosingState());
    
            context.open();
            context.close();
            context.run();
            context.stop();
        }
    }
    

    6.5.4、优缺点

    1,优点:

    • 将所有与某个状态有关的行为放到一个类中,并且可以方便地增加新的状态,只需要改变对象状态即可改变对象的行为。
    • 允许状态转换逻辑与状态对象合成一体,而不是某一个巨大的条件语句块。

    2,缺点:

    • 状态模式的使用必然会增加系统类和对象的个数。
    • 状态模式的结构与实现都较为复杂,如果使用不当将导致程序结构和代码的混乱。
    • 状态模式对"开闭原则"的支持并不太好。

    6.5.5、使用场景

    • 当一个对象的行为取决于它的状态,并且它必须在运行时根据状态改变它的行为时,就可以考虑使用状态模式。
    • 一个操作中含有庞大的分支结构,并且这些分支决定于对象的状态时。

    6.6、观察者模式

    6.6.1、概述

    定义:

    又被称为发布-订阅(Publish/Subscribe)模式,它定义了一种一对多的依赖关系,让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时,会通知所有的观察者对象,使他们能够自动更新自己。

    6.6.2、结构

    在观察者模式中有如下角色:

    • 发布者 (Publisher) 会向其他对象发送值得关注的事件。 事件会在发布者自身状态改变或执行特定行为后发生。 发布者中包含一个允许新订阅者加入和当前订阅者离开列表的订阅构架。
    • 订阅者 (Subscriber) 接口声明了通知接口。 在绝大多数情况下, 该接口仅包含一个 update更新方法。 该方法可以拥有多个参数, 使发布者能在更新时传递事件的详细信息。
    • 具体订阅者 (Concrete Subscribers):可以执行一些操作来回应发布者的通知。 所有具体订阅者类都实现了同样的接口, 因此发布者不需要与具体类相耦合。

    在这里插入图片描述

    订阅者——观察者

    发布者——被观察者

    6.6.3、案例实现

    【例】微信公众号

    在使用微信公众号时,大家都会有这样的体验,当你关注的公众号中有新内容更新的话,它就会推送给关注公众号的微信用户端。我们使用观察者模式来模拟这样的场景,微信用户就是观察者,微信公众号是被观察者,有多个的微信用户关注了程序猿这个公众号。

    类图如下:

    在这里插入图片描述

    代码如下:

    定义抽象观察者类,里面定义一个更新的方法

    public interface Observer {
        void update(String message);
    }
    

    定义具体观察者类,微信用户是观察者,里面实现了更新的方法

    public class WeixinUser implements Observer {
        // 微信用户名
        private String name;
    
        public WeixinUser(String name) {
            this.name = name;
        }
        @Override
        public void update(String message) {
            System.out.println(name + "-收到:" + message);
        }
    }
    

    定义抽象主题类,提供了attach、detach、notify三个方法

    public interface Subject {
        //增加订阅者
        public void attach(Observer observer);
    
        //删除订阅者
        public void detach(Observer observer);
        
        //通知订阅者更新消息
        public void notify(String message);
    }
    
    

    微信公众号是具体主题(具体被观察者),里面存储了订阅该公众号的微信用户,并实现了抽象主题中的方法

    public class SubscriptionSubject implements Subject {
        //储存订阅公众号的微信用户
        private List<Observer> weixinUserlist = new ArrayList<Observer>();
    
        @Override
        public void attach(Observer observer) {
            weixinUserlist.add(observer);
        }
    
        @Override
        public void detach(Observer observer) {
            weixinUserlist.remove(observer);
        }
    
        @Override
        public void notify(String message) {
            for (Observer observer : weixinUserlist) {
                observer.update(message);
            }
        }
    }
    

    客户端程序

    public class Client {
        public static void main(String[] args) {
            SubscriptionSubject subject = new SubscriptionSubject();
            //创建微信用户,订阅公众号
           subject.attach(new WeiXinUser("孙悟空"));
    		subject.attach(new WeiXinUser("猪悟能"));
    		subject.attach(new WeiXinUser("沙悟净"));
            
            //公众号更新发出消息给订阅的微信用户
            mSubscriptionSubject.notify("师傅被妖怪抓走了!");
        }
    }
    
    

    在这里插入图片描述

    6.6.4、优缺点

    1,优点:

    • 降低了目标与观察者之间的耦合关系,两者之间是抽象耦合关系。
    • 被观察者发送通知,所有注册的观察者都会收到信息【可以实现广播机制】

    2,缺点:

    • 如果观察者非常多的话,那么所有的观察者收到被观察者发送的通知会耗时
    • 如果被观察者有循环依赖的话,那么被观察者发送通知会使观察者循环调用,会导致系统崩溃

    6.6.5、使用场景

    • 对象间存在一对多关系,一个对象的状态发生改变会影响其他对象。
    • 当一个抽象模型有两个方面,其中一个方面依赖于另一方面时。

    6.6.6、JDK中提供的实现

    在 Java 中,通过 java.util.Observable 类和 java.util.Observer 接口定义了观察者模式,只要实现它们的子类就可以编写观察者模式实例。

    1,Observable类

    Observable 类是抽象目标类(被观察者),它有一个 Vector 集合成员变量,用于保存所有要通知的观察者对象,下面来介绍它最重要的 3 个方法。

    • void addObserver(Observer o) 方法:用于将新的观察者对象添加到集合中。

    • void notifyObservers(Object arg) 方法:调用集合中的所有观察者对象的 update方法,通知它们数据发生改变。通常越晚加入集合的观察者越先得到通知。

    • void setChange() 方法:用来设置一个 boolean 类型的内部标志,注明目标对象发生了变化。当它为true时,notifyObservers() 才会通知观察者。

    2,Observer 接口

    Observer 接口是抽象观察者,它监视目标对象的变化,当目标对象发生变化时,观察者得到通知,并调用 update 方法,进行相应的工作。

    【例】警察抓小偷

    警察抓小偷也可以使用观察者模式来实现,警察是观察者,小偷是被观察者。代码如下:

    小偷是一个被观察者,所以需要继承Observable类

    public class Thief extends Observable {
    
        private String name;
    
        public Thief(String name) {
            this.name = name;
        }
        
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        public void steal() {
            System.out.println("小偷:我偷东西了,有没有人来抓我!!!");
            super.setChanged(); //changed  = true
            super.notifyObservers();
        }
    }
    
    

    警察是一个观察者,所以需要让其实现Observer接口

    public class Policemen implements Observer {
    
        private String name;
    
        public Policemen(String name) {
            this.name = name;
        }
        public void setName(String name) {
            this.name = name;
        }
    
        public String getName() {
            return name;
        }
    
        @Override
        public void update(Observable o, Object arg) {
            System.out.println("警察-" + name + ": " + ((Thief) observable).getName() + ",我已经盯你很久了,你可以保持沉默,但你所说的将成为呈堂证供!!!");
        }
    }
    

    客户端代码

    public class Client {
        public static void main(String[] args) {
            //创建小偷对象
            Thief t = new Thief("隔壁老王");
            //创建警察对象
            Policemen p = new Policemen("小李");
            //让警察盯着小偷
            t.addObserver(p);
            //小偷偷东西
            t.steal();
        }
    }
    

    在这里插入图片描述

    6.7、中介者模式

    中介者模式是一种行为设计模式, 能让你减少对象之间混乱无序的依赖关系。 该模式会限制对象之间的直接交互, 迫使它们通过一个中介者对象进行合作。

    6.7.1、概述

    一般来说,同事类之间的关系是比较复杂的,多个同事类之间互相关联时,他们之间的关系会呈现为复杂的网状结构,这是一种过度耦合的架构,即不利于类的复用,也不稳定。例如在下左图中,有六个同事类对象,假如对象1发生变化,那么将会有4个对象受到影响。如果对象2发生变化,那么将会有5个对象受到影响。也就是说,同事类之间直接关联的设计是不好的。

    如果引入中介者模式,那么同事类之间的关系将变为星型结构,从下右图中可以看到,任何一个类的变动,只会影响的类本身,以及中介者,这样就减小了系统的耦合。一个好的设计,必定不会把所有的对象关系处理逻辑封装在本类中,而是使用一个专门的类来管理那些不属于自己的行为。

    在这里插入图片描述

    定义:

    又叫调停模式,定义一个中介角色来封装一系列对象之间的交互,使原有对象之间的耦合松散,且可以独立地改变它们之间的交互。

    6.7.2、结构

    中介者模式包含以下主要角色:

    • 抽象中介者(Mediator)角色:它是中介者的接口,提供了同事对象注册与转发同事对象信息的抽象方法。

    • 具体中介者(ConcreteMediator)角色:实现中介者接口,定义一个 List 来管理同事对象,协调各个同事角色之间的交互关系,因此它依赖于同事角色。

    • 抽象同事类(Colleague)角色:定义同事类的接口,保存中介者对象,提供同事对象交互的抽象方法,实现所有相互影响的同事类的公共功能。

    • 具体同事类(Concrete Colleague)角色:是抽象同事类的实现者,当需要与其他同事对象交互时,由中介者对象负责后续的交互。

    在这里插入图片描述

    6.7.3、案例实现

    【例】租房

    现在租房基本都是通过房屋中介,房主将房屋托管给房屋中介,而租房者从房屋中介获取房屋信息。房屋中介充当租房者与房屋所有者之间的中介者。

    类图如下:

    在这里插入图片描述

    代码如下:

    //抽象中介者
    public abstract class Mediator {
        //申明一个联络方法
        public abstract void constact(String message,Person person);
    }
    
    //抽象同事类
    public abstract class Person {
        protected String name;
        protected Mediator mediator;
    
        public Person(String name,Mediator mediator){
            this.name = name;
            this.mediator = mediator;
        }
    }
    
    //具体同事类 房屋拥有者
    public class HouseOwner extends Person {
    
        public HouseOwner(String name, Mediator mediator) {
            super(name, mediator);
        }
    
        //与中介者联系
        public void constact(String message){
            mediator.constact(message, this);
        }
    
        //获取信息
        public void getMessage(String message){
            System.out.println("房主" + name +"获取到的信息:" + message);
        }
    }
    
    //具体同事类 承租人
    public class Tenant extends Person {
        public Tenant(String name, Mediator mediator) {
            super(name, mediator);
        }
    
        //与中介者联系
        public void constact(String message){
            mediator.constact(message, this);
        }
    
        //获取信息
        public void getMessage(String message){
            System.out.println("租房者" + name +"获取到的信息:" + message);
        }
    }
    
    //中介机构
    public class MediatorStructure extends Mediator {
        //首先中介结构必须知道所有房主和租房者的信息
        private HouseOwner houseOwner;
        private Tenant tenant;
    
        public HouseOwner getHouseOwner() {
            return houseOwner;
        }
    
        public void setHouseOwner(HouseOwner houseOwner) {
            this.houseOwner = houseOwner;
        }
    
        public Tenant getTenant() {
            return tenant;
        }
    
        public void setTenant(Tenant tenant) {
            this.tenant = tenant;
        }
    
        public void constact(String message, Person person) {
            if (person == houseOwner) {          //如果是房主,则租房者获得信息
                tenant.getMessage(message);
            } else {       //反正则是房主获得信息
                houseOwner.getMessage(message);
            }
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            //一个房主、一个租房者、一个中介机构
            MediatorStructure mediator = new MediatorStructure();
    
            //房主和租房者只需要知道中介机构即可
            HouseOwner houseOwner = new HouseOwner("张三", mediator);
            Tenant tenant = new Tenant("李四", mediator);
    
            //中介结构要知道房主和租房者
            mediator.setHouseOwner(houseOwner);
            mediator.setTenant(tenant);
    
            tenant.constact("需要租三室的房子");
            houseOwner.constact("我这有三室的房子,你需要租吗?");
        }
    }
    

    6.7.4、优缺点

    1,优点:

    • 松散耦合

      中介者模式通过把多个同事对象之间的交互封装到中介者对象里面,从而使得同事对象之间松散耦合,基本上可以做到互补依赖。这样一来,同事对象就可以独立地变化和复用,而不再像以前那样“牵一处而动全身”了。

    • 集中控制交互

      多个同事对象的交互,被封装在中介者对象里面集中管理,使得这些交互行为发生变化的时候,只需要修改中介者对象就可以了,当然如果是已经做好的系统,那么就扩展中介者对象,而各个同事类不需要做修改。

    • 一对多关联转变为一对一的关联

      没有使用中介者模式的时候,同事对象之间的关系通常是一对多的,引入中介者对象以后,中介者对象和同事对象的关系通常变成双向的一对一,这会让对象的关系更容易理解和实现。

    2,缺点:

    当同事类太多时,中介者的职责将很大,它会变得复杂而庞大,以至于系统难以维护。

    6.7.5、使用场景

    • 系统中对象之间存在复杂的引用关系,系统结构混乱且难以理解。
    • 当想创建一个运行于多个类之间的对象,又不想生成新的子类时。

    6.8、迭代器模式

    6.8.1、概述

    定义:

    提供一个对象来顺序访问聚合对象中的一系列数据,而不暴露聚合对象的内部表示。

    6.8.2、结构

    迭代器模式主要包含以下角色:

    • 抽象聚合(Aggregate)角色:定义存储、添加、删除聚合元素以及创建迭代器对象的接口。

    • 具体聚合(ConcreteAggregate)角色:实现抽象聚合类,返回一个具体迭代器的实例。

    • 抽象迭代器(Iterator)角色:定义访问和遍历聚合元素的接口,通常包含 hasNext()、next() 等方法。

    • 具体迭代器(Concretelterator)角色:实现抽象迭代器接口中所定义的方法,完成对聚合对象的遍历,记录遍历的当前位置。