Java 设计模式及应用场景

Java 设计模式是解决软件开发中常见问题的通用方案，通过合理的设计模式可以提高代码的可维护性、可扩展性和复用性。下面将介绍 Java 中常见的设计模式及其原理。

一、设计模式的分类

设计模式主要分为三大类，共 23 种经典模式：

创建型模式（5 种）：用于对象的创建过程，如单例模式、工厂模式等。
结构型模式（7 种）：用于处理类或对象的组合，如代理模式、装饰器模式等。
行为型模式（11 种）：用于处理对象之间的交互和职责分配，如观察者模式、策略模式等。

二、常见设计模式详解

1. 单例模式（Singleton）

原理：确保一个类只有一个实例，并提供全局访问点。
实现方式：

饿汉式 （线程安全，类加载时初始化）：

复制代码

public class Singleton {
    private static final Singleton INSTANCE = new Singleton();
    private Singleton() {}
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

懒汉式 （延迟初始化，需注意线程安全）：

复制代码

public class Singleton {
    private static volatile Singleton instance; // 防止指令重排序
    private Singleton() {}
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

应用场景：配置管理器、数据库连接池等。

2. 工厂模式（Factory）

原理：定义创建对象的接口，让子类决定实例化哪个类。
分类：

简单工厂 （非标准模式）：

复制代码

public class ShapeFactory {
    public Shape createShape(String type) {
        if ("circle".equals(type)) {
            return new Circle();
        } else if ("rectangle".equals(type)) {
            return new Rectangle();
        }
        return null;
    }
}

工厂方法 ：

复制代码

public interface ShapeFactory {
    Shape createShape();
}

public class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

应用场景：根据不同条件创建对象，如游戏中的角色创建。

3. 观察者模式（Observer）

原理：定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖它的对象都会收到通知并自动更新。
结构：

主题（Subject）：维护观察者列表，提供注册和删除观察者的方法。

观察者（Observer） ：定义更新接口。

复制代码

// 主题接口
public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// 观察者接口
public interface Observer {
    void update(String message);
}

应用场景：事件监听、消息推送等。

4. 装饰器模式（Decorator）

原理：动态地给对象添加额外职责，比继承更灵活。
结构：

组件接口（Component）：定义核心功能。
具体组件（ConcreteComponent）：实现核心功能。

装饰器（Decorator） ：持有组件引用，扩展功能

复制代码

// 组件接口
public interface Beverage {
    String getDescription();
    double cost();
}

// 具体组件
public class Espresso implements Beverage {
    @Override
    public String getDescription() {
        return "Espresso";
    }
    @Override
    public double cost() {
        return 1.99;
    }
}

// 装饰器
public abstract class CondimentDecorator implements Beverage {
    protected Beverage beverage;
    public CondimentDecorator(Beverage beverage) {
        this.beverage = beverage;
    }
}

应用场景 ：IO 流（如BufferedInputStream装饰FileInputStream）。

5. 策略模式（Strategy）

原理：定义一系列算法，将每个算法封装起来，并使它们可以互换。
结构：

策略接口（Strategy）：定义算法行为。
具体策略（ConcreteStrategy）：实现策略接口。

上下文（Context） ：持有策略引用，根据需要选择策略。
示例：

复制代码

// 策略接口
public interface SortStrategy {
    void sort(int[] arr);
}

// 具体策略
public class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] arr) {
        // 冒泡排序实现
    }
}

// 上下文
public class SortContext {
    private SortStrategy strategy;
    public SortContext(SortStrategy strategy) {
        this.strategy = strategy;
    }
    public void executeSort(int[] arr) {
        strategy.sort(arr);
    }
}

应用场景：根据运行时条件选择算法，如支付方式选择。

三、设计模式的六大原则

设计模式的核心思想是遵循以下六大原则：

单一职责原则（SRP）：一个类只负责一项职责。
开闭原则（OCP）：对扩展开放，对修改关闭。
里氏替换原则（LSP）：子类可以替换父类而不影响程序正确性。
依赖倒置原则（DIP）：依赖抽象而非具体实现。
接口隔离原则（ISP）：客户端不应该依赖它不需要的接口。
迪米特法则（LoD）：一个对象应该对其他对象保持最少的了解。

四、设计模式的应用场景

创建型模式：对象创建过程复杂时，如单例模式、工厂模式。
结构型模式：需要优化类结构时，如代理模式（AOP 实现）、适配器模式（兼容不同接口）。
行为型模式：处理对象间交互时，如观察者模式（事件驱动）、状态模式（状态机）。

五、总结

设计模式是软件开发的经验总结，掌握常见模式可以提高代码质量和开发效率。关键是理解模式背后的设计原则，并根据实际需求合理选择和应用模式，避免过度设计。