引言
Java设计模式是软件工程中解决常见问题的模板或解决方案。掌握设计模式对于提高代码的可维护性、可扩展性和复用性至关重要。本文将结合实战案例，深入解析Java中的常见设计模式，并探讨其深度应用。
目录
设计模式概述
创建型模式
单例模式
工厂方法模式
抽象工厂模式
建造者模式
原型模式
结构型模式
适配器模式
桥接模式
组合模式
装饰器模式
代理模式
行为型模式
职责链模式
命令模式
解释器模式
迭代器模式
中介者模式
观察者模式
状态模式
策略模式
模板方法模式
访问者模式
设计模式的深度应用
总结
1. 设计模式概述
设计模式是一种在特定情境下解决问题的最佳实践。它不仅限于Java，也适用于其他编程语言。Java设计模式分为三大类：创建型、结构型和行为型。
2. 创建型模式
创建型模式关注对象的创建过程，主要目的是封装对象的创建过程，降低系统耦合度。
2.1 单例模式
单例模式确保一个类只有一个实例，并提供一个全局访问点。
public class Singleton {
private static Singleton instance;
private Singleton() {}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
2.2 工厂方法模式
工厂方法模式定义一个用于创建对象的接口，让子类决定实例化哪个类。
public interface Factory {
Product createProduct();
}
public class ConcreteFactoryA implements Factory {
public Product createProduct() {
return new ProductA();
}
}
public class ConcreteFactoryB implements Factory {
public Product createProduct() {
return new ProductB();
}
}
2.3 抽象工厂模式
抽象工厂模式提供一组抽象接口，用于创建相关或依赖对象的家族。
public interface AbstractFactory {
Color createColor();
Shape createShape();
}
public class ConcreteFactory1 implements AbstractFactory {
public Color createColor() {
return new Red();
}
public Shape createShape() {
return new Circle();
}
}
public class ConcreteFactory2 implements AbstractFactory {
public Color createColor() {
return new Green();
}
public Shape createShape() {
return new Square();
}
}
2.4 建造者模式
建造者模式将一个复杂对象的构建与其表示分离，使得同样的构建过程可以创建不同的表示。
public class Builder {
public void buildPartA() {
// …
}
public void buildPartB() {
// …
}
}
public class Director {
private Builder builder;
public Director(Builder builder) {
this.builder = builder;
}
public void construct() {
builder.buildPartA();
builder.buildPartB();
}
}
2.5 原型模式
原型模式通过复制现有的实例来创建新的实例，而不需要通过构造函数。
public class Prototype implements Cloneable {
private String field;
public Prototype clone() {
try {
return (Prototype) super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
}
3. 结构型模式
结构型模式关注类和对象的组合，主要用于处理类和对象之间的关系。
3.1 适配器模式
适配器模式将一个类的接口转换成客户期望的另一个接口，使得原本接口不兼容的类可以一起工作。
public interface Target {
void request();
}
public class Adaptee {
public void specificRequest() {
// …
}
}
public class Adapter implements Target {
private Adaptee adaptee;
public Adapter(Adaptee adaptee) {
this.adaptee = adaptee;
}
public void request() {
adaptee.specificRequest();
}
}
3.2 桥接模式
桥接模式将抽象部分与实现部分分离，使它们都可以独立地变化。
public interface Abstraction {
void operation();
}
public class RefinedAbstraction extends Abstraction {
private Implementor implementor;
public RefinedAbstraction(Implementor implementor) {
this.implementor = implementor;
}
public void operation() {
implementor.operationImpl();
}
}
public interface Implementor {
void operationImpl();
}
public class ConcreteImplementorA implements Implementor {
public void operationImpl() {
// …
}
}
public class ConcreteImplementorB implements Implementor {
public void operationImpl() {
// …
}
}
3.3 组合模式
组合模式将对象组合成树形结构以表示部分整体层次结构。
public abstract class Component {
public abstract void operation();
}
public class Leaf extends Component {
public void operation() {
// …
}
}
public class Composite extends Component {
private List
public void add(Component component) {
children.add(component);
}
public void remove(Component component) {
children.remove(component);
}
public void operation() {
for (Component child : children) {
child.operation();
}
}
}
3.4 装饰器模式
装饰器模式动态地给一个对象添加一些额外的职责，而不改变其接口。
public interface Component {
void operation();
}
public class ConcreteComponent implements Component {
public void operation() {
// …
}
}
public class Decorator implements Component {
private Component component;
public Decorator(Component component) {
this.component = component;
}
public void operation() {
component.operation();
// …
}
}
3.5 代理模式
代理模式为其他对象提供一种代理以控制对这个对象的访问。
public interface Image {
void display();
}
public class RealImage implements Image {
private String fileName;
public RealImage(String fileName) {
this.fileName = fileName;
loadImageFromDisk();
}
public void display() {
// …
}
private void loadImageFromDisk() {
// …
}
}
public class ProxyImage implements Image {
private RealImage realImage;
private String fileName;
public ProxyImage(String fileName) {
this.fileName = fileName;
}
public void display() {
if (realImage == null) {
realImage = new RealImage(fileName);
}
realImage.display();
}
}
4. 行为型模式
行为型模式关注对象之间的通信和交互，主要目的是降低类之间的耦合度。
4.1 职责链模式
职责链模式将请求的发送者和接收者解耦，使多个对象都有机会处理请求。
public interface Handler {
void handleRequest(int request);
}
public class ConcreteHandlerA implements Handler {
private Handler nextHandler;
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
public void handleRequest(int request) {
if (request < 10) {
System.out.println("Handler A handles request " + request);
} else {
if (nextHandler != null) {
nextHandler.handleRequest(request);
}
}
}
}
public class ConcreteHandlerB implements Handler {
private Handler nextHandler;
public void setNextHandler(Handler nextHandler) {
this.nextHandler = nextHandler;
}
public void handleRequest(int request) {
if (request >= 10 && request < 20) {
System.out.println("Handler B handles request " + request);
} else {
if (nextHandler != null) {
nextHandler.handleRequest(request);
}
}
}
}
4.2 命令模式
命令模式将请求封装成对象，从而允许用户使用不同的请求、队列或日志请求，并支持可撤销的操作。
public interface Command {
void execute();
}
public class LightOnCommand implements Command {
private Light light;
public LightOnCommand(Light light) {
this.light = light;
}
public void execute() {
light.on();
}
}
public class Light {
public void on() {
// ...
}
public void off() {
// ...
}
}
4.3 解释器模式
解释器模式定义语言的文法，并为语言的每个词法元素指定一个解释器，然后通过解释器来解释语言中的句子。
public interface Expression {
boolean interpret(String context);
}
public class TerminalExpression implements Expression {
private String data;
public TerminalExpression(String data) {
this.data = data;
}
public boolean interpret(String context) {
return context.contains(data);
}
}
public class OrExpression implements Expression {
private Expression expr1;
private Expression expr2;
public OrExpression(Expression expr1, Expression expr2) {
this.expr1 = expr1;
this.expr2 = expr2;
}
public boolean interpret(String context) {
return expr1.interpret(context) || expr2.interpret(context);
}
}
4.4 迭代器模式
迭代器模式提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。
public interface Iterator {
boolean hasNext();
Object next();
}
public class ListIterator implements Iterator {
private List list;
private int index;
public ListIterator(List list) {
this.list = list;
this.index = 0;
}
public boolean hasNext() {
return index < list.size();
}
public Object next() {
return list.get(index++);
}
}
4.5 中介者模式
中介者模式定义一个中介对象来封装一系列的对象交互，从而使对象之间不需要显式地相互引用，降低类之间的耦合度。
public class Mediator {
public void addColleague(Colleague colleague) {
// ...
}
public void notifyColleague(Colleague colleague) {
// ...
}
}
public class Colleague {
private Mediator mediator;
public Colleague(Mediator mediator) {
this.mediator = mediator;
}
public void send(String message) {
mediator.notifyColleague(this, message);
}
public void receive(String message) {
// ...
}
}
4.6 观察者模式
观察者模式定义对象间的一种一对多的依赖关系，当一个对象改变状态时，所有依赖于它的对象都得到通知并自动更新。
public interface Observer {
void update(String message);
}
public class ConcreteObserver implements Observer {
public void update(String message) {
// ...
}
}
public class Subject {
private List
public void addObserver(Observer observer) {
observers.add(observer);
}
public void removeObserver(Observer observer) {
observers.remove(observer);
}
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}
4.7 状态模式
状态模式允许一个对象在其内部状态改变时改变其行为。
public interface State {
void handle();
}
public class ConcreteStateA implements State {
public void handle() {
// …
}
}
public class ConcreteStateB implements State {
public void handle() {
// …
}
}
public class Context {
private State state;
public void setState(State state) {
this.state = state;
}
public void request() {
state.handle();
}
}
4.8 策略模式
策略模式定义一系列算法，将每个算法封装起来，并使它们可以互相替换。
public interface Strategy {
void execute();
}
public class ConcreteStrategyA implements Strategy {
public void execute() {
// …
}
}
public class ConcreteStrategyB implements Strategy {
public void execute() {
// …
}
}
public class Context {
private Strategy strategy;
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public void executeStrategy() {
strategy.execute();
}
}
4.9 模板方法模式
模板方法模式定义一个操作中的算法的骨架，将一些步骤延迟到子类中。
public abstract class TemplateMethod {
protected abstract void step1();
protected abstract void step2();
public final void executeTemplateMethod() {
step1();
step2();
}
}
public class ConcreteTemplateMethod extends TemplateMethod {
public void step1() {
// …
}
public void step2() {
// …
}
}
4.10 访问者模式
访问者模式表示一个作用于某对象结构中的各元素的操作，它使你可以在不改变各元素类的前提下定义作用于这些元素的新操作。
public interface Visitor {
void visit(ConcreteElementA element);
void visit(ConcreteElementB element);
}
public class ConcreteVisitorA implements Visitor {
public void visit(ConcreteElementA element) {
// …
}
public void visit(ConcreteElementB element) {
// …
}
}
public class ConcreteElementA {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
public class ConcreteElementB {
public void accept(Visitor visitor) {
visitor.visit(this);
}
}
5. 设计模式的深度应用
设计模式在实际项目中有着广泛的应用，以下是一些深度应用的例子：
使用单例模式管理数据库连接。
使用工厂方法模式创建不同类型的数据库连接。
使用适配器模式将旧系统与新系统兼容。
使用装饰器模式扩展系统功能。
使用代理模式控制对敏感资源的访问。
使用策略模式实现灵活的算法选择。
使用模板方法模式简化代码复用。
6. 总结
掌握Java设计模式对于提高代码质量至关重要。本文详细解析了Java中的常见设计模式，并结合实战案例进行了深度应用探讨。通过学习和实践设计模式，可以提高代码的可维护性、可扩展性和复用性，从而提升软件开发效率。