# JavaDesignPattern **Repository Path**: wyzstudy/java-design-pattern ## Basic Information - **Project Name**: JavaDesignPattern - **Description**: 用Java语言来实现设计模式,对23种设计模式的原理及应用场景进行简单分析 - **Primary Language**: Java - **License**: GPL-3.0 - **Default Branch**: master - **Homepage**: None - **GVP Project**: No ## Statistics - **Stars**: 0 - **Forks**: 0 - **Created**: 2021-06-21 - **Last Updated**: 2021-11-02 ## Categories & Tags **Categories**: Uncategorized **Tags**: None ## README # JavaDesignPattern #### 介绍 用Java语言来实现设计模式,对23种设计模式的原理及应用场景进行简单分析 #### 设计模式的七大原则 + 单一职责原则 对类来说,一个类就负责一个职责。例如如果类A负责两个不同的职责,职责1和职责2,当职责1需求变更改变A时,可能会造成职责2的执行错误,所以需要将类A分解成不同职责的类A1和A2。 **案例应用:** ```java //交通工具类 class Vehicle{ public void run(String vehicle){ System.out.println(vehicle + "在公路上面跑"); } } Vehicle vehicle = new Vehicle(); vehicle.run("汽车"); vehicle.run("摩托车"); vehicle.run("飞机"); //存在问题,飞机不能在路上跑,一个类的方法职责过多,违反单一职责原则 //方式2 class RoadVehicle{ public void run(String vehicle){ System.out.println(vehicle + "在公路上面跑"); } } class AirVehicle{ public void run(String vehicle){ System.out.println(vehicle + "在天空中飞"); } } class WaterVehicle{ public void run(String vehicle){ System.out.println(vehicle + "在水中游"); } } RoadVehicle roadVehicle = new RoadVehicle(); roadVehicle.run("摩托车"); WaterVehicle waterVehicle = new WaterVehicle(); waterVehicle.run("轮船"); AirVehicle airVehicle = new AirVehicle(); airVehicle.run("飞机"); //遵守单一职责原则,但是对类的改动很大,将类分解成几个类,同时需要修改客户端,成本很大 //方式3 class Vehicle2{ public void run(String vehicle){ System.out.println(vehicle + "在公路上跑"); } public void airRun(String vehicle){ System.out.println(vehicle + "在天空中飞"); } public void waterRun(String vehicle){ System.out.println(vehicle + "在水中游"); } } Vehicle2 vehicle = new Vehicle2(); vehicle.run("摩托车"); vehicle.waterRun("轮船"); vehicle.airRun("飞机"); //在类的层面没有遵守单一职责原则,但是在方法的层面是遵守单一职责原则,并没有对类做很大的改变,不需要修改客户端 ``` 单一职责原则和注意事项: 1. 降低类的复杂度,一个类只负责一个职责 2. 提高类的可读性和可维护性 3. 降低变更引起的风险 4. 通常情况下,我们应该遵守单一职责原则,只有逻辑足够简单,才可以在代码级别违法单一职责原则,只有在类中方法足够少的时候才可以在方法层面遵守类的单一职责原则,如上面方式3 + 接口隔离原则 客户端应该不依赖它不需要的接口,即一个类对另一个类的依赖应该建立在最小接口上面。 代码演示: ```java interface A{ void operation1(); void operation2(); void operation3(); void operation4(); void operation5(); } class B implements A{ @Override public void operation1() { System.out.println("类B实现了operation1"); } @Override public void operation2() { System.out.println("类B实现了operation2"); } @Override public void operation3() { System.out.println("类B实现了operation3"); } @Override public void operation4() { System.out.println("类B实现了operation4"); } @Override public void operation5() { System.out.println("类B实现了operation5"); } } class D implements A{ @Override public void operation1() { System.out.println("类D实现了operation1"); } @Override public void operation2() { System.out.println("类D实现了operation2"); } @Override public void operation3() { System.out.println("类D实现了operation3"); } @Override public void operation4() { System.out.println("类D实现了operation4"); } @Override public void operation5() { System.out.println("类D实现了operation5"); } } class C1{ public void operation1(B a){ a.operation1(); } public void operation2(B a){ a.operation2(); } public void operation3(B a){ a.operation3(); } } class C2{ public void operation1(D a){ a.operation1(); } public void operation4(D a){ a.operation4(); } public void operation5(D a){ a.operation5(); } } //代码的问题,接口A有五个方法,类B和D都实现了接口A,C1通过接口A引用类B,C2通过引用接口A的实现D,这里就存在一个问题,类C1对类B的使用只需要方法1、2、3,类C2对类D的使用只需要方法1、4、5,两个类都有多余不需要实现的方法,违法了即一个类对另一个类的依赖应该建立在最小接口上面 //改进版本 interface interface1{ void operation1(); } interface interface2{ void operation2(); void operation3(); } interface interface3{ void operation4(); void operation5(); } class B1 implements interface1,interface2{ @Override public void operation1() { System.out.println("B1实现operation1"); } @Override public void operation2() { System.out.println("B1实现operation2"); } @Override public void operation3() { System.out.println("B1实现operation3"); } } class D1 implements interface1,interface3{ @Override public void operation1() { System.out.println("D1实现operation1"); } @Override public void operation4() { System.out.println("D1实现operation4"); } @Override public void operation5() { System.out.println("D1实现operation5"); } } class C3{ public void operation1(interface1 interface1){ interface1.operation1(); } public void operation2(interface2 interface2){ interface2.operation2(); } public void operation3(interface2 interface2){ interface2.operation3(); } } class C4{ public void operation1(interface1 interface1){ interface1.operation1(); } public void operation4(interface3 interface3){ interface3.operation4(); } public void operation5(interface3 interface3){ interface3.operation5(); } } C3 c3 = new C3(); c3.operation1(new B1()); c3.operation2(new B1()); c3.operation3(new B1()); C4 c4 = new C4(); c4.operation1(new D1()); c4.operation4(new D1()); c4.operation5(new D1()); 我们对第一个版本中的接口进行了改进,我们的类只依赖最小的接口 ``` + 依赖倒转原则 高层模块不应该依赖其底层模块,二者都应该依赖其抽象,抽象不应该依赖其细节,细节应该依赖其抽象,依赖倒转的中心思想是面向接口编程。依赖倒转的原则是基于这样的设计理念:相对于细节的多变性,抽象的对象要稳定的多,以抽象为基础搭建的架构比以细节为基础搭建的架构稳定的多,在java中抽象指的是抽象类或者接口,细节指的是具体的实现类。使用接口或者抽象类的具体目的,制定好规范,而不设涉及任何具体的操作,把展现细节的任务交给他们的实现类去完成。 ```java class Email{ public String getInfo(){ return "邮件信息: hello world"; } } class Person{ public void inversion(Email email){ System.out.println(email.getInfo()); } } Person person = new Person(); person.inversion(new Email()); //存在一个问题,如果我们想要扩展一个微信消息或者短信,我们就必须修改Person在类中增加一些方法,我们的inversion方法是依赖的具体实现类,我们可以将其改进一下 interface IReceiver{ String getInfo(); } class Email implements IReceiver{ @Override public String getInfo() { return "邮件信息: hello world"; } } class WeiXin implements IReceiver{ @Override public String getInfo() { return "微信消息: hello world"; } } class Person{ public void inversion(IReceiver iReceiver){ System.out.println(iReceiver.getInfo()); } } Person person = new Person(); person.inversion(new Email()); person.inversion(new WeiXin()); ``` 依赖关系的传递方式: 1. 接口传递 2. 构造方法传递 3. setter方法传递 ```java //接口传递依赖关系 interface IOpenAndClose{ void open(ITV itv); } interface ITV{ void play(); } class ChangHong implements ITV{ @Override public void play() { System.out.println("打开长虹电视机"); } } class OpenAndClose implements IOpenAndClose{ @Override public void open(ITV itv) { itv.play(); } } ChangHong changHong = new ChangHong(); OpenAndClose openAndClose = new OpenAndClose(); openAndClose.open(changHong); //通过构造方式传递依赖关系 interface IOpenAndClose{ void open(); } interface ITV{ void play(); } class ChangHong implements ITV{ @Override public void play() { System.out.println("打开长虹电视机"); } } class OpenAndClose implements IOpenAndClose{ private ITV itv; public OpenAndClose(ITV itv){ this.itv = itv; } @Override public void open() { itv.play(); } } ChangHong changHong = new ChangHong(); OpenAndClose openAndClose = new OpenAndClose(changHong); openAndClose.open(); //通过setter方式传递依赖关系 interface IOpenAndClose{ void open(); } interface ITV{ void play(); } class ChangHong implements ITV{ @Override public void play() { System.out.println("打开长虹电视机"); } } class OpenAndClose implements IOpenAndClose{ private ITV itv; public void setItv(ITV itv) { this.itv = itv; } @Override public void open() { itv.play(); } } ChangHong changHong = new ChangHong(); OpenAndClose openAndClose = new OpenAndClose(); openAndClose.setItv(changHong); openAndClose.open(); ``` 细节和总结: 低层模块或者类都应该有抽象类或者接口,或者二者都有,这样程序的稳定性更好。变量的声明类型尽量是抽象类或者接口,这样我们的变量引用和实际对象间就有应该缓存区域,利于程序扩展和优化,继承时遵循里氏替换原则。 + 里氏替换原则 如果对每个类型为T1的对象o1,都有类型为T2对象o2,使得以T1定义的所有程序P,在所有的对象o1都被替换为o2的时候,程序P并没有发生变化,那么类型T2是类型T1的子类型,换句话说,所有使用基类的地方都能透明的使用子类型。 **在继承时,遵守里氏替换原则,所有的子类尽量不要重写父类的方法** 里氏替换原则告诉我们,继承会让两个对象的耦合性增强,**在适当的情况下我们可以通过依赖、组合、聚合来解决问题** 实例: ```java class A { public int func1(int a,int b){ return a - b; } } class B extends A{ @Override public int func1(int a, int b) { return a + b; } public int func2(int a,int b){ return func1(a,b) + 9; } } A a = new A(); System.out.println("11 - 3 = " + a.func1(11,3)); System.out.println("1 - 9 = " + a.func1(1,9)); B b = new B(); System.out.println("11 - 3 = " + b.func1(11,3)); System.out.println("1 - 9 = " + b.func1(1,9)); System.out.println("11 + 3 + 9 = " + b.func2(11,3)); //类B无意识的重写了类A中的方法,造成了程序错误,在实际的开发中,我们会通过重写父类的方法来完成新功能的扩展,这样写起来虽然很简单,但整个继承体系的复用性会比较差,特别是运行多态比较繁琐的时候。我们通用的做法是,通过让原来的父类和子类继承一个更加通俗的基类,原有的继承关系去掉,采用依赖、聚合、组合等关系代替。 class Base{ } class A extends Base{ public int func1(int a,int b){ return a-b; } } class B extends Base{ private A a = new A(); public int func1(int a,int b){ return a + b; } public int func2(int a,int b){ return func1(a,b) + 9; } public int func3(int a,int b){ return this.a.func1(a,b); } } A a1 = new A(); System.out.println("11 - 3 = " + a1.func1(11,3)); System.out.println("1 - 9 = " + a1.func1(1,9)); B b = new B(); System.out.println("11 + 3 = " + b.func1(11,3)); System.out.println("1 + 9 = " + b.func1(1,9)); System.out.println("11 + 3 + 9 = " + b.func2(11,3)); System.out.println("1-9 = " + b.func3(1,9)); ``` + 开闭原则OCP 开闭原则是编程中最基础,最重要的设计原则。一个软件实体如类、模块、函数应该对扩展开发(对提供方),对修改关闭(对使用方),用抽象构建框架,用实现扩展细节。当软件需要变化的时候,尽量通过扩展软件实体来实现变化,而不是通过修改已有的代码来实现变化。**在编程中遵循其它原则以及使用设计模式的作用就是遵循开闭原则** ```java class GraphicEditor{ public void drawShape(Shape s){ if(s.m_type == 1){ drawCircle(); }else if(s.m_type == 2){ drawRectangle(); } } public void drawCircle(){ System.out.println("绘制圆形"); } public void drawRectangle(){ System.out.println("绘制矩形"); } } class Shape{ int m_type; } class Rectangle extends Shape{ public Rectangle(){ super.m_type = 2; } } class Circle extends Shape{ public Circle(){ super.m_type = 1; } } GraphicEditor graphicEditor = new GraphicEditor(); graphicEditor.drawShape(new Rectangle()); graphicEditor.drawShape(new Circle()); //实现代码比较简单,容易理解,但是违法OCP原则,扩展开发(提供方),修改关闭(使用方),当我们给类增加一个新的功能的时候,尽量不去修改代码,或者减少修改代码,我们在这里增加一个绘制三角形的类,需要修改大量代码,不仅仅是提供方需要增加新类,使用的地方也需要修改代码。 class GraphicEditor{ public void shape(Shape s){ s.drawShape(); } } abstract class Shape{ int m_type; abstract void drawShape(); } class Rectangle extends Shape{ public Rectangle(){ super.m_type = 2; } @Override void drawShape() { System.out.println("绘制矩形"); } } class Circle extends Shape{ public Circle(){ super.m_type = 1; } @Override void drawShape() { System.out.println("绘制圆形"); } } class Triangle extends Shape{ public Triangle(){ super.m_type = 3; } @Override void drawShape() { System.out.println("绘制三角形"); } } class Other extends Shape{ public Other(){ super.m_type = 4; } @Override void drawShape() { System.out.println("绘制其它图像"); } } GraphicEditor graphicEditor = new GraphicEditor(); graphicEditor.shape(new Rectangle()); graphicEditor.shape(new Circle()); graphicEditor.shape(new Triangle()); graphicEditor.shape(new Other()); ``` + 迪米特法则 一个对象应该对其它对象保持最少的了解;类与类关系越亲密,耦合度越大;迪米特法则又叫最少知道原则,即一个类对自己依赖的类知道的越少越好,也就是说,对于被依赖的类,不管多么复制,都应该将逻辑尽量封装在类的内部,对外部提供public方法,不对外泄露任何信息;迪米特法则还有一个更简单的定义就是只与直接朋友通信。 直接朋友: 每个对象都会与其它对象有耦合关系,只要两个对象有耦合关系,我们就说这两个类是朋友关系,耦合的关系有很多种,依赖,聚合,组合,关联等,其中我们称出现成员变量、方法参数、方法返回值中的类为直接朋友关系,而出现在局部变量中的类不是直接朋友关系,也就是说,陌生的类最好不要以局部变量的方式出现在类的内部。 ```java class Employee{ private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } } class CollegeEmployee{ private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } } class CollegeManager{ public List getAllEmployee(){ List list = new ArrayList<>(); for(int i = 1 ; i <= 10; i++){ CollegeEmployee employee = new CollegeEmployee(); employee.setId("学院员工: " + i); list.add(employee); } return list; } } class SchoolManager{ public List getAllEmployee(){ List list = new ArrayList<>(); for(int i = 1 ; i <= 5; i++){ Employee employee = new Employee(); employee.setId("学校总部员工: " + i); list.add(employee); } return list; } public void printAllEmployee(CollegeManager collegeManager){ //打印学院员工 List collegeEmployees = collegeManager.getAllEmployee(); for(CollegeEmployee employee : collegeEmployees){ System.out.println(employee.getId()); } //打印学校员工 List employees = this.getAllEmployee(); for(Employee e: employees){ System.out.println(e.getId()); } } } SchoolManager schoolManager = new SchoolManager(); schoolManager.printAllEmployee(new CollegeManager()); //我们来分析SchoolManager的朋友,Employee是直接朋友,在返回值中,CollegeManager是直接朋友,出现在参数中,而CollectionEmployee不是直接朋友关系,出现在类的内部,局部变量的位置,违反了迪米特法则应该避免非直接朋友的耦合关系 //改进 class Employee1{ private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } } class CollegeEmployee1{ private String id; public String getId() { return id; } public void setId(String id) { this.id = id; } } class CollegeManager{ public List getAllEmployee(){ List list = new ArrayList<>(); for(int i = 1 ; i <= 10; i++){ CollegeEmployee1 employee = new CollegeEmployee1(); employee.setId("学院员工: " + i); list.add(employee); } return list; } public void printAllEmployee(){ List employee1s = this.getAllEmployee(); for(CollegeEmployee1 collegeEmployee1 : employee1s){ System.out.println(collegeEmployee1.getId()); } } } class SchoolManager{ public List getAllEmployee(){ List list = new ArrayList<>(); for(int i = 1 ; i <= 5; i++){ Employee1 employee = new Employee1(); employee.setId("学校总部员工: " + i); list.add(employee); } return list; } public void printAllEmployee(CollegeManager collegeManager){ //打印学院员工 collegeManager.printAllEmployee(); //打印学校员工 List employees = this.getAllEmployee(); for(Employee1 e: employees){ System.out.println(e.getId()); } } } SchoolManager schoolManager = new SchoolManager(); schoolManager.printAllEmployee(new CollegeManager()); ``` 迪米特法则的核心是降低类之间的耦合度,但是注意,由于每个类减少了不必要的依赖,因此,迪米特法则只是要求降低类之间的耦合关系,并不是完全没有依赖关系。 + 合成复用原则 尽量使用合成或者聚合的方式,而不是使用继承 七大设计模式,都是为了实现下面的几个目标: 1. 找出应用中可能需要变化的地方,把他们独立出来,不要和不需要变化的代码混合在一起 2. 针对接口编程,而不是针对实现编程 3. 为了交互对象之间的松耦合设计而努力 #### 设计模式的目的 在编写软件的过程中,程序员面临着耦合性、内聚性、可维护性、可扩展性、重用性、灵活性等多方面的挑战,设计模式是为了让程序具有更好的: + 代码重用性 + 可读性 + 可扩展性 + 可靠性 + 使程序呈现高内聚,低耦合的特性 各种原则要求的侧重点不同,下面我们分别用一句话归纳总结软件设计模式的七大原则,如下表所示。 | 设计原则 | 一句话归纳 | 目的 | | ------------ | ------------------------------------------------------------ | ------------------------------------------ | | 开闭原则 | 对扩展开放,对修改关闭 | 降低维护带来的新风险 | | 依赖倒置原则 | 高层不应该依赖低层,要面向接口编程 | 更利于代码结构的升级扩展 | | 单一职责原则 | 一个类只干一件事,实现类要单一 | 便于理解,提高代码的可读性 | | 接口隔离原则 | 一个接口只干一件事,接口要精简单一 | 功能解耦,高聚合、低耦合 | | 迪米特法则 | 不该知道的不要知道,一个类应该保持对其它对象最少的了解,降低耦合度 | 只和朋友交流,不和陌生人说话,减少代码臃肿 | | 里氏替换原则 | 不要破坏继承体系,子类重写方法功能发生改变,不应该影响父类方法的含义 | 防止继承泛滥 | | 合成复用原则 | 尽量使用组合或者聚合关系实现代码复用,少使用继承 | 降低代码耦合 | 实际上,这些原则的目的只有一个:降低对象之间的耦合,增加程序的可复用性、可扩展性和可维护性。 #### 设计模式分类 设计模式共分为三种类型,一共23种 创建型模式:**单例模式**、抽象工厂模式、原型模式、建造者模式、**工厂模式** 结构性模式:适配器模式、桥接模式、**装饰模式**、组合模式、外观模式、享元模式、**代理模式** 行为型模式:模板方法模式、命令模式、访问者模式、迭代器模式、**观察者模式**、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式 #### 创建型设计模式概述 创建型模式隐藏了对象的创建细节,对象的创建由相关的工厂来完成,使用者不需要关注对象的创建细节,这样可以降低系统的耦合度。 创建型模式分为以下几种。 - 单例(Singleton)模式:某个类只能生成一个实例,该类提供了一个全局访问点供外部获取该实例,其拓展是有限多例模式。 - 原型(Prototype)模式:将一个对象作为原型,通过对其进行复制而克隆出多个和原型类似的新实例。 - 工厂方法(FactoryMethod)模式:定义一个用于创建产品的接口,由子类决定生产什么产品。 - 抽象工厂(AbstractFactory)模式:提供一个创建产品族的接口,其每个子类可以生产一系列相关的产品。 - 建造者(Builder)模式:将一个复杂对象分解成多个相对简单的部分,然后根据不同需要分别创建它们,最后构建成该复杂对象。 #### 单例模式 所谓类的单例模式设计模式,就是采取一定的方法保证在整个软件系统中,对某个类只存在一个对象实例,并且该类只提供一个取得其对象实例的方法(静态方法)。 单例模式八种创建方式 + **饿汉式(静态常量)** + **饿汉式(静态代码块)** + 懒汉式(线程不安全) + 懒汉式(线程安全,同步方法) + 懒汉式(线程安全,同步代码块) + **双重检查** + **静态内部类** + **枚举** 1. 饿汉式(静态常量) 代码实现: ```java class Singleton{ //构造器私有化 private Singleton(){ } //内部实例化对象 private final static Singleton singleton = new Singleton(); //对外提供静态方法返回实例 public static Singleton getInstance(){ return singleton; } } ``` 优缺点: 优点:这种方式比较简单,在类加载的时候就完成实例化对象,避免了线程同步问题 缺点:在类加载的时候就完成了对象实例化,没有达到懒加载的目的,如果一直没有使用这个对象的话,会造成内存浪费 这种方式是基于类加载机制实现避免了多线程同步的问题,不过,实例再类加载的时候就实例化,单例模式大多数都是调用getInstance方法,但是导致类加载的原因有很多,不能确定其它方式导致类加载,这时候初始化实例就没有达到懒加载的目的。 结论:这种设计模式可用,可能会导致内存浪费 2. 饿汉式(静态代码块) 代码实现: ```java class Singleton{ //构造器私有化 private Singleton(){ } //内部实例化对象 private final static Singleton singleton; static{ singleton = new Singleton(); } //对外提供获取实例方法 public static Singleton getInstance(){ return singleton; } } ``` 优缺点: 这种方式和上面的方式实现类似,只不过将实例化的过程放到静态代码块中,也就是类加载的时候,就执行静态代码块,初始化类的实例,优缺点和上面一样。 结论:这种设计模式可用,但是会造成内存浪费。 3. 懒汉式(线程不安全) 代码实现: ```java class Singleton{ //构造器私有化 private Singleton(){} //内部实例化对象 private static Singleton singleton; //对外提供实例化对象 public static Singleton getInstance(){ if(singleton == null){ singleton = new Singleton(); } return singleton; } } ``` 优缺点: 起到了懒加载的效果,但只能在单线程下使用,如果在多线程下一个线程进入if内部,没有来得及处理,另一个线程也进入,这样会造成创建多个实例,所有在多线程实例中不能使用。 结论:在实际开发中不要使用这种方式 4. 懒汉式(线程安全) 代码实现: ```java class Singleton{ //构造器私有化 private Singleton(){} //内部实例化对象 private static Singleton singleton; //对外提供实例化对象 public static synchronized Singleton getInstance(){ if(singleton == null){ singleton = new Singleton(); } return singleton; } } ``` 优缺点: 解决线程不安全问题,效率太低了,每个线程在想获得类的实例的时候,就执行getInstance方法都要进行同步,而其实只执行一次实例化代码就够了,后面想要获得该实例,直接return就行了,方法进行同步效率太低了。 结论:在实际开发中,不推荐这种方式 5. 懒汉式(同步代码块) 代码实现: ```java class Singleton{ //构造器私有化 private Singleton(){} //内部实例化对象 private static Singleton singleton; //对外提供实例化对象 public static Singleton getInstance(){ if(singleton == null){ synchronized (Singleton.class) { singleton = new Singleton(); } } return singleton; } } ``` 优缺点: 这种方式本来想要对第四种方式进行改进,因为前面效率太低,改为同步代码块实例化对象。**但是这种方式并不能起到线程同步作用**会产生多个实例。 结论:在实际开发中,不推荐使用。 6. 双重检查 代码实现: ```java class Singleton{ private Singleton(){} private static volatile Singleton singleton; public static Singleton getInstance(){ if(singleton == null){ synchronized (Singleton.class){ if(singleton == null){ singleton = new Singleton(); } } } return singleton; } } ``` 优缺点: 双重检查是多线程中最常用的,我们进行了二次检查,保证了多线程的安全。实例化代码只执行了一次,第二次判断,避免了反复进行同步的消耗。**线程安全,延迟加载,效率较高** 结论:在实际开发中,推荐使用这种方式 7. 静态内部类 代码演示: ```java class Singleton{ private Singleton(){ } private static class SingletonInstance{ private final static Singleton INSTANCE = new Singleton(); } public static synchronized Singleton getInstance(){ return SingletonInstance.INSTANCE; } } ``` 优缺点: 这种方式采用类加载的方式来保证初始化实例只有一个;静态内部类在类Singleton加载的时候不会立即实例化,而是在需要实例化时调用getInstance方法,才会装载SingletonInstance,从而完成Singleton实例化;类的静态属性只会在第一次加载的时候初始化,所有这里JVM保存了我们线程的安全性,在类进行初始化的时候,别的线程是无法进入的。 **避免了线程的不安全性,利用静态内部类的特点实现延迟加载,效率高**推荐使用 8. 枚举 代码实现 ```java enum Singleton{ INSTANCE; public void say(){ System.out.println("ok"); } } ``` 这里借助JDK1.5的添加的枚举来实现单例模式,不仅仅能避免多线程同步问题,而且还能避免反序列化重新创建新对象的问题。推荐使用。 单例模式在JDK源码中应用: java.lang.Runtime类: ```java public class Runtime { private static Runtime currentRuntime = new Runtime(); public static Runtime getRuntime() { return currentRuntime; } private Runtime() {} } ``` **单例模式注意事项和细节说明** + 单例模式保证了在系统内存中该类对象只有一个实例,节省了系统资源,对于一些频繁需要创建销毁的对象,使用单例模式可以提供性能。 + 当想要实例化一个单例模式的对象时,要记得使用相应的方法获取对象,而不是使用new + 单例模式的使用场景:需要频繁的创建和销毁对象时;创建对象时耗时过多或者耗费资源过多,但又经常用到的对象;工具类对象;频繁访问数据库或者文件的对象。 #### 工厂设计模式 ```java public abstract class Pizza { protected String name; public void setName(String name) { this.name = name; } //准备原材料,不同披萨材料不一样 public abstract void prepare(); //烘烤 public void bake(){ System.out.println(name + " baking "); } //切割 public void cut(){ System.out.println(name + " cutting "); } //打包 public void box(){ System.out.println(name + " boxing "); } } public class GreekPizza extends Pizza { @Override public void prepare() { System.out.println(" 给希腊披萨准备原材料 "); } } public class CheesePizza extends Pizza { @Override public void prepare() { System.out.println("给奶酪披萨准备原材料"); } } //订单类 public class OrderPizza { public OrderPizza(){ Pizza pizza = null; String orderType;//披萨类型 do{ orderType = getType(); if(orderType.equals("greek")){ pizza = new GreekPizza(); pizza.setName("希腊披萨"); }else if(orderType.equals("cheese")){ pizza = new CheesePizza(); pizza.setName("奶酪披萨"); }else{ break; } //披萨制作过程 pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box(); }while (true); } //获得希望制作的披萨种类 private String getType(){ try{ BufferedReader strin = new BufferedReader(new InputStreamReader(System.in)); System.out.println("input pizza type: "); String str = strin.readLine(); return str; } catch (IOException e) { e.printStackTrace(); return ""; } } } //相当于客户端 public class PizzaStore { public static void main(String[] args) { new OrderPizza(); } } //存在的问题,当我们新增一个披萨种类的时候,我们需要修改订单类中的逻辑,违反了OCP原则,扩展开发,修改关闭。如果有很多地方都使用到这个订单类,我们就需要修改很多地方。 ``` 修改思路:我们把新建Pizza封装在一个类中,这样当有新的披萨时,我们只需要修改这个类即可,其它有创建到Pizza对象的代码就不需要修改了---简单工厂模式 简单工厂类是属于创建型模式,是工厂模式的一种,简单工厂模式是由一个工厂对象决定创建出哪一种产品类实例,简单工厂模式是工厂模式家族中最实用最简单的模式。 简单工厂模式定义了一个创建对象工厂类,由这个类来封装实例化对象的行为(过程) 在软件开发过程中,我们会用到大量的创建某种、某类、某批对象时,就会使用到工厂模式。 改进代码演示: ```java //简单工厂类 public class SimpleFactory { public Pizza create(String orderType){ Pizza pizza = null; if(orderType.equals("greek")){ pizza = new GreekPizza(); pizza.setName("希腊披萨"); }else if(orderType.equals("cheese")){ pizza = new CheesePizza(); pizza.setName("奶酪披萨"); }else if(orderType.equals("pepper")){ pizza = new PepperPizza(); pizza.setName("胡椒披萨"); } return pizza; } } public class OrderPizza { SimpleFactory simpleFactory; Pizza pizza; public void setSimpleFactory(SimpleFactory simpleFactory){ this.simpleFactory = simpleFactory; do{ String orderType = getType();//获取类型 pizza = this.simpleFactory.create(orderType); if(pizza != null){ System.out.println("订购披萨成功"); pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box(); }else{ System.out.println("订购披萨失败"); break; } }while(true); } public OrderPizza(SimpleFactory simpleFactory){ setSimpleFactory(simpleFactory); } //获得希望制作的披萨种类 private String getType(){ try{ BufferedReader strin = new BufferedReader(new InputStreamReader(System.in)); System.out.println("input pizza type: "); String str = strin.readLine(); return str; } catch (IOException e) { e.printStackTrace(); return ""; } } } //相当于客户端 public class PizzaStore { public static void main(String[] args) { new OrderPizza(new SimpleFactory()); } } ``` 当新增一种披萨时候,订单类和客户端都不需要修改,只需要修改工厂即可。简单工厂模式也可以写成静态的方法,静态简单工厂模式,代码如下: ```java public class SimpleStaticFactory { public static Pizza create(String orderType){ Pizza pizza = null; if(orderType.equals("greek")){ pizza = new GreekPizza(); pizza.setName("希腊披萨"); }else if(orderType.equals("cheese")){ pizza = new CheesePizza(); pizza.setName("奶酪披萨"); }else if(orderType.equals("pepper")){ pizza = new PepperPizza(); pizza.setName("胡椒披萨"); } return pizza; } } public class OrderPizza1 { Pizza pizza; String orderType; //获得希望制作的披萨种类 private String getType(){ try{ BufferedReader strin = new BufferedReader(new InputStreamReader(System.in)); System.out.println("input pizza type: "); String str = strin.readLine(); return str; } catch (IOException e) { e.printStackTrace(); return ""; } } public OrderPizza1(){ do{ String orderType = getType();//获取类型 pizza = SimpleStaticFactory.create(orderType); if(pizza != null){ System.out.println("订购披萨成功"); pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box(); }else{ System.out.println("订购披萨失败"); break; } }while(true); } } ``` #### 工厂方法模式 定义一个创建对象的抽象方法,由子类决定要实例化的类,工厂方法模式将对象实例化推迟到子类。 代码演示: ```java public abstract class Pizza { protected String name; public abstract void prepare(); public void bake(){ System.out.println(name + " baking "); } public void cut(){ System.out.println(name + " cutting "); } public void box(){ System.out.println(name + " boxing "); } public void setName(String name){ this.name = name; } } public class BJCheesePizza extends Pizza { @Override public void prepare() { System.out.println("准备北京奶酪披萨"); } } public class BJGreekPizza extends Pizza { @Override public void prepare() { System.out.println("准备北京希腊披萨"); } } public abstract class OrderPizza { Pizza pizza; //获得希望制作的披萨种类 private String getType(){ try{ BufferedReader strin = new BufferedReader(new InputStreamReader(System.in)); System.out.println("input pizza type: "); String str = strin.readLine(); return str; } catch (IOException e) { e.printStackTrace(); return ""; } } public abstract Pizza create(String orderType); public OrderPizza(){ do{ String orderType = getType(); pizza = create(orderType); if(pizza != null){ System.out.println("订购披萨成功"); pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box(); }else{ System.out.println("订购披萨失败"); break; } }while (true); } } public class LDOrderPizza extends OrderPizza { @Override public Pizza create(String orderType) { Pizza pizza = null; if(orderType.equals("greek")){ pizza = new LDGreekPizza(); pizza.setName("伦敦希腊披萨"); }else if(orderType.equals("cheese")){ pizza = new LDCheesePizza(); pizza.setName("伦敦奶酪披萨"); } return pizza; } } public class BJOrderPizza extends OrderPizza{ @Override public Pizza create(String orderType) { Pizza pizza = null; if(orderType.equals("greek")){ pizza = new BJGreekPizza(); pizza.setName("北京希腊披萨"); }else if(orderType.equals("cheese")){ pizza = new BJCheesePizza(); pizza.setName("北京奶酪披萨"); } return pizza; } } public class PizzaStore { public static void main(String[] args) { new LDOrderPizza(); } } ``` #### 抽象工厂模式 抽象工厂模式:定义一个interface用于创建相关或者有依赖关系的对象族,而无须指明具体的类。 抽象工厂模式:可以将简单工厂模式和工厂方法模式进行整合 从设计层面看,抽象工厂模式就是对简单工厂模式的改进。 将工厂抽象成二层,抽象工厂和具体实现的工厂子类,程序员可以根据创建对象类型使用对用的工厂子类,这样将单个简单工厂变成工厂族更利于代码的维护和扩展。 ```java public abstract class Pizza { protected String name; public void setName(String name) { this.name = name; } public abstract void prepare(); public void bake(){ System.out.println(name + " baking"); } public void cut(){ System.out.println(name + " cutting "); } public void box(){ System.out.println(name + " boxing "); } } public class BJCheesePizza extends Pizza { @Override public void prepare() { setName("北京奶酪披萨"); System.out.println("准备北京奶酪披萨"); } } public class BJGreenPizza extends Pizza { @Override public void prepare() { setName("北京希腊披萨"); System.out.println("准备北京希腊披萨"); } } public interface absFactory { Pizza create(String orderType); } public class BJFactory implements absFactory { @Override public Pizza create(String orderType) { Pizza pizza = null; if("greek".equals(orderType)){ pizza = new BJGreenPizza(); }else if("cheese".equals(orderType)){ pizza = new BJCheesePizza(); } return pizza; } } public class LDFactory implements absFactory { @Override public Pizza create(String orderType) { Pizza pizza = null; if("greek".equals(orderType)){ pizza = new LDGreenPizza(); }else if("cheese".equals(orderType)){ pizza = new LDCheesePizza(); } return pizza; } } public class OrderPizza { Pizza pizza; absFactory absFactory; //获得希望制作的披萨种类 private String getType(){ try{ BufferedReader strin = new BufferedReader(new InputStreamReader(System.in)); System.out.println("input pizza type: "); String str = strin.readLine(); return str; } catch (IOException e) { e.printStackTrace(); return ""; } } private void setAbsFactory(absFactory absFactory){ this.absFactory = absFactory; do{ String orderType = getType(); pizza = this.absFactory.create(orderType); if(pizza != null){ System.out.println("订购成功"); pizza.prepare(); pizza.bake(); pizza.cut(); pizza.box(); }else{ System.out.println("订购失败"); break; } }while(true); } public OrderPizza(absFactory absFactory){ setAbsFactory(absFactory); } } ``` **工厂模式在JDK源码中的应用** ```java Calendar calendar = Calendar.getInstance(); //Debug源码 public static Calendar getInstance() { return createCalendar(TimeZone.getDefault(), Locale.getDefault(Locale.Category.FORMAT)); } private static Calendar createCalendar(TimeZone zone, Locale aLocale) { CalendarProvider provider = LocaleProviderAdapter.getAdapter(CalendarProvider.class, aLocale) .getCalendarProvider(); if (provider != null) { try { return provider.getInstance(zone, aLocale); } catch (IllegalArgumentException iae) { // fall back to the default instantiation } } Calendar cal = null; if (aLocale.hasExtensions()) { String caltype = aLocale.getUnicodeLocaleType("ca"); if (caltype != null) { switch (caltype) { case "buddhist": cal = new BuddhistCalendar(zone, aLocale); break; case "japanese": cal = new JapaneseImperialCalendar(zone, aLocale); break; case "gregory": cal = new GregorianCalendar(zone, aLocale); break; } } } if (cal == null) { // If no known calendar type is explicitly specified, // perform the traditional way to create a Calendar: // create a BuddhistCalendar for th_TH locale, // a JapaneseImperialCalendar for ja_JP_JP locale, or // a GregorianCalendar for any other locales. // NOTE: The language, country and variant strings are interned. if (aLocale.getLanguage() == "th" && aLocale.getCountry() == "TH") { cal = new BuddhistCalendar(zone, aLocale); } else if (aLocale.getVariant() == "JP" && aLocale.getLanguage() == "ja" && aLocale.getCountry() == "JP") { cal = new JapaneseImperialCalendar(zone, aLocale); } else { cal = new GregorianCalendar(zone, aLocale); } } return cal; } ``` **工厂模式总结:** 工厂模式的意义: 将实例化对象的方法提取出来,放到一个类中进行统一的管理和维护,达到和主项目的依赖解耦,从而提高项目的扩展性和维护性。 三种工厂模式:简单工厂模式、工厂方法模式、抽象工厂模式 工厂模式的依赖倒转原则 创建对象的时候,不要直接使用new,而是把创建对象这个动作放在一个工厂方法里面,并返回,有的书上面说,变量不要直接持有具体类引用 不要让类继承具体类,而是让类继承抽象类或者实现接口 不要覆盖基类已经实现的方法 #### 原型模式 羊克隆的问题,如果我们要将一个羊,名叫Tom,年龄10,颜色白色复制10份 传统方法:new 10次 ```java public class Sheep { private String name; private int age; private String color; public Sheep(String name, int age, String color) { this.name = name; this.age = age; this.color = color; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } } Sheep sheep = new Sheep("Tom",10,"白色"); Sheep sheep1 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor()); Sheep sheep2 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor()); Sheep sheep3 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor()); Sheep sheep4 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor()); Sheep sheep5 = new Sheep(sheep.getName(),sheep.getAge(),sheep.getColor()); ``` 优缺点: 比较好理解,容易操作;在创建对象时,总是需要获取原始对象的属性,如果创建对象比较复制时,效率比较低;总是需要重新初始化对象,而不是动态获取对象运行时状态,不够灵活 改进思路:在java中Object类有一个clone方法,能够复制对象,复制的对象类要实现Cloneable接口,表示可以复制且具有复制的能力。 ```java public class Sheep implements Cloneable{ private String name; private int age; private String color; public Sheep(String name, int age, String color) { this.name = name; this.age = age; this.color = color; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } @Override public String toString() { return "Sheep{" + "name='" + name + '\'' + ", age=" + age + ", color='" + color + '\'' + '}'; } @Override protected Object clone(){ Sheep sheep = null; try{ sheep = (Sheep)super.clone(); } catch (CloneNotSupportedException e) { System.out.println(e.getMessage()); } return sheep; } } ``` 原型模式:是指用原型实例指定创建的种类,并且通过拷贝这些原型,创建新的对象。 原型模式:是一种创建型设计模式,允许一个对象再创建一个可定制的对象,无须知道如何创建对象的细节 深拷贝介绍: + 复制所有基本数据类型的成员变量的值 + 为所有引用数据类型的变量申请空间,并复制每个引用类型的成员变量所引用的对象,直到该对象可达的所有对象,也就是说,对对象进行深拷贝,就是要对整个对象进行拷贝。 + 深拷贝实现方式1:重写clone方法进行深拷贝 + 深拷贝方式实现2:通过对象序列化实现深拷贝 ```java public class DeepCloneTarget implements Serializable,Cloneable { private static final long SerialVersionUID = 1L; private String cloneName; private String cloneClass; public DeepCloneTarget(String cloneName, String cloneClass) { this.cloneName = cloneName; this.cloneClass = cloneClass; } @Override protected Object clone() throws CloneNotSupportedException { return super.clone(); } } public class DeepProtoType implements Serializable,Cloneable { private String name; private DeepCloneTarget deepCloneTarget; public void setDeepCloneTarget(DeepCloneTarget deepCloneTarget) { this.deepCloneTarget = deepCloneTarget; } public void setName(String name) { this.name = name; } public String getName() { return name; } public DeepCloneTarget getDeepCloneTarget() { return deepCloneTarget; } public DeepProtoType() { super(); } //完成深拷贝 @Override protected Object clone() throws CloneNotSupportedException { Object deep = null; //先对基本类型进行拷贝 deep = super.clone(); //对引用类型进行拷贝 DeepProtoType deepProtoType = (DeepProtoType) deep; deepProtoType.deepCloneTarget = (DeepCloneTarget) deepCloneTarget.clone(); return deepProtoType; } //使用序列化完成对象拷贝推荐 public DeepProtoType deepClone(){ //创建流对象 ByteArrayInputStream bis = null; ByteArrayOutputStream bos = null; ObjectInputStream ois = null; ObjectOutputStream oos = null; try{ //序列化 bos = new ByteArrayOutputStream(); oos = new ObjectOutputStream(bos); oos.writeObject(this);//当前这个对象以流的方式输出 //反序列化 bis = new ByteArrayInputStream(bos.toByteArray()); ois = new ObjectInputStream(bis); DeepProtoType deepCopy = (DeepProtoType) ois.readObject(); return deepCopy; } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); return null; }finally { //关闭流资源 try{ bos.close(); bis.close(); ois.close(); oos.close(); } catch (IOException e) { e.printStackTrace(); } } } } ``` 原型模式注意事项: + 创建新的对象比较复制的时候,可以利用原型模式简化对象的创建过程,也能够提高效率。 + 不用重新初始化对象,而是动态获得对象的状态 + 如果原始对象发生变化,其它克隆对象也会发生相应的变化,无须修改代码。 + 在实现深克隆的时候可能需要比较复杂的代码 + 缺点:需要为每一个类配备一个方法,对新类来说不是很难,但是对于已经存在的类来说违法OCP原则 原型模式通常适用于以下场景。 - 对象之间相同或相似,即只是个别的几个属性不同的时候。 - 创建对象成本较大,例如初始化时间长,占用CPU太多,或者占用网络资源太多等,需要优化资源。 - 创建一个对象需要繁琐的数据准备或访问权限等,需要提高性能或者提高安全性。 - 系统中大量使用该类对象,且各个调用者都需要给它的属性重新赋值。 #### 建造者模式 ```java public abstract class AbstractHouse { public abstract void buildBaisc(); public abstract void buildWall(); public abstract void roofed(); public void build(){ buildBaisc(); buildWall(); roofed(); } } public class CommonHouse extends AbstractHouse { @Override public void buildBaisc() { System.out.println("普通房子打地基"); } @Override public void buildWall() { System.out.println("普通房子建墙"); } @Override public void roofed() { System.out.println("普通房子盖房顶"); } } CommonHouse commonHouse = new CommonHouse(); commonHouse.build(); ``` 这种方式比较简单,容易理解,容易操作,设计的程序结构,过于简单,没有设置缓存层对象,程序的扩展维护不容易,也就是说,这种方式把产品和创建产品的过程封装在一起,程序的耦合性很强 解决方案:把产品和产品建造过程解耦,这就是建造者模式 建造者模式又叫生成器模式,把复杂对象的建造过程抽象出来,使这个抽象出来的过程不同的实现方式可以构建出不同的对象。一步一步构建复杂的对象,它允许用户指定复杂的类型和内容就可以构建他们,用户不需要知道具体的构建细节。 建造者模式有四个角色: Product(产品角色):一个具体的产品对象 Builder(抽象构建者):创建一个Product对象的各个部件指定的接口或者抽象类 ConcreteBuilder(具体构建者):实现接口,构建和装备各个部件 Director(指挥者):构建一个使用Builder接口的对象,它主要是用于创建一个复杂的对象,它主要有两个作用:隔离客户和对象生成过程;负责控制产品对象的生成过程 ```java public class House { private String baise; private String wall; private String roofed; public String getBaise() { return baise; } public void setBaise(String baise) { this.baise = baise; } public String getWall() { return wall; } public void setWall(String wall) { this.wall = wall; } public String getRoofed() { return roofed; } public void setRoofed(String roofed) { this.roofed = roofed; } } public abstract class HouseBuilder { //组合House House house = new House(); public abstract void buildBasic(); public abstract void buildWall(); public abstract void buildRoofed(); public House buildHouse(){ return house; } } public class CommonBuilder extends HouseBuilder { @Override public void buildBasic() { System.out.println("普通房子打地基10米"); } @Override public void buildWall() { System.out.println("普通房子建墙10cm"); } @Override public void buildRoofed() { System.out.println("普通房子盖屋顶"); } } public class HightBuilder extends HouseBuilder { @Override public void buildBasic() { System.out.println("高楼打地基100米"); } @Override public void buildWall() { System.out.println("高楼建墙20cm"); } @Override public void buildRoofed() { System.out.println("高楼盖楼顶"); } } public class HouseDirector { private HouseBuilder houseBuilder; //通过构造方式赋值 public HouseDirector(HouseBuilder houseBuilder) { this.houseBuilder = houseBuilder; } //通过setter方法赋值 public void setHouseBuilder(HouseBuilder houseBuilder) { this.houseBuilder = houseBuilder; } public House constructHouse(){ houseBuilder.buildBasic(); houseBuilder.buildWall(); houseBuilder.buildRoofed(); return houseBuilder.buildHouse(); } } CommonBuilder commonBuilder = new CommonBuilder(); //构建者 HouseDirector houseDirector = new HouseDirector(commonBuilder); House house = houseDirector.constructHouse(); //构建大厦 HightBuilder hightBuilder = new HightBuilder(); houseDirector.setHouseBuilder(hightBuilder); House house1 = houseDirector.constructHouse(); ``` 建造者模式唯一区别于工厂模式的是针对复杂对象的创建。也就是说,如果创建简单对象,通常都是使用工厂模式进行创建,而如果创建复杂对象,就可以考虑使用建造者模式。 当需要创建的产品具备复杂创建过程时,可以抽取出共性创建过程,然后交由具体实现类自定义创建流程,使得同样的创建行为可以生产出不同的产品,分离了创建与表示,使创建产品的灵活性大大增加。 建造者模式主要适用于以下应用场景: - 相同的方法,不同的执行顺序,产生不同的结果。 - 多个部件或零件,都可以装配到一个对象中,但是产生的结果又不相同。 - 产品类非常复杂,或者产品类中不同的调用顺序产生不同的作用。 - 初始化一个对象特别复杂,参数多,而且很多参数都具有默认值。 工厂模式和建造者模式的区别: - 建造者模式更加注重方法的调用顺序,工厂模式注重创建对象。 - 创建对象的力度不同,建造者模式创建复杂的对象,由各种复杂的部件组成,工厂模式创建出来的对象都一样 - 关注重点不一样,工厂模式只需要把对象创建出来就可以了,而建造者模式不仅要创建出对象,还要知道对象由哪些部件组成。 - 建造者模式根据建造过程中的顺序不一样,最终对象部件组成也不一样。 #### 结构性设计模式 结构型模式描述如何将类或对象按某种布局组成更大的结构。它分为类结构型模式和对象结构型模式,前者采用继承机制来组织接口和类,后者釆用组合或聚合来组合对象。由于组合关系或聚合关系比继承关系耦合度低,满足“合成复用原则”,所以对象结构型模式比类结构型模式具有更大的灵活性。 结构型模式分为以下 7 种: 1. 代理(Proxy)模式:为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象,从而限制、增强或修改该对象的一些特性。 2. 适配器(Adapter)模式:将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。 3. 桥接(Bridge)模式:将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现的,从而降低了抽象和实现这两个可变维度的耦合度。 4. 装饰(Decorator)模式:动态地给对象增加一些职责,即增加其额外的功能。 5. 外观(Facade)模式:为多个复杂的子系统提供一个一致的接口,使这些子系统更加容易被访问。 6. 享元(Flyweight)模式:运用共享技术来有效地支持大量细粒度对象的复用。 7. 组合(Composite)模式:将对象组合成树状层次结构,使用户对单个对象和组合对象具有一致的访问性。 以上 7 种结构型模式,除了适配器模式分为类结构型模式和对象结构型模式两种,其他的全部属于对象结构型模式。 #### 适配器模式 将某个类的接口转换成客户端期望的另一种接口表示,主要目的是兼容性,让原本因接口不匹配的两个类能够在一起工作,其别名是包装器类:Warpper 适配器模式是结构性模式 主要分为三类:类适配器、对象适配器、接口适配器 该模式的主要优点如下: - 客户端通过适配器可以透明地调用目标接口。 - 复用了现存的类,程序员不需要修改原有代码而重用现有的适配者类。 - 将目标类和适配者类解耦,解决了目标类和适配者类接口不一致的问题。 - 在很多业务场景中符合开闭原则。 其缺点是: - 适配器编写过程需要结合业务场景全面考虑,可能会增加系统的复杂性。 - 增加代码阅读难度,降低代码可读性,过多使用适配器会使系统代码变得凌乱。 ```java public class Voltage220V { public int output220V(){ int src = 220; System.out.println("电压为:" + src + "V"); return src; } } public interface IVoltage5V { public int output5V(); } public class VoltageAdapter extends Voltage220V implements IVoltage5V { @Override public int output5V() { int src = output220V(); int desc = src / 44;//降压处理 return desc; } } public class Phone { //手机充电 public void charging(IVoltage5V iVoltage5V){ if(iVoltage5V.output5V() == 5){ System.out.println("电压为5V手机可以正常充电"); }else if(iVoltage5V.output5V() > 5){ System.out.println("电压大于5V,手机不能充电"); } } } public class Client { public static void main(String[] args) { IVoltage5V iVoltage5V = new VoltageAdapter(); Phone phone = new Phone(); phone.charging(iVoltage5V); } } ``` 类适配器模式注意事项和细节 + Java是单继承,所以类适配器继承src类算是一个缺点,这要求desc必须是一个接口,这算一个局限性 + src类中的方法都会在适配器类中暴露,这增加使用成本 + 由于继承src类,所以可以根据需求重写方法,使得适配器类灵活性增强 **对象适配器模式** 基本思路跟类适配器一样,只是将适配器修改,不是继承src类,而是持有src类的实例,以解决兼容性问题,持有src类,实现desc类接口,完成适配。 根据合成复用原则,尽量使用关联关系代替继承关系 **对象适配器是适配器模式最常用的一种** ```java public class VoltageAdapter implements IVoltage5V { private Voltage220V voltage220V; public VoltageAdapter(Voltage220V voltage220V) { this.voltage220V = voltage220V; } @Override public int output5V() { int desc = 0; if(null != voltage220V){ System.out.println("使用对象适配器进行处理"); int src = voltage220V.output220V(); desc = src / 44; System.out.println("降压之后的电压为:" + desc); } return desc; } } ``` 跟类适配器差不多,只是将继承的方式改为聚合的方式,成本更低,更加灵活。 **接口适配器模式** 当不需要实现接口的全部方法时,我们可以通过一个抽象类实现接口的方法,并为该接口中的每一个方法都提供一个默认实现(空方法),那么该抽象类的子类可以有选择性的覆盖父类的方法来实现需求 适用于一个接口不想使用其所有方法的情况 ```java public interface Interface { void m1(); void m2(); void m3(); } public abstract class AbsInterface implements Interface { //给接口中的所有方法增加默认实现 @Override public void m1() { } @Override public void m2() { } @Override public void m3() { } } AbsInterface absInterface = new AbsInterface() { @Override public void m2() { System.out.println("使用匿名内部类覆盖抽象类方法"); } }; absInterface.m2(); ``` 例题:新能源汽车的发动机有电能发动机(Electric Motor)和光能发动机(Optical Motor)等,各种发动机的驱动方法不同,例如,电能发动机的驱动方法 electricDrive() 是用电能驱动,而光能发动机的驱动方法 opticalDrive() 是用光能驱动,它们是适配器模式中被访问的适配者。 客户端希望用统一的发动机驱动方法 drive() 访问这两种发动机,所以必须定义一个统一的目标接口 Motor,然后再定义电能适配器(Electric Adapter)和光能适配器(Optical Adapter)去适配这两种发动机。 ```java //适配者1 public class ElectricMotor { public void electricDriver(){ System.out.println("用电能进行驱动汽车"); } } //适配者2 public class OpticalMotor { public void opticalDriver(){ System.out.println("用光能驱动汽车"); } } //目标接口 public interface Motor { void driver(); } //适配者1适配器 public class ElectricAdapter implements Motor { private ElectricMotor electricMotor; public ElectricAdapter(ElectricMotor electricMotor) { this.electricMotor = electricMotor; } @Override public void driver() { electricMotor.electricDriver(); } } //适配者2适配器 public class ObjectAdapter implements Target { private Adaptee adaptee; public ObjectAdapter(Adaptee adaptee) { this.adaptee = adaptee; } @Override public void request() { adaptee.specificRequest(); } } ``` 适配器模式(Adapter)通常适用于以下场景。 - 以前开发的系统存在满足新系统功能需求的类,但其接口同新系统的接口不一致。 - 使用第三方提供的组件,但组件接口定义和自己要求的接口定义不同。 #### 桥接模式 桥接(Bridge)模式的定义如下:将抽象与实现分离,使它们可以独立变化。它是用组合关系代替继承关系来实现,从而降低了抽象和实现这两个可变维度的耦合度。 通过上面的讲解,我们能很好的感觉到桥接模式遵循了里氏替换原则和依赖倒置原则,最终实现了开闭原则,对修改关闭,对扩展开放。这里将桥接模式的优缺点总结如下。 桥接(Bridge)模式的优点是: - 抽象与实现分离,扩展能力强 - 符合开闭原则 - 符合合成复用原则 - 其实现细节对客户透明 缺点是:由于聚合关系建立在抽象层,要求开发者针对抽象化进行设计与编程,能正确地识别出系统中两个独立变化的维度,这增加了系统的理解与设计难度。 可以将抽象化部分与实现化部分分开,取消二者的继承关系,改用组合关系。 **模式结构** 桥接(Bridge)模式包含以下主要角色。 1. 抽象化(Abstraction)角色:定义抽象类,并包含一个对实现化对象的引用。 2. 扩展抽象化(Refined Abstraction)角色:是抽象化角色的子类,实现父类中的业务方法,并通过组合关系调用实现化角色中的业务方法。 3. 实现化(Implementor)角色:定义实现化角色的接口,供扩展抽象化角色调用。 4. 具体实现化(Concrete Implementor)角色:给出实现化角色接口的具体实现。 ```java public interface Brand { void open(); void close(); void call(); } public class Mi implements Brand { @Override public void open() { System.out.println("Mi开机"); } @Override public void close() { System.out.println("Mi关机"); } @Override public void call() { System.out.println("Mi手机打电话"); } } public class Vivo implements Brand { @Override public void open() { System.out.println("Vivo开机"); } @Override public void close() { System.out.println("Vivo关机"); } @Override public void call() { System.out.println("Vivo打电话"); } } public abstract class Phone { private Brand brand; public Phone(Brand brand) { this.brand = brand; } public void open(){ brand.open(); } public void close(){ brand.close(); } public void call(){ brand.call(); } } public class FoldedPhone extends Phone { public FoldedPhone(Brand brand) { super(brand); } @Override public void open() { super.open(); System.out.println("折叠式手机"); } @Override public void close() { super.close(); System.out.println("折叠式手机"); } @Override public void call() { super.call(); System.out.println("折叠式手机"); } } Vivo vivo = new Vivo(); Phone phone = new FoldedPhone(vivo); phone.open(); phone.call(); phone.close(); ``` 当一个类内部具备两种或多种变化维度时,使用桥接模式可以解耦这些变化的维度,使高层代码架构稳定。 桥接模式通常适用于以下场景。 1. 当一个类存在两个独立变化的维度,且这两个维度都需要进行扩展时。 2. 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。 3. 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。 桥接模式的一个常见使用场景就是替换继承。我们知道,继承拥有很多优点,比如,抽象、封装、多态等,父类封装共性,子类实现特性。继承可以很好的实现代码复用(封装)的功能,但这也是继承的一大缺点。 因为父类拥有的方法,子类也会继承得到,无论子类需不需要,这说明继承具备强侵入性(父类代码侵入子类),同时会导致子类臃肿。因此,在设计模式中,有一个原则为优先使用组合/聚合,而不是继承。很多时候,我们分不清该使用继承还是组合/聚合或其他方式等,其实可以从现实语义进行思考。因为软件最终还是提供给现实生活中的人使用的,是服务于人类社会的,软件是具备现实场景的。当我们从纯代码角度无法看清问题时,现实角度可能会提供更加开阔的思路。 常见应用场景: JDBC驱动、银行转账系统、消息管理 #### 装饰者设计模式 在软件开发过程中,有时想用一些现存的组件。这些组件可能只是完成了一些核心功能。但在不改变其结构的情况下,可以动态地扩展其功能。所有这些都可以釆用装饰器模式来实现。 装饰器(Decorator)模式的定义:指在不改变现有对象结构的情况下,动态地给该对象增加一些职责(即增加其额外功能)的模式,它属于对象结构型模式。 装饰器模式的主要优点有: - 装饰器是继承的有力补充,比继承灵活,在不改变原有对象的情况下,动态的给一个对象扩展功能,即插即用 - 通过使用不用装饰类及这些装饰类的排列组合,可以实现不同效果 - 装饰器模式完全遵守开闭原则 其主要缺点是:装饰器模式会增加许多子类,过度使用会增加程序得复杂性。 通常情况下,扩展一个类的功能会使用继承方式来实现。但继承具有静态特征,耦合度高,并且随着扩展功能的增多,子类会很膨胀。如果使用组合关系来创建一个包装对象(即装饰对象)来包裹真实对象,并在保持真实对象的类结构不变的前提下,为其提供额外的功能,这就是装饰器模式的目标。下面来分析其基本结构和实现方法。 **模式的结构** 装饰器模式主要包含以下角色。 1. 抽象构件(Component)角色:定义一个抽象接口以规范准备接收附加责任的对象。 2. 具体构件(ConcreteComponent)角色:实现抽象构件,通过装饰角色为其添加一些职责。 3. 抽象装饰(Decorator)角色:继承抽象构件,并包含具体构件的实例,可以通过其子类扩展具体构件的功能。 4. 具体装饰(ConcreteDecorator)角色:实现抽象装饰的相关方法,并给具体构件对象添加附加的责任。 ```java //抽象饮料类 public abstract class Drink { public String desc; private double price; public String getDesc() { return desc; } public void setDesc(String desc) { this.desc = desc; } public double getPrice() { return price; } public void setPrice(double price) { this.price = price; } public abstract double cost(); } //抽象咖啡类 public abstract class Coffee extends Drink { @Override public double cost(){ return super.getPrice(); } } //具体咖啡类 public class Espresso extends Coffee { public Espresso(){ setPrice(60.0); setDesc("意大利咖啡"); } @Override public String getDesc() { return super.getDesc(); } } public class LongBlack extends Coffee { public LongBlack(){ setDesc("美式咖啡"); setPrice(88.0); } } //装饰类,内部组合被装饰类并且继承装饰类 public class Decorator extends Drink { private Drink drink; public Decorator(Drink drink) { this.drink = drink; } @Override public double cost() { //当前配料价格+单品的价格 return super.getPrice() + drink.cost(); } @Override public String getDesc() { return desc + " " + getPrice() + "&&" + drink.getDesc(); } } public class Chocolate extends Decorator { public Chocolate(Drink drink) { super(drink); setDesc("巧克力"); setPrice(12.0); } } public class Milk extends Decorator { public Milk(Drink drink) { super(drink); setDesc("牛奶"); setPrice(9.0); } } Drink drink = new Espresso(); System.out.println("费用1:" + drink.getDesc() + "," + drink.cost()); drink = new Chocolate(drink); System.out.println("加入巧克力之后费用2:" + drink.getDesc() + "," + drink.cost()); drink = new Milk(drink); System.out.println("加入牛奶之后费用3:" + drink.getDesc() + "," + drink.cost()); ``` 前面讲解了关于装饰器模式的结构与特点,下面介绍其适用的应用场景,装饰器模式通常在以下几种情况使用。 - 当需要给一个现有类添加附加职责,而又不能采用生成子类的方法进行扩充时。例如,该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。 - 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时,采用继承关系很难实现,而采用装饰器模式却很好实现。 - 当对象的功能要求可以动态地添加,也可以再动态地撤销时。 装饰器模式在 Java语言中的最著名的应用莫过于 Java I/O 标准库的设计了。例如,InputStream 的子类 FilterInputStream,OutputStream 的子类 FilterOutputStream,Reader 的子类 BufferedReader 以及 FilterReader,还有 Writer 的子类 BufferedWriter、FilterWriter 以及 PrintWriter 等,它们都是抽象装饰类。 在JDK源码的IO系统中有使用。 #### 组合模式 组合(Composite Pattern)模式的定义:有时又叫作整体-部分(Part-Whole)模式,它是一种将对象组合成树状的层次结构的模式,用来表示“整体-部分”的关系,使用户对单个对象和组合对象具有一致的访问性,属于结构型设计模式。 组合模式一般用来描述整体与部分的关系,它将对象组织到树形结构中,顶层的节点被称为根节点,根节点下面可以包含树枝节点和叶子节点,树枝节点下面又可以包含树枝节点和叶子节点, 组合模式的主要优点有: 1. 组合模式使得客户端代码可以一致地处理单个对象和组合对象,无须关心自己处理的是单个对象,还是组合对象,这简化了客户端代码; 2. 更容易在组合体内加入新的对象,客户端不会因为加入了新的对象而更改源代码,满足“开闭原则”; 其主要缺点是: 1. 设计较复杂,客户端需要花更多时间理清类之间的层次关系; 2. 不容易限制容器中的构件; 3. 不容易用继承的方法来增加构件的新功能; 组合模式包含以下主要角色。 1. 抽象构件(Component)角色:它的主要作用是为树叶构件和树枝构件声明公共接口,并实现它们的默认行为。在透明式的组合模式中抽象构件还声明访问和管理子类的接口;在安全式的组合模式中不声明访问和管理子类的接口,管理工作由树枝构件完成。(总的抽象类或接口,定义一些通用的方法,比如新增、删除) 2. 树叶构件(Leaf)角色:是组合中的叶节点对象,它没有子节点,用于继承或实现抽象构件。 3. 树枝构件(Composite)角色 / 中间构件:是组合中的分支节点对象,它有子节点,用于继承和实现抽象构件。它的主要作用是存储和管理子部件,通常包含 Add()、Remove()、GetChild() 等方法。 组合模式分为透明式的组合模式和安全式的组合模式。 ```java public abstract class OrganizationComponent { private String name; private String desc; public OrganizationComponent(String name, String desc) { this.name = name; this.desc = desc; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getDesc() { return desc; } public void setDesc(String desc) { this.desc = desc; } public void add(OrganizationComponent organizationComponent){ throw new UnsupportedOperationException(); } public void remove(OrganizationComponent organizationComponent){ throw new UnsupportedOperationException(); } public abstract void print(); } public class University extends OrganizationComponent { private List organizationComponents = new ArrayList<>(); public University(String name, String desc) { super(name, desc); } @Override public void add(OrganizationComponent organizationComponent) { organizationComponents.add(organizationComponent); } @Override public void remove(OrganizationComponent organizationComponent) { organizationComponents.remove(organizationComponent); } @Override public void print() { System.out.println("----------"+getName() + "----------"); for(OrganizationComponent o: organizationComponents){ o.print(); } } } public class College extends OrganizationComponent { private List organizationComponents = new ArrayList<>(); @Override public void add(OrganizationComponent organizationComponent) { organizationComponents.add(organizationComponent); } @Override public void remove(OrganizationComponent organizationComponent) { organizationComponents.remove(organizationComponent); } public College(String name, String desc) { super(name, desc); } @Override public void print() { System.out.println("-----" + getName() + "-----"); for(OrganizationComponent o: organizationComponents){ o.print(); } } } public class Department extends OrganizationComponent { public Department(String name, String desc) { super(name, desc); } @Override public void print() { System.out.println(getName()); } } OrganizationComponent university = new University("武汉工程大学", "武汉的一所大学"); OrganizationComponent ComputerCollege = new College("计算机学院", "计算机学院"); OrganizationComponent InfoEngineer = new College("信息学院", "信息学院"); ComputerCollege.add(new Department("计算机科学与技术","一个传统专业")); ComputerCollege.add(new Department("软件工程","一个不错专业")); InfoEngineer.add(new Department("通信工程","一个不好学的专业")); InfoEngineer.add(new Department("信息工程","一个好学的专业")); university.add(ComputerCollege); university.add(InfoEngineer); university.print(); ``` 在JDK中集合中有应用,HashMap #### 外观模式 外观(Facade)模式又叫作门面模式,是一种通过为多个复杂的子系统提供一个一致的接口,而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口,外部应用程序不用关心内部子系统的具体细节,这样会大大降低应用程序的复杂度,提高了程序的可维护性。 在日常编码工作中,我们都在有意无意的大量使用外观模式。只要是高层模块需要调度多个子系统(2个以上的类对象),我们都会自觉地创建一个新的类封装这些子系统,提供精简的接口,让高层模块可以更加容易地间接调用这些子系统的功能。尤其是现阶段各种第三方SDK、开源类库,很大概率都会使用外观模式。 外观(Facade)模式是“迪米特法则”的典型应用,它有以下主要优点。 1. 降低了子系统与客户端之间的耦合度,使得子系统的变化不会影响调用它的客户类。 2. 对客户屏蔽了子系统组件,减少了客户处理的对象数目,并使得子系统使用起来更加容易。 3. 降低了大型软件系统中的编译依赖性,简化了系统在不同平台之间的移植过程,因为编译一个子系统不会影响其他的子系统,也不会影响外观对象。 外观(Facade)模式的主要缺点如下。 1. 不能很好地限制客户使用子系统类,很容易带来未知风险。 2. 增加新的子系统可能需要修改外观类或客户端的源代码,违背了“开闭原则”。 外观(Facade)模式包含以下主要角色。 1. 外观(Facade)角色:为多个子系统对外提供一个共同的接口。 2. 子系统(Sub System)角色:实现系统的部分功能,客户可以通过外观角色访问它。 3. 客户(Client)角色:通过一个外观角色访问各个子系统的功能。 ```java public class DVDPlayer { private DVDPlayer(){}; private static final DVDPlayer DVD_PLAYER = new DVDPlayer(); public static DVDPlayer getInstance(){ return DVD_PLAYER; } public void on(){ System.out.println("打开DVD"); } public void off(){ System.out.println("关闭DVD"); } public void play(){ System.out.println("DVD开始播放"); } public void pause(){ System.out.println("DVD暂停播放"); } } public class Popcorn { private Popcorn(){} private static final Popcorn POPCORN = new Popcorn(); public static Popcorn getInstance(){ return POPCORN; } public void on(){ System.out.println("打开爆米花机"); } public void off(){ System.out.println("关闭爆米花机"); } public void pop(){ System.out.println("出爆米花"); } } public class Projector { private Projector(){}; private static final Projector PROJECTOR = new Projector(); public static Projector getInstance(){ return PROJECTOR; } public void on(){ System.out.println("打开投影仪"); } public void off(){ System.out.println("关闭投影仪"); } public void focus(){ System.out.println("投影仪聚焦"); } } public class Screen { private Screen(){}; private static final Screen SCREEN = new Screen(); public static Screen getInstance(){ return SCREEN; } public void up(){ System.out.println("屏幕放下"); } public void down(){ System.out.println("屏幕升起"); } } public class Stereo { private Stereo(){}; private static final Stereo STEREO = new Stereo(); public static Stereo getInstance(){ return STEREO; } public void on(){ System.out.println("打开立体声"); } public void off(){ System.out.println("关闭立体声"); } public void up(){ System.out.println("增大立体声"); } } public class TheaterLight { private TheaterLight(){}; private static final TheaterLight THEATER_LIGHT = new TheaterLight(); public static TheaterLight getInstance(){ return THEATER_LIGHT; } public void on(){ System.out.println("打开灯关"); } public void off(){ System.out.println("关闭灯光"); } public void dim(){ System.out.println("影院灯光"); } public void bright(){ System.out.println("影院灯光增亮"); } } //影院系统外观类 public class HomeTheaterFacade { private DVDPlayer dvdPlayer; private Popcorn popcorn; private Projector projector; private Screen screen; private Stereo stereo; private TheaterLight theaterLight; public HomeTheaterFacade() { this.dvdPlayer = DVDPlayer.getInstance(); this.popcorn = Popcorn.getInstance(); this.projector = Projector.getInstance(); this.screen = Screen.getInstance(); this.stereo = Stereo.getInstance(); this.theaterLight = TheaterLight.getInstance(); } //准备 public void ready(){ popcorn.on(); popcorn.pop(); screen.down(); projector.on(); projector.focus(); stereo.on(); dvdPlayer.on(); theaterLight.on(); theaterLight.dim(); } //播放 public void play(){ dvdPlayer.play(); } //暂停 public void pause(){ dvdPlayer.pause(); } //关闭 public void end(){ theaterLight.bright(); screen.up(); projector.off(); stereo.off(); dvdPlayer.off(); } } HomeTheaterFacade homeTheaterFacade = new HomeTheaterFacade(); homeTheaterFacade.ready(); homeTheaterFacade.play(); homeTheaterFacade.pause(); homeTheaterFacade.end(); ``` #### 享元模式 在面向对象程序设计过程中,有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源,它是系统性能提高的一个瓶颈。例如,围棋和五子棋中的黑白棋子,图像中的坐标点或颜色,局域网中的路由器、交换机和集线器,教室里的桌子和凳子等。这些对象有很多相似的地方,如果能把它们相同的部分提取出来共享,则能节省大量的系统资源,这就是享元模式的产生背景。 享元(Flyweight)模式的定义:运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销,从而提高系统资源的利用率。 享元模式的主要优点是:相同对象只要保存一份,这降低了系统中对象的数量,从而降低了系统中细粒度对象给内存带来的压力。 其主要缺点是: 1. 为了使对象可以共享,需要将一些不能共享的状态外部化,这将增加程序的复杂性。 2. 读取享元模式的外部状态会使得运行时间稍微变长。 享元模式的定义提出了两个要求,细粒度和共享对象。因为要求细粒度,所以不可避免地会使对象数量多且性质相近,此时我们就将这些对象的信息分为两个部分:内部状态和外部状态。 - 内部状态指对象共享出来的信息,存储在享元信息内部,并且不回随环境的改变而改变; - 外部状态指对象得以依赖的一个标记,随环境的改变而改变,不可共享。 享元模式的主要角色有如下。 1. 抽象享元角色(Flyweight):是所有的具体享元类的基类,为具体享元规范需要实现的公共接口,非享元的外部状态以参数的形式通过方法传入。 2. 具体享元(Concrete Flyweight)角色:实现抽象享元角色中所规定的接口。 3. 非享元(Unsharable Flyweight)角色:是不可以共享的外部状态,它以参数的形式注入具体享元的相关方法中。 4. 享元工厂(Flyweight Factory)角色:负责创建和管理享元角色。当客户对象请求一个享元对象时,享元工厂检査系统中是否存在符合要求的享元对象,如果存在则提供给客户;如果不存在的话,则创建一个新的享元对象。 ```java //抽象享元对象 public abstract class WebSite { public abstract void use(User user); } //具体享元对象 public class ConcreteWebSite extends WebSite { private String type; public ConcreteWebSite(String type) { this.type = type; } @Override public void use(User user) { System.out.println("网站的发布形式为:" + type + ",正在使用中...使用者:" + user.getUsername()); } } //外部非享元对象 public class User { private String username; public User(String username) { this.username = username; } public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } } //享元对象工厂 public class WebSiteFactory { private Map pool = new HashMap<>(); public WebSite getWebSiteCategory(String type){ if(!pool.containsKey(type)){ pool.put(type,new ConcreteWebSite(type)); } return (WebSite) pool.get(type); } public int getWebSiteCount(){ return pool.size(); } } //客户端 WebSiteFactory factory = new WebSiteFactory(); WebSite site1 = factory.getWebSiteCategory("新闻"); site1.use(new User("jock")); WebSite site2 = factory.getWebSiteCategory("新闻"); site2.use(new User("李四")); System.out.println(factory.getWebSiteCount()); ``` #### 代理模式 代理模式的定义:由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时,访问对象不适合或者不能直接引用目标对象,代理对象作为访问对象和目标对象之间的中介。 代理模式的主要优点有: - 代理模式在客户端与目标对象之间起到一个中介作用和保护目标对象的作用; - 代理对象可以扩展目标对象的功能; - 代理模式能将客户端与目标对象分离,在一定程度上降低了系统的耦合度,增加了程序的可扩展性 其主要缺点是: - 代理模式会造成系统设计中类的数量增加 - 在客户端和目标对象之间增加一个代理对象,会造成请求处理速度变慢; - 增加了系统的复杂度; 代理模式的主要角色如下。 1. 抽象主题(Subject)类:通过接口或抽象类声明真实主题和代理对象实现的业务方法。 2. 真实主题(Real Subject)类:实现了抽象主题中的具体业务,是代理对象所代表的真实对象,是最终要引用的对象。 3. 代理(Proxy)类:提供了与真实主题相同的接口,其内部含有对真实主题的引用,它可以访问、控制或扩展真实主题的功能。 ```java public interface ITeacher { void teach(); } public class TeacherDao implements ITeacher { @Override public void teach() { System.out.println("老师正在讲课"); } } public class TeacherDaoProxy implements ITeacher { private TeacherDao target; public TeacherDaoProxy(TeacherDao teacherDao) { this.target = teacherDao; } @Override public void teach() { System.out.println("代理之前操作"); target.teach(); System.out.println("代理之后的操作"); } } TeacherDao teacherDao = new TeacherDao(); TeacherDaoProxy teacherDaoProxy = new TeacherDaoProxy(teacherDao); teacherDaoProxy.teach(); ``` 代理模式有多种不同的实现方式。如果**按照代理创建的时期来进行分类:静态代理、动态代理**。 - 静态代理 由程序员创建或特定工具自动生成源代码,再对其进行编译。**在程序运行之前,代理类.class文件就已经被创建**,代理类和委托类的关系在运行前就确定。 - 动态代理 动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成,所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。 上面代码就是静态代理模式实例,代理类和被代理类实现同一个接口,在代理类中,可以对方法进行扩展,进行前置或者后置处理。业务类只需要关注业务逻辑本身,保证了业务类的重用性。这是代理的共有优点。代理使客户端不需要知道实现类是什么,怎么做的,而客户端只需知道代理即可(解耦合)。代理类和委托类实现了相同的接口,代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法,除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。代理对象只服务于一种类型的对象,如果要服务多类型的对象。势必要为每一种对象都进行代理,静态代理在程序规模稍大时就无法胜任了。 **动态代理** 从静态代理会发现——每个代理类只能为一个接口服务,这样程序开发中必然会产生许多的代理类。所以我们想办法**通过一个代理类完成全部的代理功能,那么我们就需要用动态代理**静态代理,一个代理只能代理一种类型,而且是在编译器就已经确定被代理的对象。而**动态代理**是在运行时,**通过反射机制实现动态代理,并且能够代理各种类型的对象**。在Java中要想实现动态代理机制,需要`java.lang.reflect.InvocationHandler`接口和 `java.lang.reflect.Proxy`类的支持。 ```java public interface ITeacher { void teach(); } public class ProxyHandler implements InvocationHandler{ private Object target; public ProxyHandler(Object obj){ this.target = obj; } @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object res = null; System.out.println("前置处理"); res = method.invoke(target,args); System.out.println("后置处理"); return res; } } public class TeacherDao implements ITeacher { @Override public void teach() { System.out.println("老师正在教授知识"); } } TeacherDao teacherDao = new TeacherDao(); ProxyHandler proxyHandler = new ProxyHandler(teacherDao); ITeacher iTeacher = (ITeacher) Proxy.newProxyInstance(ITeacher.class.getClassLoader(), new Class[]{ITeacher.class},proxyHandler); iTeacher.teach(); ``` 当无法或不想直接引用某个对象或访问某个对象存在困难时,可以通过代理对象来间接访问。使用代理模式主要有两个目的:一是保护目标对象,二是增强目标对象。