Java中的设计模式实战单例、工厂到观察者的实现与应用

设计模式是软件开发中的一种最佳实践，帮助开发者解决常见问题。它们不仅可以增强代码的可读性、可维护性，还能提高软件的扩展性与灵活性。在本文中，我们将深入探讨Java中的几种经典设计模式，包括单例模式（Singleton）、工厂模式（Factory）**和**观察者模式（Observer）。通过代码实例，我们将展示这些设计模式的实现与应用，帮助你更好地理解并在项目中应用它们。

1. 单例模式（Singleton）

单例模式确保一个类只有一个实例，并提供全局访问点。它适用于那些需要确保全局唯一实例的场景，例如配置管理、线程池、数据库连接池等。

1.1 单例模式的实现方式

单例模式有几种实现方式，最常见的有饿汉式、懒汉式、双重锁检查等。

1.1.1 饿汉式实现

饿汉式在类加载时就初始化实例，确保线程安全，但缺点是可能在程序启动时即加载实例，即使没有使用到它。

public class Singleton {
    // 1. 私有静态实例
    private static final Singleton instance = new Singleton();

    // 2. 私有构造函数
    private Singleton() {}

    // 3. 公共静态方法
    public static Singleton getInstance() {
        return instance;
    }
}

1.1.2 懒汉式实现（线程不安全）

懒汉式在第一次调用时初始化实例，但没有考虑多线程问题，可能会导致多个实例。

public class Singleton {
    private static Singleton instance;

    private Singleton() {}

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

1.1.3 双重检查锁实现（线程安全）

双重检查锁实现了懒汉式的延迟加载，同时解决了线程安全问题，效率相对较高。

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;
    }
}

1.2 单例模式的应用场景

• 配置管理：一个全局配置类的实例，用于读取和维护配置。
• 线程池管理：一个全局线程池对象，用于控制线程的生命周期。
• 日志管理：一个全局日志对象，负责记录系统的日志信息。

2. 工厂模式（Factory）

工厂模式是一种创建对象的设计模式，通过提供一个创建对象的接口，来决定实例化哪个类。它可以有效地将对象的创建和使用分离，适用于需要创建多种不同类型对象的场景。

2.1 简单工厂模式

简单工厂模式通过一个工厂类根据提供的参数来创建不同类型的对象。

public class Animal {
    public void speak() {
        System.out.println("Animal speaks");
    }
}

public class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

public class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("Cat meows");
    }
}

public class AnimalFactory {
    public static Animal createAnimal(String type) {
        if ("dog".equalsIgnoreCase(type)) {
            return new Dog();
        } else if ("cat".equalsIgnoreCase(type)) {
            return new Cat();
        }
        return null;
    }
}

2.1.1 使用示例

public class Main {
    public static void main(String[] args) {
        Animal animal = AnimalFactory.createAnimal("dog");
        animal.speak();  // 输出：Dog barks
    }
}

2.2 工厂方法模式

工厂方法模式提供一个接口用来创建对象，让子类决定实例化哪个类。与简单工厂模式不同，工厂方法模式让工厂类不再依赖具体的类。

public interface Animal {
    void speak();
}

public class Dog implements Animal {
    @Override
    public void speak() {
        System.out.println("Dog barks");
    }
}

public class Cat implements Animal {
    @Override
    public void speak() {
        System.out.println("Cat meows");
    }
}

public interface AnimalFactory {
    Animal createAnimal();
}

public class DogFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
}

public class CatFactory implements AnimalFactory {
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}

2.2.1 使用示例

public class Main {
    public static void main(String[] args) {
        AnimalFactory factory = new DogFactory();
        Animal animal = factory.createAnimal();
        animal.speak();  // 输出：Dog barks
    }
}

2.3 工厂模式的应用场景

• 产品对象复杂：需要根据不同的条件返回不同的产品类型。
• 代码解耦：客户端代码不需要知道如何创建对象，只需依赖工厂接口。

3. 观察者模式（Observer）

观察者模式用于定义对象之间的一对多依赖关系，使得当一个对象的状态改变时，所有依赖于它的对象都得到通知并自动更新。它常用于实现事件驱动的系统，比如GUI组件、事件监听机制等。

3.1 观察者模式的实现

观察者模式包括主题（Subject）和观察者（Observer）。主题类维持一组观察者对象，当主题的状态变化时，所有观察者都会收到通知。

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;
    }

    @Override
    public void update(String message) {
        System.out.println(name + " received: " + message);
    }
}

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

    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);
        }
    }
}

3.1.1 使用示例

public class Main {
    public static void main(String[] args) {
        Subject subject = new Subject();

        Observer observer1 = new ConcreteObserver("Observer 1");
        Observer observer2 = new ConcreteObserver("Observer 2");

        subject.addObserver(observer1);
        subject.addObserver(observer2);

        subject.notifyObservers("Event occurred!");  
        // 输出：
        // Observer 1 received: Event occurred!
        // Observer 2 received: Event occurred!
    }
}

3.2 观察者模式的应用场景

• GUI框架：按钮点击、菜单选择等事件的监听和响应。
• 事件驱动编程：如消息推送系统、订阅/发布模式等。

4. 适配器模式（Adapter）

适配器模式是一种结构型设计模式，旨在将一个类的接口转换成客户端期望的另一个接口。它使得原本因接口不兼容而不能一起工作的类能够协同工作。适配器模式常用于第三方库的整合以及对旧代码的适配。

4.1 适配器模式的实现

适配器模式通常涉及到一个适配器类，它通过实现目标接口并在内部调用被适配的类的方法来完成适配。

4.1.1 示例：适配器模式

假设我们有一个老旧的OldSystem类，它只有一个方法oldMethod，现在我们需要将它与一个新的系统兼容，该系统期望使用newMethod接口。通过适配器模式，我们可以使这两个系统协同工作。

// 目标接口
interface Target {
    void newMethod();
}

// 被适配的类
class OldSystem {
    public void oldMethod() {
        System.out.println("Old system method");
    }
}

// 适配器类
class Adapter implements Target {
    private OldSystem oldSystem;

    public Adapter(OldSystem oldSystem) {
        this.oldSystem = oldSystem;
    }

    @Override
    public void newMethod() {
        oldSystem.oldMethod();  // 转换成期望的调用
    }
}

4.1.2 使用示例

public class Main {
    public static void main(String[] args) {
        OldSystem oldSystem = new OldSystem();
        Target target = new Adapter(oldSystem);  // 使用适配器

        target.newMethod();  // 输出：Old system method
    }
}

4.2 适配器模式的应用场景

• 旧系统与新系统的兼容：当需要集成新的系统或库时，如果新旧系统的接口不兼容，适配器模式可以提供桥梁，避免大规模修改现有代码。
• 第三方库的封装：通过适配器将第三方库与现有系统无缝集成。
• 多种接口的统一：在不同的类库中，通过适配器将各种不同的接口转换成统一的接口供外部使用。

5. 策略模式（Strategy）

策略模式属于行为型设计模式，旨在定义一系列算法，并将每个算法封装起来，使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户端。

5.1 策略模式的实现

策略模式通过创建一系列的策略类，每个类封装不同的算法或行为，并通过上下文类来动态地选择和执行其中的某一个策略。

5.1.1 示例：策略模式

假设我们有一个电子商务网站，不同的用户可以享受不同的折扣。我们可以通过策略模式来实现不同的折扣策略。

// 策略接口
interface DiscountStrategy {
    double applyDiscount(double price);
}

// 具体策略：普通用户折扣
class RegularCustomerDiscount implements DiscountStrategy {
    @Override
    public double applyDiscount(double price) {
        return price * 0.9;  // 10%折扣
    }
}

// 具体策略：VIP用户折扣
class VipCustomerDiscount implements DiscountStrategy {
    @Override
    public double applyDiscount(double price) {
        return price * 0.8;  // 20%折扣
    }
}

// 环境类：购物车
class ShoppingCart {
    private DiscountStrategy discountStrategy;

    public ShoppingCart(DiscountStrategy discountStrategy) {
        this.discountStrategy = discountStrategy;
    }

    public double calculateTotalPrice(double price) {
        return discountStrategy.applyDiscount(price);
    }
}

5.1.2 使用示例

public class Main {
    public static void main(String[] args) {
        // 创建两种折扣策略
        DiscountStrategy regularDiscount = new RegularCustomerDiscount();
        DiscountStrategy vipDiscount = new VipCustomerDiscount();

        // 计算不同策略下的购物车价格
        ShoppingCart cart1 = new ShoppingCart(regularDiscount);
        System.out.println("Regular customer price: " + cart1.calculateTotalPrice(100));  // 输出：90.0

        ShoppingCart cart2 = new ShoppingCart(vipDiscount);
        System.out.println("VIP customer price: " + cart2.calculateTotalPrice(100));  // 输出：80.0
    }
}

5.2 策略模式的应用场景

• 动态选择算法：当有多种算法可以选择时，可以使用策略模式来在运行时动态选择合适的算法。
• 行为的变更：当某个行为需要在不同的场景下有所不同，而这些变更又不希望影响到对象的类结构时，策略模式是一个理想的选择。
• 复杂的条件分支：减少代码中的大量条件语句，通过将这些条件封装为不同的策略来使代码更加简洁和易于扩展。

6. 装饰者模式（Decorator）

装饰者模式是一种结构型设计模式，允许用户在不修改类的情况下，动态地给一个对象添加额外的功能。装饰者模式通常用于需要扩展对象功能但又不希望使用继承的场景。

6.1 装饰者模式的实现

装饰者模式通常涉及一个装饰类，它通过持有被装饰对象的引用来增强对象的行为。装饰类和被装饰对象实现相同的接口，从而确保可以替换和扩展功能。

6.1.1 示例：装饰者模式

假设我们有一个基本的咖啡类，用户可以在此基础上加不同的配料，如牛奶、糖等。

// 基础接口
interface Coffee {
    String getDescription();
    double cost();
}

// 具体实现：简单咖啡
class SimpleCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "Simple Coffee";
    }

    @Override
    public double cost() {
        return 5.0;  // 基本价格
    }
}

// 装饰者类：加牛奶
class MilkDecorator implements Coffee {
    private Coffee coffee;

    public MilkDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Milk";
    }

    @Override
    public double cost() {
        return coffee.cost() + 1.5;  // 加牛奶的价格
    }
}

// 装饰者类：加糖
class SugarDecorator implements Coffee {
    private Coffee coffee;

    public SugarDecorator(Coffee coffee) {
        this.coffee = coffee;
    }

    @Override
    public String getDescription() {
        return coffee.getDescription() + ", Sugar";
    }

    @Override
    public double cost() {
        return coffee.cost() + 0.5;  // 加糖的价格
    }
}

6.1.2 使用示例

public class Main {
    public static void main(String[] args) {
        Coffee coffee = new SimpleCoffee();
        System.out.println("Description: " + coffee.getDescription());
        System.out.println("Cost: " + coffee.cost());

        coffee = new MilkDecorator(coffee);  // 添加牛奶
        System.out.println("Description: " + coffee.getDescription());
        System.out.println("Cost: " + coffee.cost());

        coffee = new SugarDecorator(coffee);  // 添加糖
        System.out.println("Description: " + coffee.getDescription());
        System.out.println("Cost: " + coffee.cost());
    }
}

6.2 装饰者模式的应用场景

• 动态地给对象添加功能：在不影响原有对象的情况下，动态添加功能，避免使用继承。
• 功能的组合：多个装饰器可以相互组合，提供多种功能的组合方式，增加系统的灵活性。
• 避免子类膨胀：通过装饰者模式替代继承，可以避免子类爆炸的问题，保持类层次的清晰。

在本文中，我们深入探讨了多个常见的设计模式，并提供了详细的代码示例和应用场景。每个设计模式都有其独特的用途和优势，掌握这些模式将使得你的Java编程更加高效、灵活且易于维护。希望本文能帮助你理解并应用这些设计模式，在实际开发中提升代码质量和架构设计水平。