Java常用设计模式

关注

原创 2025-08-28 17:05:51 632 阅读 AI 写同款· GEO 优化 ›

常用的设计模式（Java 实现） 设计模式是软件开发中非常重要的一部分，掌握常用的设计模式能够帮助我们解决很多常见的设计问题。本文介绍了单例模式工厂方法模式观察者模式策略模式装饰器模式代理模式等几种常用的设计模式。通过 Java 示例，我们可以清晰地理解每个设计模式的作用和实现方式。掌握设计模式能够提高代码的可维护性、可扩展性和灵活性，使得开发人员能够更加高效地设计和构建复杂的应用程序。阅读详情

设计模式是软件开发中解决常见问题的模板或指南。Java中的23种设计模式通常被分为三大类：创建型（Creational Patterns）、结构型（Structural Patterns）和行为型（Behavioral Patterns）。

创建型模式

1.单例模式（Singleton Pattern）

定义：确保一个类只有一个实例，并提供全局访问点。
用途：全局配置管理、数据库连接池等需要唯一实例的场景。

// 单例模式：确保一个类只有一个实例，并提供全局访问点
public class Singleton {
    // 使用volatile防止指令重排，确保线程安全
    private static volatile Singleton instance;
    
    // 私有构造器防止外部实例化
    private Singleton() {}
    
    // 双重检查锁定（Double-Check Locking）
    public static Singleton getInstance() {
        if (instance == null) { // 第一次检查
            synchronized (Singleton.class) {
                if (instance == null) { // 第二次检查
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        Singleton singleton = Singleton.getInstance();
    }
}

2.工厂方法模式（Factory Method Pattern）

定义：定义一个创建对象的接口，但由子类决定实例化哪个类。
用途：解耦对象的创建与使用（如不同数据库驱动）。

// 1. 产品接口 (Product Interface)
interface Shape {
    void draw();
}

// 2. 具体产品类 (Concrete Products)
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Circle.");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a Rectangle.");
    }
}

// 3. 创建者/工厂接口 (Creator/Factory Interface)
//    核心：工厂方法 createShape() 由子类实现。
interface ShapeFactory {
    Shape createShape(); // 这就是“工厂方法”
}

// 4. 具体创建者/工厂类 (Concrete Creators)
//    每个具体工厂负责创建一个具体产品。
class CircleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Circle();
    }
}

class RectangleFactory implements ShapeFactory {
    @Override
    public Shape createShape() {
        return new Rectangle();
    }
}

// 5. 客户端使用 (Client Code)
public class FactoryPatternDemo {
    public static void main(String[] args) {
        // 客户端代码只依赖抽象接口（Shape和ShapeFactory）
        // 需要什么产品，就使用对应的工厂
        ShapeFactory circleFactory = new CircleFactory();
        Shape circle = circleFactory.createShape();
        circle.draw(); // Output: Drawing a Circle.

        ShapeFactory rectangleFactory = new RectangleFactory();
        Shape rectangle = rectangleFactory.createShape();
        rectangle.draw(); // Output: Drawing a Rectangle.
        
        // 优点：如果要新增一个Triangle，只需要新增Triangle类和TriangleFactory类，
        // 无需修改任何现有工厂和客户端的代码，完全符合“开闭原则”。
    }
}

3.建造者模式（Builder Pattern）

定义：将复杂对象的构建过程分离，允许逐步构造不同表示形式。
用途：创建复杂对象（如SQL查询构造器）。

// 产品类（复杂对象）
class Car {
    private String engine;
    private String tires;
    
    // 内部Builder类
    static class Builder {
        private String engine;
        private String tires;
        
        public Builder engine(String engine) {
            this.engine = engine;
            return this;
        }
        
        public Builder tires(String tires) {
            this.tires = tires;
            return this;
        }
        
        public Car build() {
            return new Car(this);
        }
    }
    
    // 私有构造器，通过Builder创建
    private Car(Builder builder) {
        this.engine = builder.engine;
        this.tires = builder.tires;
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        Car car = new Car.Builder()
            .engine("V8")
            .tires("All-Terrain")
            .build();
    }
}

结构型模式

1.适配器模式（Adapter Pattern）

定义：将一个类的接口转换成客户端期望的另一个接口。
用途：兼容旧代码或第三方库（如USB转Type-C适配器）。

// 旧接口
interface OldSystem {
    void oldMethod();
}

// 适配的目标接口
interface NewSystem {
    void newMethod();
}

// 适配器：将旧接口适配为新接口
class Adapter implements NewSystem {
    private OldSystem oldSystem;
    
    public Adapter(OldSystem oldSystem) {
        this.oldSystem = oldSystem;
    }
    
    @Override
    public void newMethod() {
        oldSystem.oldMethod(); // 调用旧方法
    }
}

// 旧系统实现
class OldImplementation implements OldSystem {
    @Override
    public void oldMethod() {
        System.out.println("Old method called");
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        OldSystem old = new OldImplementation();
        NewSystem adapter = new Adapter(old);
        adapter.newMethod(); // 通过适配器调用旧方法
    }
}

2.装饰者模式（Decorator Pattern）

定义：动态地为对象添加额外职责，通过包装原始对象实现。
用途：扩展功能而不修改类（如为咖啡添加牛奶、糖）。

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

// 具体组件
class SimpleCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "Simple Coffee";
    }
    
    @Override
    public double cost() {
        return 2.0;
    }
}

// 装饰者抽象类
abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;
    
    public CoffeeDecorator(Coffee decoratedCoffee) {
        this.decoratedCoffee = decoratedCoffee;
    }
    
    @Override
    public String getDescription() {
        return decoratedCoffee.getDescription();
    }
    
    @Override
    public double cost() {
        return decoratedCoffee.cost();
    }
}

// 具体装饰者（添加牛奶）
class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee decoratedCoffee) {
        super(decoratedCoffee);
    }
    
    @Override
    public String getDescription() {
        return super.getDescription() + ", Milk";
    }
    
    @Override
    public double cost() {
        return super.cost() + 0.5;
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        coffee = new MilkDecorator(coffee);
        System.out.println(coffee.getDescription() + " $" + coffee.cost());
    }
}

3.代理模式（Proxy Pattern）

定义：为其他对象提供一个代理，以控制对这个对象的访问。
用途：延迟加载、权限控制（如虚拟代理、安全代理）。

// 主题接口
interface Subject {
    void request();
}

// 真实主题
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject handling request");
    }
}

// 代理
class Proxy implements Subject {
    private RealSubject realSubject;
    
    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        // 代理逻辑（如权限检查）
        System.out.println("Proxy: Checking access...");
        realSubject.request();
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        Subject proxy = new Proxy();
        proxy.request();
    }
}

行为型模式

1.观察者模式（Observer Pattern）

定义：定义对象间的一对多依赖，当一个对象状态改变时，自动通知依赖它的对象。
用途：事件处理系统（如消息订阅、UI数据更新）。

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

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

// 具体主题
class WeatherStation implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String weatherData;
    
    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(weatherData);
        }
    }
    
    public void setWeatherData(String data) {
        this.weatherData = data;
        notifyObservers();
    }
}

// 具体观察者
class WeatherDisplay implements Observer {
    @Override
    public void update(String message) {
        System.out.println("WeatherDisplay received: " + message);
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        WeatherStation station = new WeatherStation();
        WeatherDisplay display = new WeatherDisplay();
        station.registerObserver(display);
        station.setWeatherData("Sunny");
    }
}

2.策略模式（Strategy Pattern）

定义：定义一系列算法并封装它们，使可以独立于使用它的功能而变化。
用途：动态切换行为（如排序算法、支付方式选择）。

// 策略接口
interface PaymentStrategy {
    void pay(int amount);
}

// 具体策略（信用卡支付）
class CreditCardStrategy implements PaymentStrategy {
    private String cardNumber;
    
    public CreditCardStrategy(String cardNumber) {
        this.cardNumber = cardNumber;
    }
    
    @Override
    public void pay(int amount) {
        System.out.println("Paid " + amount + " using Credit Card");
    }
}

// 上下文
class Order {
    private PaymentStrategy strategy;
    
    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void placeOrder(int amount) {
        strategy.pay(amount);
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        Order order = new Order();
        order.setPaymentStrategy(new CreditCardStrategy("1234-5678"));
        order.placeOrder(100);
    }
}

3.命令模式（Command Pattern）

定义：将请求封装为对象，以便参数化、队列化或记录请求。
用途：实现撤销/重做、任务队列（如编辑器操作记录）。

// 命令接口
interface Command {
    void execute();
}

// 接收者（执行实际操作）
class Light {
    public void turnOn() {
        System.out.println("Light turned ON");
    }
    
    public void turnOff() {
        System.out.println("Light turned OFF");
    }
}

// 具体命令（开灯）
class TurnOnCommand implements Command {
    private Light light;
    
    public TurnOnCommand(Light light) {
        this.light = light;
    }
    
    @Override
    public void execute() {
        light.turnOn();
    }
}

// 调用者（Invoker）
class RemoteControl {
    private Command command;
    
    public void setCommand(Command command) {
        this.command = command;
    }
    
    public void pressButton() {
        command.execute();
    }
}

// 调用
public class Main {
    public static void main(String[] args) {
        Light light = new Light();
        Command command = new TurnOnCommand(light);
        RemoteControl remote = new RemoteControl();
        remote.setCommand(command);
        remote.pressButton();
    }
}