iis7发布网站教程,wordpress高级,白云做网站要多少钱,表格网站源码目录 一、概述
二、创建型模式 (Creational Patterns)
单例模式 (Singleton Pattern)
工厂方法模式 (Factory Method Pattern)
抽象工厂模式 (Abstract Factory Pattern)
建造者模式 (Builder Pattern)
原型模式 (Prototype Pattern)
三、结构型模式 (Structu…目录 一、概述
二、创建型模式 (Creational Patterns)
单例模式 (Singleton Pattern)
工厂方法模式 (Factory Method Pattern)
抽象工厂模式 (Abstract Factory Pattern)
建造者模式 (Builder Pattern)
原型模式 (Prototype Pattern)
三、结构型模式 (Structural Patterns)
适配器模式 (Adapter Pattern)
装饰器模式 (Decorator Pattern)
代理模式 (Proxy Pattern)
桥接模式 (Bridge Pattern)
组合模式 (Composite Pattern)
外观模式 (Facade Pattern)
享元模式 (Flyweight Pattern)
四、行为型模式 (Behavioral Patterns)
责任链模式 (Chain of Responsibility Pattern)
命令模式 (Command Pattern)
解释器模式 (Interpreter Pattern)
迭代器模式 (Iterator Pattern)
中介者模式 (Mediator Pattern)
备忘录模式 (Memento Pattern)
状态模式 (State Pattern)
策略模式 (Strategy Pattern)
模板方法模式 (Template Method Pattern)
访问者模式 (Visitor Pattern)
观察者模式 (Observer Pattern)
五、使用场景
场景一
策略模式 (Strategy Pattern)
模板方法模式 (Template Method Pattern)
命令模式 (Command Pattern)
适配器模式 (Adapter Pattern) 一、概述
在Java开发中设计模式是解决常见问题的最佳实践通常被归纳为23种经典设计模式这些模式源自《设计模式可复用面向对象软件的基础》一书由GoF四人组提出。这些模式分为三大类创建型模式、结构型模式和行为型模式。提升代码的可维护性、可复用性、可扩展性。下面讲解这23种设计模式包括定义、使用场景和简要示例。 创建型模式Creational Patterns
这些设计模式主要解决对象的创建问题。 单例模式Singleton
保证类只有一个实例并提供全局访问点。 工厂方法模式Factory Method
定义一个创建对象的接口但让子类决定实例化哪一个类。 抽象工厂模式Abstract Factory
提供一个接口创建相关或依赖对象的家族而不需要指定具体类。 建造者模式Builder
使用多个简单的对象一步步构建成一个复杂的对象解耦了对象的创建和表示。 原型模式Prototype
通过复制现有的对象来创建新对象避免重复创建相似对象。 结构型模式Structural Patterns
这些模式主要解决类和对象的组合结构问题。 适配器模式Adapter
将一个类的接口转换成客户端所期望的另一个接口使得原本不兼容的接口可以一起工作。 桥接模式Bridge
将抽象部分与实现部分分离使得两者可以独立变化。 过滤器模式Filter
通过组合多个过滤条件来筛选对象集合链式调用简化复杂的条件判断。 组合模式Composite
将对象组合成树形结构来表示“部分-整体”层次结构使得客户端可以一致地对待单个对象和组合对象。 装饰器模式Decorator
动态地给一个对象添加额外的职责而不影响其他对象。 外观模式Facade
为子系统中的一组接口提供一个统一的高层接口简化客户端的使用。 享元模式Flyweight
用共享对象来支持大量细粒度的对象减少内存占用。 观察者模式Proxy
这种模式也称为“发布-订阅”模式。它解耦了事件的发布者和消费者。 行为型模式Behavioral Patterns
这些模式主要解决对象之间的通信问题和算法的设计。 责任链模式Chain of Responsibility
通过一系列处理对象来形成链条客户端请求沿着链条传递直到某个对象处理该请求。 命令模式Command
将请求封装为一个对象从而允许用户使用不同的请求、队列或日志请求并支持可撤销的操作。 解释器模式Interpreter
给定一个语言定义一个文法并通过解释器来解释该语言的句子。 迭代器模式Iterator
提供一种方法访问集合对象中的元素而无需暴露集合的内部表示。 中介者模式Mediator
通过一个中介者对象来协调各个对象之间的交互减少类之间的直接依赖。 备忘录模式Memento
在不暴露对象内部状态的情况下捕获对象的状态并在需要时恢复。 观察者模式Observer
定义对象之间的一对多依赖关系当一个对象的状态改变时所有依赖它的对象都会收到通知并自动更新。 状态模式State
允许对象在内部状态改变时改变其行为使得对象看起来像是修改了其类。 策略模式Strategy
定义一系列算法将每一个算法封装起来并使它们可以互换允许在运行时选择算法。 模板方法模式Template Method
定义一个操作中的算法骨架允许子类为一个或多个步骤提供具体实现。 这些设计模式被广泛应用于实际开发中能够帮助开发者解决常见问题并使代码更易于维护和扩展。 二、创建型模式 (Creational Patterns)
这些模式关注对象的创建过程帮助解耦对象的创建和使用。
单例模式 (Singleton Pattern)
定义确保一个类只有一个实例并提供全局访问点。
使用场景需要唯一实例的场景如日志记录器、配置管理器、线程池、数据库连接池等。
示例
下面是一个Java中**单例模式 (Singleton Pattern)**的示例。我们将以“日志记录器”为例展示如何通过单例模式确保一个类只有一个实例并提供全局访问点。
单例模式有多种实现方式我会提供几种常见实现并解释它们的优缺点。
示例 1懒汉式延迟加载非线程安全
// 1. 懒汉式单例
class Logger {private static Logger instance;// 私有构造器防止外部实例化private Logger() {System.out.println(Logger 创建);}// 提供全局访问点public static Logger getInstance() {if (instance null) {instance new Logger();}return instance;}public void log(String message) {System.out.println(日志: message);}
}// 测试代码
public class SingletonPatternDemo {public static void main(String[] args) {Logger logger1 Logger.getInstance();Logger logger2 Logger.getInstance();logger1.log(第一次记录);logger2.log(第二次记录);System.out.println(logger1 logger2: (logger1 logger2));}
}
输出结果 Logger 创建 日志: 第一次记录 日志: 第二次记录 logger1 logger2: true 解析
特点延迟加载懒汉式只有在第一次调用 getInstance 时才创建实例。
缺点线程不安全多线程环境下可能创建多个实例。
示例 2懒汉式线程安全使用同步
class Logger {private static Logger instance;private Logger() {System.out.println(Logger 创建);}// 使用 synchronized 确保线程安全public static synchronized Logger getInstance() {if (instance null) {instance new Logger();}return instance;}public void log(String message) {System.out.println(日志: message);}
}
输出结果
与示例 1 相同但线程安全。
解析
改进通过 synchronized 关键字实现线程安全。
缺点每次调用 getInstance 都会加锁性能开销较大。
示例 3双重检查锁定Double-Checked Locking
class Logger {private static volatile Logger instance; // 使用 volatile 防止指令重排序private Logger() {System.out.println(Logger 创建);}public static Logger getInstance() {if (instance null) {synchronized (Logger.class) {if (instance null) {instance new Logger();}}}return instance;}public void log(String message) {System.out.println(日志: message);}
}
输出结果
与示例 1 相同但线程安全且性能优化。
解析
改进双重检查锁定只有在实例未创建时才加锁提高性能。
注意使用 volatile 防止指令重排序确保线程安全Java 1.5。
示例 4饿汉式静态初始化
class Logger {private static final Logger instance new Logger(); // 类加载时创建private Logger() {System.out.println(Logger 创建);}public static Logger getInstance() {return instance;}public void log(String message) {System.out.println(日志: message);}
}
输出结果 Logger 创建 日志: 第一次记录 日志: 第二次记录 logger1 logger2: true 解析
特点饿汉式类加载时立即创建实例。
优点线程安全简单。
缺点不支持延迟加载即使不使用也会创建实例。
示例 5静态内部类推荐
class Logger {private Logger() {System.out.println(Logger 创建);}// 静态内部类延迟加载private static class LoggerHolder {private static final Logger INSTANCE new Logger();}public static Logger getInstance() {return LoggerHolder.INSTANCE;}public void log(String message) {System.out.println(日志: message);}
}
输出结果 Logger 创建 日志: 第一次记录 日志: 第二次记录 logger1 logger2: true 解析
特点利用静态内部类的特性只有在调用 getInstance 时才加载 LoggerHolder实现延迟加载。
优点线程安全、无锁高性能、延迟加载是推荐的实现方式。
示例 6枚举单例最简洁
enum Logger {INSTANCE; // 唯一实例public void log(String message) {System.out.println(日志: message);}
}// 测试代码
public class SingletonPatternDemo {public static void main(String[] args) {Logger logger1 Logger.INSTANCE;Logger logger2 Logger.INSTANCE;logger1.log(第一次记录);logger2.log(第二次记录);System.out.println(logger1 logger2: (logger1 logger2));}
}
输出结果 日志: 第一次记录 日志: 第二次记录 logger1 logger2: true 解析
特点利用Java枚举的特性天生单例且线程安全。
优点最简洁、防反射攻击、防序列化问题。
缺点不支持延迟加载枚举类加载时即创建。
单例模式的优点
唯一实例确保全局只有一个实例节省资源。
全局访问提供统一的访问点方便使用。
注意事项
线程安全在多线程环境中需选择合适的实现如双重检查、静态内部类。
反射与序列化普通单例可能被反射或序列化破坏枚举单例可避免这些问题。
工厂方法模式 (Factory Method Pattern)
定义定义一个创建对象的接口让子类决定实例化哪个类。
使用场景需要创建不同种类对象的场景尤其是当创建对象的具体类在运行时决定时。比如日志系统的不同日志写入方式或数据库连接的不同实现。
示例假设我们要创建一个车辆工厂可以生产不同类型的车辆如汽车和摩托车。工厂模式的核心是通过一个工厂类来封装对象的创建逻辑。
// 1. 定义车辆接口
interface Vehicle {void drive();
}// 2. 实现具体车辆类
class Car implements Vehicle {Overridepublic void drive() {System.out.println(驾驶一辆汽车);}
}class Motorcycle implements Vehicle {Overridepublic void drive() {System.out.println(驾驶一辆摩托车);}
}// 3. 创建工厂类
class VehicleFactory {// 根据类型参数创建对应的车辆对象public static Vehicle createVehicle(String type) {if (car.equalsIgnoreCase(type)) {return new Car();} else if (motorcycle.equalsIgnoreCase(type)) {return new Motorcycle();} else {throw new IllegalArgumentException(未知的车辆类型: type);}}
}// 4. 测试代码
public class FactoryPatternDemo {public static void main(String[] args) {// 通过工厂创建汽车Vehicle car VehicleFactory.createVehicle(car);car.drive();// 通过工厂创建摩托车Vehicle motorcycle VehicleFactory.createVehicle(motorcycle);motorcycle.drive();// 测试无效输入try {Vehicle unknown VehicleFactory.createVehicle(bike);} catch (IllegalArgumentException e) {System.out.println(e.getMessage());}}
}
工厂模式的优点
封装创建逻辑调用者无需知道具体类的实现细节只需通过工厂获取对象。
易于扩展如果需要添加新类型如“Truck”只需新增类并修改工厂逻辑不影响现有代码。
解耦客户端代码与具体实现类解耦符合开闭原则。
抽象工厂模式 (Abstract Factory Pattern)
定义提供一个接口用于创建一系列相关或依赖对象的家族。
使用场景当需要创建一系列相关或依赖对象时且客户端不需要指定具体类。比如操作系统的界面组件库或跨平台的UI组件。
示例假设我们要为不同操作系统如Windows和Mac创建UI组件按钮和文本框抽象工厂模式可以帮助我们生产一组风格一致的对象
// 1. 定义抽象产品接口
interface Button {void render();
}interface TextBox {void display();
}// 2. 实现具体产品类Windows风格
class WindowsButton implements Button {Overridepublic void render() {System.out.println(渲染一个Windows风格的按钮);}
}class WindowsTextBox implements TextBox {Overridepublic void display() {System.out.println(显示一个Windows风格的文本框);}
}// 3. 实现具体产品类Mac风格
class MacButton implements Button {Overridepublic void render() {System.out.println(渲染一个Mac风格的按钮);}
}class MacTextBox implements TextBox {Overridepublic void display() {System.out.println(显示一个Mac风格的文本框);}
}// 4. 定义抽象工厂接口
interface UIFactory {Button createButton();TextBox createTextBox();
}// 5. 实现具体工厂类
class WindowsUIFactory implements UIFactory {Overridepublic Button createButton() {return new WindowsButton();}Overridepublic TextBox createTextBox() {return new WindowsTextBox();}
}class MacUIFactory implements UIFactory {Overridepublic Button createButton() {return new MacButton();}Overridepublic TextBox createTextBox() {return new MacTextBox();}
}// 6. 测试代码
public class AbstractFactoryDemo {public static void main(String[] args) {// 创建Windows风格的UI组件UIFactory windowsFactory new WindowsUIFactory();Button windowsButton windowsFactory.createButton();TextBox windowsTextBox windowsFactory.createTextBox();windowsButton.render();windowsTextBox.display();// 创建Mac风格的UI组件UIFactory macFactory new MacUIFactory();Button macButton macFactory.createButton();TextBox macTextBox macFactory.createTextBox();macButton.render();macTextBox.display();}
}
抽象工厂模式的优点
产品族一致性确保创建的对象属于同一个家族如Windows风格的按钮和文本框。
解耦客户端代码只依赖抽象接口不关心具体实现。
易于扩展新产品族添加新风格如Linux只需新增一个具体工厂类和相关产品类。
与工厂方法的区别
工厂方法模式关注单个对象的创建一个工厂方法创建一个产品。
抽象工厂模式关注一组相关对象的创建一个工厂创建整个产品族。
建造者模式 (Builder Pattern)
定义将复杂对象的构建与其表示分离逐步构建对象。
使用场景用于构建复杂对象的场景尤其是在构建过程中的各个部分需要分步骤组合时。比如在创建复杂对象时想要解耦构建过程与对象表示例如构建HTML页面或者生成复杂的配置对象。
示例假设我们要构建一台计算机包含多个部件如CPU、内存、硬盘。建造者模式可以将构建过程与最终对象的表示分离支持灵活配置。
// 1. 定义产品类计算机
class Computer {private String cpu;private String ram;private String storage;// 私有构造器只能通过Builder创建private Computer(Builder builder) {this.cpu builder.cpu;this.ram builder.ram;this.storage builder.storage;}Overridepublic String toString() {return Computer [CPU cpu , RAM ram , Storage storage ];}// 2. 定义内部建造者类public static class Builder {private String cpu;private String ram;private String storage;public Builder setCpu(String cpu) {this.cpu cpu;return this;}public Builder setRam(String ram) {this.ram ram;return this;}public Builder setStorage(String storage) {this.storage storage;return this;}public Computer build() {return new Computer(this);}}
}// 3. 测试代码
public class BuilderPatternDemo {public static void main(String[] args) {// 使用建造者构建基本配置计算机Computer basicComputer new Computer.Builder().setCpu(Intel i5).setRam(8GB).build();System.out.println(基本配置: basicComputer);// 使用建造者构建高配计算机Computer highEndComputer new Computer.Builder().setCpu(Intel i9).setRam(32GB).setStorage(1TB SSD).build();System.out.println(高配: highEndComputer);}
}建造者模式的优点
分步构建将复杂对象的构造过程分解为多个步骤。
灵活性支持创建不同配置的对象属性设置顺序无关。
不可变性产品对象可以通过私有构造器和无 setter 方法保持不可变。 与工厂模式的区别
建造者模式关注分步构造复杂对象强调灵活性和过程控制。
工厂模式关注一次性创建对象通常不涉及逐步构建。
原型模式 (Prototype Pattern)
定义通过复制现有对象来创建新对象。
使用场景当需要复制大量相似对象并且希望避免重复创建时。比如游戏中角色的副本、文件系统中的文件复制等。
示例假设我们有一个图形类如圆形支持克隆操作。原型模式允许我们通过复制原型对象来生成新实例而无需从头构造。
// 1. 定义原型接口
interface Prototype {Prototype clone(); // 克隆方法void setColor(String color);String getColor();
}// 2. 实现具体原型类圆形
class Circle implements Prototype, Cloneable {private int radius;private String color;public Circle(int radius, String color) {this.radius radius;this.color color;}Overridepublic Prototype clone() {try {return (Prototype) super.clone(); // 使用Object的clone方法进行浅克隆} catch (CloneNotSupportedException e) {e.printStackTrace();return null;}}Overridepublic void setColor(String color) {this.color color;}Overridepublic String getColor() {return color;}public void setRadius(int radius) {this.radius radius;}public int getRadius() {return radius;}Overridepublic String toString() {return Circle [radius radius , color color ];}
}// 3. 测试代码
public class PrototypePatternDemo {public static void main(String[] args) {// 创建原型对象Circle prototype new Circle(10, 红色);System.out.println(原型对象: prototype);// 克隆对象并修改Circle circle1 (Circle) prototype.clone();circle1.setColor(蓝色);System.out.println(克隆对象1: circle1);Circle circle2 (Circle) prototype.clone();circle2.setRadius(20);circle2.setColor(绿色);System.out.println(克隆对象2: circle2);// 原型对象保持不变System.out.println(原型对象未变: prototype);}
}原型模式的优点
性能提升通过复制已有对象创建新实例避免从头构造的开销。
简化创建适用于构造复杂或耗时的对象。
动态性可以运行时生成不同状态的对象。
浅克隆 vs 深克隆
上述示例使用的是浅克隆Object.clone()只复制对象的基本字段。如果对象包含引用类型如集合需要实现深克隆。以下是深克隆的示例
深克隆示例
import java.util.ArrayList;
import java.util.List;class ComplexCircle implements Prototype, Cloneable {private int radius;private String color;private ListString tags; // 引用类型字段public ComplexCircle(int radius, String color) {this.radius radius;this.color color;this.tags new ArrayList();}Overridepublic Prototype clone() {try {ComplexCircle cloned (ComplexCircle) super.clone();cloned.tags new ArrayList(this.tags); // 深克隆引用类型return cloned;} catch (CloneNotSupportedException e) {e.printStackTrace();return null;}}Overridepublic void setColor(String color) {this.color color;}Overridepublic String getColor() {return color;}public void addTag(String tag) {tags.add(tag);}Overridepublic String toString() {return ComplexCircle [radius radius , color color , tags tags ];}
}// 测试深克隆
public class PrototypePatternDemo {public static void main(String[] args) {ComplexCircle prototype new ComplexCircle(10, 红色);prototype.addTag(圆形);System.out.println(原型对象: prototype);ComplexCircle cloned (ComplexCircle) prototype.clone();cloned.setColor(蓝色);cloned.addTag(克隆);System.out.println(克隆对象: cloned);System.out.println(原型对象未变: prototype);}
}
输出 原型对象: ComplexCircle [radius10, color红色, tags[圆形]] 克隆对象: ComplexCircle [radius10, color蓝色, tags[圆形, 克隆]] 原型对象未变: ComplexCircle [radius10, color红色, tags[圆形]] 在深克隆中tags 列表被独立复制修改克隆对象的 tags 不会影响原型。 三、结构型模式 (Structural Patterns)
这些模式关注类和对象的组合优化结构。
适配器模式 (Adapter Pattern)
定义将不兼容的接口转换为可用的接口。
使用场景用于解决接口不兼容的问题。比如当需要让新系统与旧系统交互时可以使用适配器模式。另一个常见的例子是数据库的多种实现JDBC、Hibernate之间的适配。
示例假设我们有一个旧的电源接口输出220V但新设备需要110V的电源。适配器模式可以将旧接口适配为新接口。
// 1. 定义目标接口新设备期望的接口
interface TargetVoltage {int get110V(); // 提供110V电压
}// 2. 定义被适配者旧电源
class OldPower {public int get220V() {System.out.println(旧电源提供 220V 电压);return 220V;}
}// 3. 实现适配器类
class PowerAdapter implements TargetVoltage {private OldPower oldPower;public PowerAdapter(OldPower oldPower) {this.oldPower oldPower;}Overridepublic int get110V() {int voltage oldPower.get220V();int adaptedVoltage voltage / 2; // 简单模拟转换System.out.println(适配器将 220V 转换为 110V);return adaptedVoltage;}
}// 4. 测试代码
public class AdapterPatternDemo {public static void main(String[] args) {// 创建旧电源OldPower oldPower new OldPower();// 使用适配器将旧电源适配为新接口TargetVoltage adapter new PowerAdapter(oldPower);// 新设备使用适配后的电源System.out.println(新设备使用电压: adapter.get110V());}
}适配器模式的优点
兼容性将不兼容的接口转换为目标接口复用现有代码。
解耦客户端只依赖目标接口与被适配者解耦。
灵活性适配器可以在不同场景中桥接不同接口。
适配器模式的两种形式
类适配器通过继承实现需要多重继承Java中较少用。
对象适配器通过组合实现上例使用此方式更常用。
类适配器示例
interface TargetVoltage {int get110V();
}class OldPower {public int get220V() {System.out.println(旧电源提供 220V 电压);return 220V;}
}// 类适配器通过继承
class ClassPowerAdapter extends OldPower implements TargetVoltage {Overridepublic int get110V() {int voltage get220V();int adaptedVoltage voltage / 2;System.out.println(类适配器将 220V 转换为 110V);return adaptedVoltage;}
}// 测试
public class AdapterPatternDemo {public static void main(String[] args) {TargetVoltage adapter new ClassPowerAdapter();System.out.println(新设备使用电压: adapter.get110V());}
}
装饰器模式 (Decorator Pattern)
定义动态为对象添加职责不改变其接口。
使用场景用于动态地给对象添加功能而不改变其结构。比如咖啡店中的各种咖啡加料场景加奶、加糖等。
示例假设我们有一个基础咖啡类用户可以选择添加不同的配料如牛奶、糖装饰器模式允许我们在运行时动态组合这些配料。
// 1. 定义组件接口
interface Coffee {String getDescription(); // 获取描述double getCost(); // 获取价格
}// 2. 实现具体组件基础咖啡
class SimpleCoffee implements Coffee {Overridepublic String getDescription() {return 简单咖啡;}Overridepublic double getCost() {return 5.0;}
}// 3. 定义装饰器抽象类
abstract class CoffeeDecorator implements Coffee {protected Coffee decoratedCoffee;public CoffeeDecorator(Coffee coffee) {this.decoratedCoffee coffee;}Overridepublic String getDescription() {return decoratedCoffee.getDescription();}Overridepublic double getCost() {return decoratedCoffee.getCost();}
}// 4. 实现具体装饰器
class MilkDecorator extends CoffeeDecorator {public MilkDecorator(Coffee coffee) {super(coffee);}Overridepublic String getDescription() {return decoratedCoffee.getDescription() 牛奶;}Overridepublic double getCost() {return decoratedCoffee.getCost() 2.0;}
}class SugarDecorator extends CoffeeDecorator {public SugarDecorator(Coffee coffee) {super(coffee);}Overridepublic String getDescription() {return decoratedCoffee.getDescription() 糖;}Overridepublic double getCost() {return decoratedCoffee.getCost() 1.0;}
}// 5. 测试代码
public class DecoratorPatternDemo {public static void main(String[] args) {// 基础咖啡Coffee simpleCoffee new SimpleCoffee();System.out.println(simpleCoffee.getDescription() 价格: simpleCoffee.getCost());// 加牛奶的咖啡Coffee milkCoffee new MilkDecorator(simpleCoffee);System.out.println(milkCoffee.getDescription() 价格: milkCoffee.getCost());// 加牛奶和糖的咖啡Coffee milkSugarCoffee new SugarDecorator(new MilkDecorator(simpleCoffee));System.out.println(milkSugarCoffee.getDescription() 价格: milkSugarCoffee.getCost());}
}装饰器模式的优点
动态扩展可以在运行时为对象添加功能无需修改原有类。
灵活组合支持多种装饰器的自由组合。
符合开闭原则对扩展开放对修改关闭。
Java中的实际应用
Java I/O类如 InputStream广泛使用装饰器模式。例如
import java.io.*;public class JavaIODemo {public static void main(String[] args) throws IOException {InputStream input new FileInputStream(test.txt);InputStream bufferedInput new BufferedInputStream(input); // 装饰器添加缓冲功能BufferedReader reader new BufferedReader(new InputStreamReader(bufferedInput)); // 再装饰为字符流System.out.println(reader.readLine());reader.close();}
}
代理模式 (Proxy Pattern) 定义为对象提供代理控制对其访问。
使用场景用于控制对对象的访问常用于需要延迟初始化或访问控制的场景。例如数据库访问代理、图片的延迟加载代理、Spring AOP等。
示例假设我们要加载一张图片但图片加载可能很耗时。我们可以使用代理模式在需要时才加载真实图片而代理对象先提供占位功能。
// 1. 定义主题接口
interface Image {void display(); // 显示图片
}// 2. 实现真实主题真实图片
class RealImage implements Image {private String filename;public RealImage(String filename) {this.filename filename;loadImageFromDisk(); // 模拟从磁盘加载}private void loadImageFromDisk() {System.out.println(从磁盘加载图片: filename);}Overridepublic void display() {System.out.println(显示图片: filename);}
}// 3. 实现代理类
class ProxyImage implements Image {private RealImage realImage;private String filename;public ProxyImage(String filename) {this.filename filename;}Overridepublic void display() {if (realImage null) {realImage new RealImage(filename); // 延迟加载}realImage.display();}
}// 4. 测试代码
public class ProxyPatternDemo {public static void main(String[] args) {// 创建代理图片对象Image image1 new ProxyImage(photo1.jpg);Image image2 new ProxyImage(photo2.jpg);// 第一次显示图片触发加载System.out.println(第一次显示图片:);image1.display();// 第二次显示图片直接使用已加载的实例System.out.println(\n第二次显示图片:);image1.display();// 显示另一张图片System.out.println(\n显示另一张图片:);image2.display();}
}和装饰者模式较为相似
代理模式的优点
访问控制代理可以延迟加载、权限检查等控制对真实对象的访问。
性能优化如本例中的延迟加载减少不必要的资源消耗。
解耦客户端只与代理交互不直接依赖真实对象。
代理模式的常见类型
虚拟代理如本例用于延迟加载。
保护代理添加权限控制。
远程代理封装远程对象访问。 Java中的代理支持
Java提供了动态代理java.lang.reflect.Proxy可以运行时生成代理对象。例如
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;class DynamicProxyHandler implements InvocationHandler {private Object target;public DynamicProxyHandler(Object target) {this.target target;}Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println(代理调用方法: method.getName());return method.invoke(target, args);}
}public class DynamicProxyDemo {public static void main(String[] args) {RealImage realImage new RealImage(photo.jpg);Image proxyImage (Image) Proxy.newProxyInstance(Image.class.getClassLoader(),new Class[]{Image.class},new DynamicProxyHandler(realImage));proxyImage.display();}
}
桥接模式 (Bridge Pattern)
定义将抽象部分与实现部分分离使它们独立变化。
使用场景当你需要将抽象与其实现解耦时。比如图形库中既有抽象的图形如Shape也有具体的实现如圆形、正方形等且你希望能够独立扩展每个部分。
示例假设我们有不同类型的设备如电视和收音机和遥控器如基本遥控器和高级遥控器。桥接模式可以将设备的功能实现与遥控器的控制逻辑解耦。
// 1. 定义实现部分的接口设备
interface Device {void powerOn();void powerOff();void setVolume(int volume);int getVolume();
}// 2. 实现具体设备
class Television implements Device {private int volume 50;private boolean isOn false;Overridepublic void powerOn() {isOn true;System.out.println(电视已开启);}Overridepublic void powerOff() {isOn false;System.out.println(电视已关闭);}Overridepublic void setVolume(int volume) {this.volume volume;System.out.println(电视音量设置为: volume);}Overridepublic int getVolume() {return volume;}
}class Radio implements Device {private int volume 30;private boolean isOn false;Overridepublic void powerOn() {isOn true;System.out.println(收音机已开启);}Overridepublic void powerOff() {isOn false;System.out.println(收音机已关闭);}Overridepublic void setVolume(int volume) {this.volume volume;System.out.println(收音机音量设置为: volume);}Overridepublic int getVolume() {return volume;}
}// 3. 定义抽象部分遥控器
abstract class RemoteControl {protected Device device;public RemoteControl(Device device) {this.device device;}public abstract void turnOn();public abstract void turnOff();public abstract void adjustVolume(int volume);
}// 4. 实现具体遥控器
class BasicRemote extends RemoteControl {public BasicRemote(Device device) {super(device);}Overridepublic void turnOn() {device.powerOn();}Overridepublic void turnOff() {device.powerOff();}Overridepublic void adjustVolume(int volume) {device.setVolume(volume);}
}class AdvancedRemote extends RemoteControl {public AdvancedRemote(Device device) {super(device);}Overridepublic void turnOn() {device.powerOn();}Overridepublic void turnOff() {device.powerOff();}Overridepublic void adjustVolume(int volume) {device.setVolume(volume);}// 高级功能静音public void mute() {device.setVolume(0);System.out.println(设备已静音);}
}// 5. 测试代码
public class BridgePatternDemo {public static void main(String[] args) {// 创建设备Device tv new Television();Device radio new Radio();// 使用基本遥控器控制电视System.out.println(使用基本遥控器控制电视:);RemoteControl basicRemote new BasicRemote(tv);basicRemote.turnOn();basicRemote.adjustVolume(70);basicRemote.turnOff();System.out.println();// 使用高级遥控器控制收音机System.out.println(使用高级遥控器控制收音机:);RemoteControl advancedRemote new AdvancedRemote(radio);advancedRemote.turnOn();advancedRemote.adjustVolume(40);((AdvancedRemote) advancedRemote).mute();advancedRemote.turnOff();}
}桥接模式的优点
解耦将设备的实现与遥控器的抽象分离两者可以独立变化。
扩展性新增设备如音箱或遥控器如智能遥控器无需修改现有代码。
灵活性支持设备的多种控制方式组合。
组合模式 (Composite Pattern)
定义将对象组合成树形结构表示部分-整体关系。
使用场景用于树形结构的组合对象例如文件系统中的目录和文件或GUI组件中的窗体和控件。
示例假设有一个文件系统包含文件和文件夹两种元素。文件夹可以包含文件或其他文件夹我们希望统一处理这些元素例如计算总大小。组合模式可以帮助我们实现这一点。
import java.util.ArrayList;
import java.util.List;// 1. 定义组件接口
interface FileSystemComponent {int getSize(); // 获取大小void printName(); // 打印名称
}// 2. 实现叶子节点文件
class File implements FileSystemComponent {private String name;private int size;public File(String name, int size) {this.name name;this.size size;}Overridepublic int getSize() {return size;}Overridepublic void printName() {System.out.println(文件: name ( size 字节));}
}// 3. 实现组合节点文件夹
class Folder implements FileSystemComponent {private String name;private ListFileSystemComponent components new ArrayList();public Folder(String name) {this.name name;}public void add(FileSystemComponent component) {components.add(component);}public void remove(FileSystemComponent component) {components.remove(component);}Overridepublic int getSize() {int totalSize 0;for (FileSystemComponent component : components) {totalSize component.getSize();}return totalSize;}Overridepublic void printName() {System.out.println(文件夹: name);for (FileSystemComponent component : components) {component.printName();}}
}// 4. 测试代码
public class CompositePatternDemo {public static void main(String[] args) {// 创建文件File file1 new File(文档1.txt, 100);File file2 new File(图片1.jpg, 200);File file3 new File(视频1.mp4, 500);// 创建文件夹并添加文件Folder folder1 new Folder(我的文档);folder1.add(file1);folder1.add(file2);Folder rootFolder new Folder(根目录);rootFolder.add(folder1);rootFolder.add(file3);// 测试操作System.out.println(文件系统结构:);rootFolder.printName();System.out.println(\n总大小: rootFolder.getSize() 字节);// 测试单独文件System.out.println(\n单个文件大小: file1.getSize() 字节);}
}组合模式的优点
统一接口文件和文件夹通过同一接口操作客户端无需区分。
树形结构自然支持层次结构适合表示部分-整体关系。
扩展性新增组件类型如符号链接只需实现 FileSystemComponent 接口。
注意事项
透明性 vs 安全性
当前示例采用透明性设计接口中定义所有操作叶子节点如 File无需实现 add 等方法但可能导致误用。
若追求安全性可将 add 和 remove 移到 Folder 类中但客户端需区分类型。
外观模式 (Facade Pattern)
定义为子系统提供统一接口简化调用。
使用场景用于简化复杂系统的使用接口使客户端只需要通过一个统一的接口访问子系统的功能。例如启动计算机时隐藏了启动CPU、加载内存等复杂操作。
示例假设有一个家庭影院系统包含多个子系统如DVD播放器、投影仪、音响。用户需要执行一系列操作来观看电影外观模式可以封装这些操作提供简单接口。
// 1. 定义子系统类
class DVDPlayer {public void on() {System.out.println(DVD播放器已开启);}public void play(String movie) {System.out.println(DVD播放器正在播放: movie);}public void off() {System.out.println(DVD播放器已关闭);}
}class Projector {public void on() {System.out.println(投影仪已开启);}public void setInput(String input) {System.out.println(投影仪输入源设置为: input);}public void off() {System.out.println(投影仪已关闭);}
}class SoundSystem {public void on() {System.out.println(音响系统已开启);}public void setVolume(int level) {System.out.println(音响音量设置为: level);}public void off() {System.out.println(音响系统已关闭);}
}// 2. 定义外观类家庭影院
class HomeTheaterFacade {private DVDPlayer dvdPlayer;private Projector projector;private SoundSystem soundSystem;public HomeTheaterFacade(DVDPlayer dvdPlayer, Projector projector, SoundSystem soundSystem) {this.dvdPlayer dvdPlayer;this.projector projector;this.soundSystem soundSystem;}// 观看电影的简化接口public void watchMovie(String movie) {System.out.println(准备观看电影...);dvdPlayer.on();projector.on();projector.setInput(DVD);soundSystem.on();soundSystem.setVolume(10);dvdPlayer.play(movie);}// 关闭系统的简化接口public void endMovie() {System.out.println(关闭家庭影院...);dvdPlayer.off();projector.off();soundSystem.off();}
}// 3. 测试代码
public class FacadePatternDemo {public static void main(String[] args) {// 创建子系统实例DVDPlayer dvdPlayer new DVDPlayer();Projector projector new Projector();SoundSystem soundSystem new SoundSystem();// 创建外观对象HomeTheaterFacade homeTheater new HomeTheaterFacade(dvdPlayer, projector, soundSystem);// 使用外观接口观看电影homeTheater.watchMovie(《星际穿越》);System.out.println();// 使用外观接口关闭系统homeTheater.endMovie();}
}外观模式的优点
简化接口为复杂的子系统提供统一的、易于使用的接口。
解耦客户端与子系统解耦只依赖外观类不直接操作子系统。
提高可读性隐藏子系统的复杂性客户端代码更简洁。
享元模式 (Flyweight Pattern)
定义共享对象以减少内存使用。
使用场景用于需要大量共享对象的场景以减少内存消耗。比如文字处理系统中的字符对象、游戏中的图形元素如树、草等。
示例假设我们要绘制多个圆形每个圆形有颜色和位置属性其中颜色是可共享的内在状态而位置是变化的外在状态。享元模式可以避免为每个圆形创建重复的颜色对象。
import java.util.HashMap;
import java.util.Map;// 1. 定义享元接口
interface Shape {void draw(int x, int y); // 绘制方法位置为外在状态
}// 2. 实现具体享元类圆形
class Circle implements Shape {private String color; // 内在状态可共享public Circle(String color) {this.color color;}Overridepublic void draw(int x, int y) {System.out.println(绘制 color 圆形位置: ( x , y ));}
}// 3. 定义享元工厂
class ShapeFactory {private static final MapString, Shape circleMap new HashMap();public static Shape getCircle(String color) {Circle circle (Circle) circleMap.get(color);if (circle null) {circle new Circle(color);circleMap.put(color, circle);System.out.println(创建新的 color 圆形对象);}return circle;}
}// 4. 测试代码
public class FlyweightPatternDemo {private static final String[] colors {红色, 蓝色, 绿色};public static void main(String[] args) {// 绘制多个圆形for (int i 0; i 10; i) {String color colors[(int) (Math.random() * colors.length)];Shape circle ShapeFactory.getCircle(color);circle.draw(i * 10, i * 20); // 随机位置}}
}享元模式的优点
减少内存占用通过共享对象如相同颜色的圆形避免重复创建。
提高效率适用于大量相似对象的场景减少资源消耗。
分离状态内在状态color共享外在状态位置动态传入。
注意事项
内在状态与外在状态享元模式的关键是区分可共享的内在状态和不可共享的外在状态。
线程安全在多线程环境下享元工厂需要同步机制如使用 ConcurrentHashMap 或 synchronized。
四、行为型模式 (Behavioral Patterns)
这些模式关注对象间的通信和职责分配。
责任链模式 (Chain of Responsibility Pattern)
定义将请求沿处理链传递直到被处理。
使用场景用于多个对象都有机会处理请求时避免了请求处理者的硬编码。比如在日志处理或权限检查中每个处理器可以根据条件决定是否处理请求。
示例假设一个员工提交请假请求需要经过不同级别的管理者审批小组长、部门经理、总经理。每个管理者有自己的审批权限如果无法处理则传递给下一级。
// 1. 定义请假请求类
class LeaveRequest {private int days;private String name;public LeaveRequest(String name, int days) {this.name name;this.days days;}public int getDays() { return days; }public String getName() { return name; }
}// 2. 定义抽象处理者类
abstract class Approver {protected Approver nextApprover; // 下一级处理者public void setNextApprover(Approver nextApprover) {this.nextApprover nextApprover;}// 处理请假请求的抽象方法public abstract void handleRequest(LeaveRequest request);
}// 3. 实现具体处理者
class TeamLeader extends Approver {Overridepublic void handleRequest(LeaveRequest request) {if (request.getDays() 2) {System.out.println(小组长批准了 request.getName() 的 request.getDays() 天请假请求);} else if (nextApprover ! null) {System.out.println(小组长无权审批传递给下一级);nextApprover.handleRequest(request);} else {System.out.println(无人能批准 request.getName() 的请求);}}
}class DepartmentManager extends Approver {Overridepublic void handleRequest(LeaveRequest request) {if (request.getDays() 5) {System.out.println(部门经理批准了 request.getName() 的 request.getDays() 天请假请求);} else if (nextApprover ! null) {System.out.println(部门经理无权审批传递给下一级);nextApprover.handleRequest(request);} else {System.out.println(无人能批准 request.getName() 的请求);}}
}class GeneralManager extends Approver {Overridepublic void handleRequest(LeaveRequest request) {if (request.getDays() 15) {System.out.println(总经理批准了 request.getName() 的 request.getDays() 天请假请求);} else {System.out.println(总经理也无权批准 request.getName() 的 request.getDays() 天请假请求);}}
}// 4. 测试代码
public class ChainOfResponsibilityDemo {public static void main(String[] args) {// 创建审批链Approver teamLeader new TeamLeader();Approver deptManager new DepartmentManager();Approver generalManager new GeneralManager();// 设置责任链小组长 - 部门经理 - 总经理teamLeader.setNextApprover(deptManager);deptManager.setNextApprover(generalManager);// 测试不同天数的请假请求LeaveRequest request1 new LeaveRequest(张三, 1);LeaveRequest request2 new LeaveRequest(李四, 4);LeaveRequest request3 new LeaveRequest(王五, 10);LeaveRequest request4 new LeaveRequest(赵六, 20);System.out.println(请求1);teamLeader.handleRequest(request1);System.out.println(\n请求2);teamLeader.handleRequest(request2);System.out.println(\n请求3);teamLeader.handleRequest(request3);System.out.println(\n请求4);teamLeader.handleRequest(request4);}
}
责任链模式的优点
解耦请求与处理请求发送者无需知道具体由谁处理。
灵活性可以动态调整链的顺序或添加新的处理者。
单一职责每个处理者只关注自己的权限范围。
命令模式 (Command Pattern)
定义将请求封装成对象支持撤销、重做。
使用场景用于将请求封装为对象从而支持请求的参数化、队列管理、撤销操作等。比如遥控器控制家电的场景或者操作系统中的任务调度。
示例假设我们有一个遥控器可以控制电灯和电视开/关操作。命令模式允许我们将这些操作封装为命令对象遥控器只需发送命令而无需知道具体实现。
// 1. 定义接收者家电设备
class Light {public void turnOn() {System.out.println(电灯已打开);}public void turnOff() {System.out.println(电灯已关闭);}
}class TV {public void turnOn() {System.out.println(电视已打开);}public void turnOff() {System.out.println(电视已关闭);}
}// 2. 定义命令接口
interface Command {void execute(); // 执行命令
}// 3. 实现具体命令
class LightOnCommand implements Command {private Light light;public LightOnCommand(Light light) {this.light light;}Overridepublic void execute() {light.turnOn();}
}class LightOffCommand implements Command {private Light light;public LightOffCommand(Light light) {this.light light;}Overridepublic void execute() {light.turnOff();}
}class TVOnCommand implements Command {private TV tv;public TVOnCommand(TV tv) {this.tv tv;}Overridepublic void execute() {tv.turnOn();}
}class TVOffCommand implements Command {private TV tv;public TVOffCommand(TV tv) {this.tv tv;}Overridepublic void execute() {tv.turnOff();}
}// 4. 定义调用者遥控器
class RemoteControl {private Command command;public void setCommand(Command command) {this.command command;}public void pressButton() {if (command ! null) {command.execute();} else {System.out.println(未设置命令);}}
}// 5. 测试代码
public class CommandPatternDemo {public static void main(String[] args) {// 创建接收者Light light new Light();TV tv new TV();// 创建命令对象Command lightOn new LightOnCommand(light);Command lightOff new LightOffCommand(light);Command tvOn new TVOnCommand(tv);Command tvOff new TVOffCommand(tv);// 创建遥控器RemoteControl remote new RemoteControl();// 测试遥控器控制电灯System.out.println(控制电灯);remote.setCommand(lightOn);remote.pressButton();remote.setCommand(lightOff);remote.pressButton();// 测试遥控器控制电视System.out.println(\n控制电视);remote.setCommand(tvOn);remote.pressButton();remote.setCommand(tvOff);remote.pressButton();// 未设置命令System.out.println(\n未设置命令);remote.setCommand(null);remote.pressButton();}
}
命令模式的优点
解耦调用者RemoteControl与接收者Light、TV通过命令对象解耦。
扩展性新增命令如调节音量只需实现 Command 接口不影响现有代码。
支持撤销/重做通过扩展命令接口如添加 undo 方法可以实现更多功能。
解释器模式 (Interpreter Pattern)
定义定义语法表示为语言提供解释器。
使用场景用于解释计算机语言或编程语言中的语法适用于解释某些规则、配置文件的解析、正则表达式的实现等场景。
示例假设我们要实现一个解释器支持加法和减法操作用户输入一个字符串表达式如 3 5解释器解析并计算结果。 // 1. 定义表达式接口
interface Expression {int interpret(); // 解释并计算结果
}// 2. 实现终结符表达式数字
class NumberExpression implements Expression {private int number;public NumberExpression(int number) {this.number number;}public NumberExpression(String number) {this.number Integer.parseInt(number);}Overridepublic int interpret() {return number;}
}// 3. 实现非终结符表达式加法
class AddExpression implements Expression {private Expression left;private Expression right;public AddExpression(Expression left, Expression right) {this.left left;this.right right;}Overridepublic int interpret() {return left.interpret() right.interpret();}
}// 4. 实现非终结符表达式减法
class SubtractExpression implements Expression {private Expression left;private Expression right;public SubtractExpression(Expression left, Expression right) {this.left left;this.right right;}Overridepublic int interpret() {return left.interpret() - right.interpret();}
}// 5. 定义解析器将字符串转为表达式
class ExpressionParser {public Expression parse(String expression) {String[] tokens expression.split( );if (tokens.length ! 3) {throw new IllegalArgumentException(表达式格式错误应为数字 运算符 数字);}Expression left new NumberExpression(tokens[0]);Expression right new NumberExpression(tokens[2]);String operator tokens[1];switch (operator) {case :return new AddExpression(left, right);case -:return new SubtractExpression(left, right);default:throw new IllegalArgumentException(不支持的运算符: operator);}}
}// 6. 测试代码
public class InterpreterPatternDemo {public static void main(String[] args) {ExpressionParser parser new ExpressionParser();// 测试加法String expression1 3 5;Expression exp1 parser.parse(expression1);System.out.println(expression1 exp1.interpret());// 测试减法String expression2 10 - 2;Expression exp2 parser.parse(expression2);System.out.println(expression2 exp2.interpret());// 测试复杂表达式手动组合Expression complexExp new AddExpression(new NumberExpression(5),new SubtractExpression(new NumberExpression(10), new NumberExpression(3)));System.out.println(5 (10 - 3) complexExp.interpret());}
}解释器模式的优点
扩展性新增运算符如乘法、除法只需添加新的非终结符表达式类。
职责分离语法规则和解释逻辑分开易于维护。
适合简单语言非常适合解析简单的自定义语言或规则。
局限性
复杂性对于复杂的语法树解析和管理表达式会变得繁琐。
性能递归解释可能效率较低不适合大规模计算。
迭代器模式 (Iterator Pattern)
定义提供顺序访问集合元素的方法。
使用场景用于访问一个集合对象的元素而不暴露其内部表示。适用于在遍历数据结构时不暴露其内部实现的场景如数据库查询结果的遍历。
示例假设有一个书架集合包含多本书我们希望遍历这些书而不直接操作书架的内部数据结构。迭代器模式可以帮助我们实现这一点。
import java.util.ArrayList;
import java.util.List;// 1. 定义迭代器接口
interface Iterator {boolean hasNext(); // 是否有下一个元素Object next(); // 获取下一个元素
}// 2. 定义集合接口
interface BookCollection {Iterator createIterator(); // 创建迭代器void addBook(String book);
}// 3. 实现具体迭代器
class BookIterator implements Iterator {private ListString books;private int index 0;public BookIterator(ListString books) {this.books books;}Overridepublic boolean hasNext() {return index books.size();}Overridepublic Object next() {if (hasNext()) {return books.get(index);}return null;}
}// 4. 实现具体集合书架
class Bookshelf implements BookCollection {private ListString books new ArrayList();Overridepublic Iterator createIterator() {return new BookIterator(books);}Overridepublic void addBook(String book) {books.add(book);}
}// 5. 测试代码
public class IteratorPatternDemo {public static void main(String[] args) {// 创建书架Bookshelf bookshelf new Bookshelf();// 添加书籍bookshelf.addBook(《Java编程思想》);bookshelf.addBook(《设计模式》);bookshelf.addBook(《深入理解JVM》);// 创建迭代器并遍历Iterator iterator bookshelf.createIterator();System.out.println(书架上的书籍:);while (iterator.hasNext()) {String book (String) iterator.next();System.out.println(book);}}
}迭代器模式的优点
封装性隐藏集合的内部结构客户端只需通过迭代器访问元素。
统一接口为不同集合提供一致的遍历方式。
灵活性可以轻松实现多种遍历方式如反向迭代器。
Java中的内置支持
Java的 java.util.Iterator 接口是迭代器模式的典型实现许多集合类如 ArrayList、HashSet都支持。例如
import java.util.ArrayList;
import java.util.Iterator;public class JavaIteratorDemo {public static void main(String[] args) {ArrayListString books new ArrayList();books.add(《Java编程思想》);books.add(《设计模式》);IteratorString iterator books.iterator();while (iterator.hasNext()) {System.out.println(iterator.next());}}
}
中介者模式 (Mediator Pattern)
定义通过中介者协调对象间交互。
使用场景用于协调对象之间的交互减少类之间的依赖。常用于多对象交互的场景如聊天系统中的消息处理、UI控件之间的交互等。
示例假设有一个聊天室用户可以发送消息所有消息通过聊天室中介者进行转发而用户之间不直接交互。中介者模式可以减少用户之间的耦合。
// 1. 定义中介者接口
interface ChatMediator {void sendMessage(String message, User user);void addUser(User user);
}// 2. 定义同事类用户
abstract class User {protected ChatMediator mediator;protected String name;public User(ChatMediator mediator, String name) {this.mediator mediator;this.name name;}public abstract void send(String message);public abstract void receive(String message);public String getName() {return name;}
}// 3. 实现具体中介者聊天室
class ChatRoom implements ChatMediator {private ListUser users new ArrayList();Overridepublic void addUser(User user) {users.add(user);System.out.println(user.getName() 已加入聊天室);}Overridepublic void sendMessage(String message, User sender) {for (User user : users) {if (user ! sender) { // 不发送给自己user.receive(message);}}}
}// 4. 实现具体用户
class ChatUser extends User {public ChatUser(ChatMediator mediator, String name) {super(mediator, name);}Overridepublic void send(String message) {System.out.println(name 发送消息: message);mediator.sendMessage(message, this);}Overridepublic void receive(String message) {System.out.println(name 接收消息: message);}
}// 5. 测试代码
public class MediatorPatternDemo {public static void main(String[] args) {// 创建聊天室中介者ChatMediator chatRoom new ChatRoom();// 创建用户User alice new ChatUser(chatRoom, Alice);User bob new ChatUser(chatRoom, Bob);User charlie new ChatUser(chatRoom, Charlie);// 将用户加入聊天室chatRoom.addUser(alice);chatRoom.addUser(bob);chatRoom.addUser(charlie);// 用户发送消息alice.send(大家好);bob.send(你好Alice);charlie.send(嗨大家好);}
}中介者模式的优点
解耦用户之间不直接交互所有通信通过中介者完成降低耦合度。
集中控制交互逻辑集中在中介者中便于管理和修改。
简化关系将多对多的关系简化为多对一。
备忘录模式 (Memento Pattern)
定义保存和恢复对象状态。
使用场景用于保存和恢复对象的状态常用于实现撤销操作的场景比如文本编辑器中的撤销功能。
示例假设有一个简单的文本编辑器支持输入文本和撤销操作。备忘录模式可以用来保存编辑器的历史状态以便在需要时恢复。
// 1. 定义备忘录类保存状态
class Memento {private String text;public Memento(String text) {this.text text;}public String getText() {return text;}
}// 2. 定义原发器类文本编辑器
class TextEditor {private String text;public TextEditor() {this.text ;}public void write(String newText) {this.text newText;System.out.println(当前文本: text);}// 创建备忘录保存当前状态public Memento save() {return new Memento(text);}// 从备忘录恢复状态public void restore(Memento memento) {this.text memento.getText();System.out.println(恢复文本: text);}public String getText() {return text;}
}// 3. 定义管理者类负责存储备忘录
class EditorHistory {private StackMemento history new Stack();public void saveState(Memento memento) {history.push(memento);}public Memento undo() {if (!history.isEmpty()) {return history.pop();}System.out.println(无历史记录可撤销);return null;}
}// 4. 测试代码
public class MementoPatternDemo {public static void main(String[] args) {TextEditor editor new TextEditor();EditorHistory history new EditorHistory();// 编辑文本并保存状态editor.write(Hello);history.saveState(editor.save());editor.write(Hello, World!);history.saveState(editor.save());editor.write(Hello, World! How are you?);System.out.println(当前文本: editor.getText());// 撤销操作System.out.println(\n撤销一次:);Memento memento1 history.undo();if (memento1 ! null) editor.restore(memento1);System.out.println(\n撤销第二次:);Memento memento2 history.undo();if (memento2 ! null) editor.restore(memento2);System.out.println(\n再次撤销无历史记录:);history.undo();}
}备忘录模式的优点
状态隔离备忘录封装了状态细节外部无法直接修改。
支持撤销通过保存历史状态实现撤销功能。
职责分离原发器专注状态管理管理者负责存储。
状态模式 (State Pattern)
定义根据状态改变对象行为。
使用场景用于对象的状态改变时允许对象在其状态发生改变时改变其行为。常见于游戏角色的状态管理、工作流系统等。
示例假设有一个订单系统订单可能处于不同状态如待支付、已支付、已发货、已完成。每个状态下订单的行为如支付、发货、取消会有所不同。状态模式可以将这些行为封装到状态类中。
// 1. 定义状态接口
interface OrderState {void pay(Order order); // 支付void ship(Order order); // 发货void cancel(Order order); // 取消
}// 2. 实现具体状态类
class PendingPaymentState implements OrderState {Overridepublic void pay(Order order) {System.out.println(支付成功订单状态变更为已支付);order.setState(new PaidState());}Overridepublic void ship(Order order) {System.out.println(订单未支付无法发货);}Overridepublic void cancel(Order order) {System.out.println(订单已取消);order.setState(new CancelledState());}
}class PaidState implements OrderState {Overridepublic void pay(Order order) {System.out.println(订单已支付无需重复支付);}Overridepublic void ship(Order order) {System.out.println(发货成功订单状态变更为已发货);order.setState(new ShippedState());}Overridepublic void cancel(Order order) {System.out.println(订单已支付无法直接取消请申请退款);}
}class ShippedState implements OrderState {Overridepublic void pay(Order order) {System.out.println(订单已支付且已发货无需重复支付);}Overridepublic void ship(Order order) {System.out.println(订单已发货无需重复发货);}Overridepublic void cancel(Order order) {System.out.println(订单已发货无法取消);}
}class CancelledState implements OrderState {Overridepublic void pay(Order order) {System.out.println(订单已取消无法支付);}Overridepublic void ship(Order order) {System.out.println(订单已取消无法发货);}Overridepublic void cancel(Order order) {System.out.println(订单已处于取消状态);}
}// 3. 定义上下文类订单
class Order {private OrderState state;public Order() {this.state new PendingPaymentState(); // 初始状态为待支付}public void setState(OrderState state) {this.state state;}// 委托给当前状态处理public void pay() {state.pay(this);}public void ship() {state.ship(this);}public void cancel() {state.cancel(this);}
}// 4. 测试代码
public class StatePatternDemo {public static void main(String[] args) {Order order new Order();System.out.println(初始状态待支付:);order.pay(); // 支付System.out.println(\n支付后状态已支付:);order.ship(); // 发货System.out.println(\n发货后状态已发货:);order.cancel(); // 尝试取消System.out.println(\n新订单测试取消:);Order newOrder new Order();newOrder.cancel(); // 取消待支付订单}
}状态模式的优点
行为局部化每个状态的行为封装在对应类中逻辑清晰。
状态切换通过状态对象动态改变行为无需复杂的条件判断。
扩展性新增状态如“退货中”只需添加新状态类。
策略模式 (Strategy Pattern)
定义定义算法家族动态选择算法。
使用场景用于选择算法的场景根据不同的情况选择不同的策略。比如支付系统中选择不同的支付方式如支付宝、微信支付、信用卡支付等或排序算法的选择。
示例假设我们有一个支付系统支持多种支付方式如支付宝、微信支付和银行卡支付。策略模式允许我们在运行时动态选择具体的支付方式。
// 1. 定义支付策略接口
interface PaymentStrategy {void pay(double amount);
}// 2. 实现具体支付策略
class AlipayPayment implements PaymentStrategy {Overridepublic void pay(double amount) {System.out.println(使用支付宝支付 amount 元);}
}class WechatPayment implements PaymentStrategy {Overridepublic void pay(double amount) {System.out.println(使用微信支付 amount 元);}
}class BankCardPayment implements PaymentStrategy {Overridepublic void pay(double amount) {System.out.println(使用银行卡支付 amount 元);}
}// 3. 创建上下文类
class PaymentContext {private PaymentStrategy paymentStrategy;// 设置策略public void setPaymentStrategy(PaymentStrategy paymentStrategy) {this.paymentStrategy paymentStrategy;}// 执行支付public void executePayment(double amount) {if (paymentStrategy null) {System.out.println(请先选择支付方式);return;}paymentStrategy.pay(amount);}
}// 4. 测试代码
public class StrategyPatternDemo {public static void main(String[] args) {PaymentContext context new PaymentContext();// 使用支付宝支付context.setPaymentStrategy(new AlipayPayment());context.executePayment(100.50);// 使用微信支付context.setPaymentStrategy(new WechatPayment());context.executePayment(200.75);// 使用银行卡支付context.setPaymentStrategy(new BankCardPayment());context.executePayment(150.00);// 未设置策略的情况context.setPaymentStrategy(null);context.executePayment(50.00);}
}
策略模式的优点
灵活性运行时可以动态切换策略如从支付宝切换到微信。
解耦支付逻辑与上下文分离客户端只需关心接口不关心具体实现。
易扩展新增支付方式如PayPal只需实现 PaymentStrategy 接口并添加相应类。
模板方法模式 (Template Method Pattern)
定义定义算法骨架子类实现具体步骤。
使用场景用于在子类中实现某些步骤而将流程的控制权交给父类。比如在游戏中有一些固定流程具体的游戏逻辑可以由子类来实现如初始化、开始、结束等步骤但是流程是统一的。
示例假设我们要制作不同类型的饮料如咖啡和茶每种饮料的制作流程基本相同烧水、冲泡、添加调料、装杯但具体步骤有所不同。模板方法模式可以用来定义通用流程。
// 1. 定义抽象类包含模板方法
abstract class BeverageMaker {// 模板方法定义制作饮料的固定流程public final void makeBeverage() {boilWater();brew();addCondiments();pourInCup();}// 通用步骤固定实现private void boilWater() {System.out.println(烧开水);}private void pourInCup() {System.out.println(将饮料倒入杯子);}// 抽象步骤由子类实现abstract void brew(); // 冲泡abstract void addCondiments(); // 添加调料
}// 2. 实现具体子类咖啡
class CoffeeMaker extends BeverageMaker {Overridevoid brew() {System.out.println(用热水冲泡咖啡粉);}Overridevoid addCondiments() {System.out.println(添加糖和奶);}
}// 3. 实现具体子类茶
class TeaMaker extends BeverageMaker {Overridevoid brew() {System.out.println(用热水浸泡茶叶);}Overridevoid addCondiments() {System.out.println(添加柠檬片);}
}// 4. 测试代码
public class TemplateMethodDemo {public static void main(String[] args) {System.out.println(制作咖啡);BeverageMaker coffee new CoffeeMaker();coffee.makeBeverage();System.out.println(\n制作茶);BeverageMaker tea new TeaMaker();tea.makeBeverage();}
}
模板方法模式的优点
固定流程确保所有子类遵循相同的步骤顺序。
代码复用通用逻辑在父类中实现避免重复。
灵活性子类可以定制特定步骤满足不同需求。
访问者模式 (Visitor Pattern)
定义将操作与对象结构分离动态添加新操作。
使用场景用于对不同类型的对象进行操作而不修改这些对象的类结构。比如在编译器中对不同的语法节点进行处理或在文件系统中对不同的文件类型文本文件、图片文件等执行不同操作。
示例假设我们有一个文件系统包含文件和文件夹两种元素。我们希望对这些元素执行不同的操作如计算大小和打印名称访问者模式可以让我们动态添加这些操作。
// 1. 定义访问者接口
interface FileSystemVisitor {void visit(File file);void visit(Folder folder);
}// 2. 定义元素接口
interface FileSystemElement {void accept(FileSystemVisitor visitor);
}// 3. 实现具体元素
class File implements FileSystemElement {private String name;private int size;public File(String name, int size) {this.name name;this.size size;}public String getName() { return name; }public int getSize() { return size; }Overridepublic void accept(FileSystemVisitor visitor) {visitor.visit(this);}
}class Folder implements FileSystemElement {private String name;private ListFileSystemElement elements new ArrayList();public Folder(String name) {this.name name;}public void addElement(FileSystemElement element) {elements.add(element);}public ListFileSystemElement getElements() { return elements; }public String getName() { return name; }Overridepublic void accept(FileSystemVisitor visitor) {visitor.visit(this);}
}// 4. 实现具体访问者
class SizeCalculatorVisitor implements FileSystemVisitor {private int totalSize 0;Overridepublic void visit(File file) {totalSize file.getSize();}Overridepublic void visit(Folder folder) {for (FileSystemElement element : folder.getElements()) {element.accept(this); // 递归访问子元素}}public int getTotalSize() { return totalSize; }
}class NamePrinterVisitor implements FileSystemVisitor {Overridepublic void visit(File file) {System.out.println(文件: file.getName());}Overridepublic void visit(Folder folder) {System.out.println(文件夹: folder.getName());for (FileSystemElement element : folder.getElements()) {element.accept(this); // 递归访问子元素}}
}// 5. 测试代码
public class VisitorPatternDemo {public static void main(String[] args) {// 构建文件系统结构File file1 new File(文档1.txt, 100);File file2 new File(图片1.jpg, 200);Folder folder1 new Folder(我的文档);folder1.addElement(file1);folder1.addElement(file2);File file3 new File(视频1.mp4, 500);Folder rootFolder new Folder(根目录);rootFolder.addElement(folder1);rootFolder.addElement(file3);// 使用SizeCalculatorVisitor计算总大小SizeCalculatorVisitor sizeVisitor new SizeCalculatorVisitor();rootFolder.accept(sizeVisitor);System.out.println(文件系统总大小: sizeVisitor.getTotalSize() 字节);System.out.println(\n打印文件系统名称:);// 使用NamePrinterVisitor打印名称NamePrinterVisitor nameVisitor new NamePrinterVisitor();rootFolder.accept(nameVisitor);}
}
访问者模式的优点
扩展性新增操作只需添加新的访问者类无需修改元素类。
分离关注点元素类专注于数据结构操作逻辑交给访问者。
适合复杂结构特别适用于树形或复合对象结构。
局限性与注意事项
增加新元素困难如果需要添加新的元素类型如 Link必须修改 FileSystemVisitor 接口及其所有实现。
访问者需知道元素细节访问者需要访问元素的内部属性如 size 和 name可能破坏封装。
观察者模式 (Observer Pattern)
定义观察者模式是一种行为型设计模式允许一个对象被观察者在状态发生变化时自动通知所有依赖于它的对象观察者。这种模式也称为“发布-订阅”模式。它解耦了事件的发布者和消费者。
使用场景
一对多依赖关系当一个对象的状态发生改变时所有依赖于它的对象都会得到通知。比如新闻发布系统、股票市场、游戏中的事件通知系统。松耦合设计观察者模式使得观察者和被观察者之间保持松耦合彼此并不直接依赖。一个被观察者可以有多个观察者观察者也可以自由注册和注销。 示例假设有一个天气站主题负责发布天气数据如温度和湿度多个显示设备观察者需要根据天气变化更新显示内容。
import java.util.ArrayList;
import java.util.List;// 1. 定义观察者接口
interface Observer {void update(float temperature, float humidity); // 更新方法
}// 2. 定义主题接口
interface Subject {void registerObserver(Observer observer); // 注册观察者void removeObserver(Observer observer); // 移除观察者void notifyObservers(); // 通知所有观察者
}// 3. 实现主题天气站
class WeatherStation implements Subject {private ListObserver observers new ArrayList();private float temperature;private float humidity;Overridepublic void registerObserver(Observer observer) {observers.add(observer);}Overridepublic void removeObserver(Observer observer) {observers.remove(observer);}Overridepublic void notifyObservers() {for (Observer observer : observers) {observer.update(temperature, humidity);}}// 设置天气数据并通知观察者public void setMeasurements(float temperature, float humidity) {this.temperature temperature;this.humidity humidity;notifyObservers();}
}// 4. 实现具体观察者
class TemperatureDisplay implements Observer {private String name;public TemperatureDisplay(String name) {this.name name;}Overridepublic void update(float temperature, float humidity) {System.out.println(name 显示: 温度 temperature °C);}
}class HumidityDisplay implements Observer {private String name;public HumidityDisplay(String name) {this.name name;}Overridepublic void update(float temperature, float humidity) {System.out.println(name 显示: 湿度 humidity %);}
}// 5. 测试代码
public class ObserverPatternDemo {public static void main(String[] args) {// 创建主题WeatherStation weatherStation new WeatherStation();// 创建观察者TemperatureDisplay tempDisplay new TemperatureDisplay(客厅显示器);HumidityDisplay humidDisplay new HumidityDisplay(卧室显示器);// 注册观察者weatherStation.registerObserver(tempDisplay);weatherStation.registerObserver(humidDisplay);// 模拟天气变化System.out.println(第一次天气更新:);weatherStation.setMeasurements(25.5f, 65.0f);System.out.println(\n第二次天气更新:);weatherStation.setMeasurements(28.0f, 70.0f);// 移除一个观察者weatherStation.removeObserver(tempDisplay);System.out.println(\n移除客厅显示器后第三次天气更新:);weatherStation.setMeasurements(30.0f, 60.0f);}
}观察者模式的优点
松耦合主题和观察者之间通过接口交互互不依赖具体实现。
动态性可以在运行时添加或移除观察者。
广播通信主题状态变化时自动通知所有观察者。
Java中的内置支持
Java提供了内置的观察者模式支持java.util.Observable 和 java.util.Observer但在新代码中更推荐使用自定义实现或事件监听机制。以下是使用Java内置类的简例
import java.util.Observable;
import java.util.Observer;class WeatherData extends Observable {private float temperature;public void setTemperature(float temperature) {this.temperature temperature;setChanged();notifyObservers(temperature);}
}class TempDisplay implements Observer {Overridepublic void update(Observable o, Object arg) {System.out.println(温度更新: arg °C);}
}public class BuiltInObserverDemo {public static void main(String[] args) {WeatherData weatherData new WeatherData();TempDisplay display new TempDisplay();weatherData.addObserver(display);weatherData.setTemperature(25.0f);}
}
使用场景
事件通知系统比如在用户界面中当某个按钮点击时多个组件观察者可能需要做出反应。例如点击“保存”按钮时不仅是保存数据还可能触发日志记录、用户界面更新等操作。股票行情更新证券市场中的股票价格变化多个投资者观察者需要根据新的价格做出反应。天气监测系统天气数据发生变化时多个显示屏观察者需要根据新的数据显示不同的天气信息。
总结
创建型解决对象创建问题5种。
结构型优化类和对象结构7种。
行为型处理对象间交互和职责11种。
每种模式都有其独特的应用场景实际开发中可以根据需求灵活组合使用。
五、使用场景
场景一
场景一有一个java方法我希望不同场景情况下都调用同一个方法会用到哪些设计模式呢 在Java中如果你希望在不同场景下都调用同一个方法同时保持代码的灵活性和可维护性可以考虑使用一些常见的设计模式。以下是几种可能适用的设计模式以及它们如何帮助你实现目标
策略模式 (Strategy Pattern)
使用场景如果你需要在不同情况下使用同一个方法但具体的实现逻辑会因场景而异策略模式是一个很好的选择。
实现方式定义一个接口包含这个方法签名然后为不同场景编写不同的实现类。调用时通过上下文类动态选择具体策略。
优点可以在运行时灵活切换实现代码解耦便于扩展。
例子
interface ProcessStrategy {void execute();
}class StrategyA implements ProcessStrategy {public void execute() { System.out.println(场景A逻辑); }
}class StrategyB implements ProcessStrategy {public void execute() { System.out.println(场景B逻辑); }
}class Context {private ProcessStrategy strategy;public void setStrategy(ProcessStrategy strategy) { this.strategy strategy; }public void process() { strategy.execute(); }
}模板方法模式 (Template Method Pattern)
使用场景如果你的方法有一个固定的流程但在某些步骤上会有不同场景的差异模板方法模式非常合适。
实现方式在一个抽象类中定义方法的骨架模板将可变部分留给子类实现。所有场景都调用这个模板方法。
优点保证方法的整体结构一致同时允许子类定制部分行为。
例子
abstract class AbstractProcess {public void process() {step1();step2();}abstract void step1();abstract void step2();
}class ProcessA extends AbstractProcess {void step1() { System.out.println(A的步骤1); }void step2() { System.out.println(A的步骤2); }
}工厂模式 (Factory Pattern)
使用场景如果不同场景需要创建不同的对象来调用同一个方法工厂模式可以帮你管理对象的创建。
实现方式通过工厂类根据场景参数创建对应的对象然后调用统一的方法。
优点隐藏对象的创建细节调用方只需关心方法本身。
例子
interface Product {void use();
}class ProductA implements Product {public void use() { System.out.println(使用A); }
}class ProductFactory {public static Product createProduct(String type) {if (A.equals(type)) return new ProductA();return null;}
}
命令模式 (Command Pattern)
使用场景如果你的方法调用需要解耦调用者和执行者或者需要支持撤销、重做等操作命令模式是一个选择。
实现方式将方法封装成命令对象调用方通过命令接口执行。
优点灵活性高可以动态调整调用逻辑。
例子
interface Command {void execute();
}class ConcreteCommand implements Command {public void execute() { System.out.println(执行命令); }
}class Invoker {private Command command;public void setCommand(Command command) { this.command command; }public void call() { command.execute(); }
}
适配器模式 (Adapter Pattern)
使用场景如果不同场景下已有不同的方法或接口但你想统一调用同一个方法可以用适配器模式。
实现方式通过适配器将不同接口转换为统一的接口。
优点复用现有代码统一调用方式。
例子
interface Target {void request();
}class Adaptee {public void specificRequest() { System.out.println(特殊请求); }
}class Adapter implements Target {private Adaptee adaptee new Adaptee();public void request() { adaptee.specificRequest(); }
}如何选择
如果逻辑差异大用策略模式。
如果流程固定但细节不同用模板方法模式。
如果需要动态创建对象用工厂模式。
如果需要解耦或支持额外功能如撤销用命令模式。
如果整合已有不同接口用适配器模式。
