java 中的设计模式

在软件开发中，设计模式是一种经过总结和归纳的可复用解决方案，特别是在面临常见设计问题时。Java 作为一种广泛使用的编程语言，非常依赖于设计模式来提高代码的可维护性、可扩展性和可重用性。以下是一些常见的设计模式，以及它们的代码示例。

1. 单例模式（Singleton Pattern）

单例模式确保一个类只有一个实例，并提供一个全局访问点。这个模式常用于需要控制资源访问的场景，比如数据库连接。

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有构造函数，防止外部创建实例
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

2. 工厂模式（Factory Pattern）

工厂模式定义一个创建对象的接口，但让子类决定实例化哪一个类。它将对象的创建与使用分离。

interface Product {
    void use();
}

class ConcreteProductA implements Product {
    public void use() {
        System.out.println("使用产品A");
    }
}

class ConcreteProductB implements Product {
    public void use() {
        System.out.println("使用产品B");
    }
}

class Factory {
    public static Product createProduct(String type) {
        if (type.equals("A")) {
            return new ConcreteProductA();
        } else if (type.equals("B")) {
            return new ConcreteProductB();
        }
        return null;
    }
}

3. 观察者模式（Observer Pattern）

观察者模式是一种一对多的依赖关系，当一个对象改变状态时，所有依赖它的对象都会得到通知并自动更新。

import java.util.ArrayList;
import java.util.List;

interface Observer {
    void update(String message);
}

class ConcreteObserver implements Observer {
    private String name;

    public ConcreteObserver(String name) {
        this.name = name;
    }

    public void update(String message) {
        System.out.println(name + " 收到消息: " + message);
    }
}

class Subject {
    private List<Observer> observers = new ArrayList<>();

    public void attach(Observer observer) {
        observers.add(observer);
    }

    public void notifyAllObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

4. 策略模式（Strategy Pattern）

策略模式定义了一系列的算法，将每一个算法封装起来，并使它们可以互相替换。这使得算法独立于使用它的客户端。

interface Strategy {
    int doOperation(int num1, int num2);
}

class OperationAdd implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

class OperationSubtract implements Strategy {
    public int doOperation(int num1, int num2) {
        return num1 - num2;
    }
}

class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) {
        return strategy.doOperation(num1, num2);
    }
}

5. 装饰者模式（Decorator Pattern）

装饰者模式允许在不改变对象自身的情况下，动态地添加行为或功能。它是通过将对象放入一个封装的对象中来实现的。

interface Coffee {
    double cost();
}

class SimpleCoffee implements Coffee {
    public double cost() {
        return 5.0;
    }
}

abstract class CoffeeDecorator implements Coffee {
    protected Coffee decoratedCoffee;

    public CoffeeDecorator(Coffee coffee) {
        this.decoratedCoffee = coffee;
    }

    public double cost() {
        return decoratedCoffee.cost();
    }
}

class MilkDecorator extends CoffeeDecorator {
    public MilkDecorator(Coffee coffee) {
        super(coffee);
    }

    public double cost() {
        return super.cost() + 1.5;
    }
}

总结

在 Java 开发中，设计模式提供了有效的解决方案，帮助开发者应对各种复杂的场景。通过合理运用这些设计模式，可以显著提升代码的可维护性和可扩展性。在实际项目中，了解并掌握这些设计模式将大大提高软件的质量和开发效率。希望这个简要的介绍和示例能够帮助你在日常开发中更好地运用设计模式。