Java 设计模式示例详解

简介

设计模式是软件开发中针对反复出现的问题所总结出的通用解决方案。在 Java 编程中，合理运用设计模式可以提高代码的可维护性、可扩展性和可复用性。本文将围绕 Java 设计模式，结合具体示例，详细介绍其基础概念、使用方法、常见实践以及最佳实践。

基础概念

什么是设计模式

设计模式是指在软件开发过程中，针对反复出现的问题所总结归纳出的通用解决方案。它是前人经验的结晶，能够帮助开发者更高效地构建软件系统。

设计模式的分类

设计模式主要分为三大类： - 创建型模式：用于对象的创建过程，如单例模式、工厂模式等。 - 结构型模式：关注如何将类或对象组合成更大的结构，如代理模式、装饰器模式等。 - 行为型模式：用于处理对象之间的交互和职责分配，如观察者模式、策略模式等。

使用方法

单例模式

单例模式确保一个类只有一个实例，并提供一个全局访问点。

// 饿汉式单例模式
public class Singleton {
    private static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

    public static Singleton getInstance() {
        return INSTANCE;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2); // 输出 true
    }
}

工厂模式

工厂模式定义一个创建对象的接口，让子类决定实例化哪个类。

// 抽象产品类
interface Shape {
    void draw();
}

// 具体产品类
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");
    }
}

// 工厂类
class ShapeFactory {
    public Shape getShape(String shapeType) {
        if (shapeType == null) {
            return null;
        }
        if (shapeType.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else if (shapeType.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        }
        return null;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();

        Shape circle = shapeFactory.getShape("CIRCLE");
        circle.draw();

        Shape rectangle = shapeFactory.getShape("RECTANGLE");
        rectangle.draw();
    }
}

常见实践

观察者模式

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

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

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

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

// 具体主题类
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String state;

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
        notifyObservers();
    }

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

// 具体观察者类
class ConcreteObserver implements Observer {
    private ConcreteSubject subject;

    public ConcreteObserver(ConcreteSubject subject) {
        this.subject = subject;
        subject.registerObserver(this);
    }

    @Override
    public void update() {
        System.out.println("Observer updated. New state: " + subject.getState());
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject();
        ConcreteObserver observer1 = new ConcreteObserver(subject);
        ConcreteObserver observer2 = new ConcreteObserver(subject);

        subject.setState("New state");
    }
}

策略模式

策略模式定义了一系列的算法，并将每个算法封装起来，使它们可以相互替换。

// 策略接口
interface Strategy {
    int doOperation(int num1, int num2);
}

// 具体策略类
class AddStrategy implements Strategy {
    @Override
    public int doOperation(int num1, int num2) {
        return num1 + num2;
    }
}

class SubtractStrategy implements Strategy {
    @Override
    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);
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        Context context = new Context(new AddStrategy());
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5));

        context = new Context(new SubtractStrategy());
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
    }
}

最佳实践

按需选择模式：根据具体的业务需求和问题场景，选择合适的设计模式，避免过度设计。
遵循设计原则：遵循开闭原则、里氏替换原则等设计原则，确保代码的可维护性和可扩展性。
代码复用：充分利用设计模式的可复用性，减少重复代码的编写。

小结

本文详细介绍了 Java 设计模式的基础概念、使用方法、常见实践以及最佳实践。通过具体的代码示例，展示了单例模式、工厂模式、观察者模式和策略模式的实现和应用。合理运用设计模式可以提高代码的质量和开发效率，希望读者能够在实际开发中灵活运用这些模式。

参考资料

《Effective Java》
《设计模式：可复用面向对象软件的基础》
Java 官方文档