设计模式(Design Pattern)是软件设计中的一种通用解决方案，旨在解决在开发过程中遇到的常见问题。Java 作为一种面向对象的编程语言，支持丰富的设计模式，能够帮助开发人员创建更具可维护性、可扩展性和复用性的代码。
一、设计模式的分类
设计模式通常分为三大类：
创建型模式：关注如何创建对象。常见的设计模式有单例模式、工厂模式、抽象工厂模式、建造者模式和原型模式。
结构型模式：关注如何将类或对象组合成更大的结构。常见的设计模式有适配器模式、装饰器模式、代理模式、外观模式、桥接模式和组合模式。
行为型模式：关注对象之间的通信与协作。常见的设计模式有观察者模式、策略模式、命令模式、责任链模式、状态模式和模板方法模式。
二、常用设计模式及应用场景解析
1. 单例模式(Singleton Pattern)
定义：单例模式确保一个类只有一个实例，并提供全局访问点。
应用场景：
需要一个类只有一个实例的情况，如数据库连接池、线程池、日志记录器等。
配置管理类。
实现方式：
懒汉式(线程不安全)
懒汉式(线程安全)
饿汉式(线程安全)
双重检查锁(线程安全)
javaCopy Codepublic class Singleton {
private static Singleton instance;
// 私有构造函数，防止外部创建对象
private Singleton() {}
// 双重检查锁的线程安全实现
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
2. 工厂模式(Factory Pattern)
定义：工厂模式提供了创建对象的接口，但由子类决定实例化哪个类。
应用场景：
需要生成大量相关或相似对象时，避免直接调用构造函数。
需要根据不同的输入条件选择不同类的实例。
实现方式：
简单工厂：通过一个工厂类返回不同类型的对象。
工厂方法：让子类决定创建哪个具体产品类。
抽象工厂：创建一组相关的工厂，负责创建不同系列的产品。
javaCopy Code// 简单工厂
public class AnimalFactory {
public static Animal createAnimal(String type) {
if ("Dog".equals(type)) {
return new Dog();
} else if ("Cat".equals(type)) {
return new Cat();
}
return null;
}
}
// 工厂方法
public abstract class AnimalFactory {
public abstract Animal createAnimal();
}
public class DogFactory extends AnimalFactory {
@Override
public Animal createAnimal() {
return new Dog();
}
}
3. 观察者模式(Observer Pattern)
定义：观察者模式定义了一种一对多的依赖关系，使得当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。
应用场景：
事件驱动系统，如 UI 更新、股票行情更新等。
需要对象间自动同步的场景。
实现方式：
主题类(Subject)：保持一组观察者对象，提供添加和删除观察者的方法。
观察者类(Observer)：定义更新接口，通知观察者进行相应更新。
javaCopy Codepublic 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() {
for (Observer observer : observers) {
observer.update();
}
}
}
public interface Observer {
void update();
}
4. 策略模式(Strategy Pattern)
定义：策略模式定义了一系列算法，并将每一个算法封装起来，使得它们可以互换。策略模式让算法独立于使用它的客户端独立变化。
应用场景：
当系统有多个算法可以选择时，根据不同的需求选择不同的算法进行计算。
例如排序算法的选择，支付方式的选择。
实现方式：
定义一个策略接口，每个策略类实现这个接口。
客户端通过注入不同的策略来实现不同的行为。
javaCopy Codepublic interface Strategy {
int doOperation(int a, int b);
}
public class AddOperation implements Strategy {
@Override
public int doOperation(int a, int b) {
return a + b;
}
}
public class Context {
private Strategy strategy;
public Context(Strategy strategy) {
this.strategy = strategy;
}
public int executeStrategy(int a, int b) {
return strategy.doOperation(a, b);
}
}
5. 代理模式(Proxy Pattern)
定义：代理模式为其他对象提供一个代理，以控制对这个对象的访问。
应用场景：
对象的创建成本较高，使用代理对象来延迟创建。
需要对访问进行控制，如访问权限控制、懒加载等。
实现方式：
虚拟代理：用于控制对象的创建。
远程代理：用于表示远程对象。
保护代理：用于控制对对象的访问权限。
javaCopy Codepublic interface RealSubject {
void request();
}
public class RealSubjectImpl implements RealSubject {
@Override
public void request() {
System.out.println("Real Subject request.");
}
}
public class ProxySubject implements RealSubject {
private RealSubjectImpl realSubject;
@Override
public void request() {
if (realSubject == null) {
realSubject = new RealSubjectImpl();
}
realSubject.request();
}
}
6. 装饰器模式(Decorator Pattern)
定义：装饰器模式允许在不改变原始对象的情况下，动态地给对象添加额外的功能。
应用场景：
需要为一个对象增加额外的功能，而又不希望修改对象的源代码。
例如日志记录、性能监控等。
实现方式：
使用装饰器类扩展被装饰的类功能。
javaCopy Codepublic interface Coffee {
double cost();
}
public class SimpleCoffee implements Coffee {
@Override
public double cost() {
return 5;
}
}
public class MilkDecorator implements Coffee {
private Coffee coffee;
public MilkDecorator(Coffee coffee) {
this.coffee = coffee;
}
@Override
public double cost() {
return coffee.cost() + 2;
}
}
设计模式在软件开发中扮演着至关重要的角色。理解并掌握常用设计模式，不仅能够提高开发效率，还能增强代码的可维护性和可扩展性。本文介绍了几种常见的 Java 设计模式及其应用场景，希望能帮助你更好地理解如何运用这些模式来解决实际问题。
