（Java基础笔记vlog）Java中常见的几种设计模式详解

前言：

在 Java 编程里，设计模式是被反复使用、多数人知晓、经过分类编目的代码设计经验总结。他能帮助开发者更高效地解决常见问题，提升代码的可维护性、可扩展性和复用性。下面介绍Java 中几种常见的设计模式。

单例模式（Singleton Pattern）
工厂模式（Factory Pattern）
代理模式（Proxy Pattern）
装饰器模式（Decorator Pattern）
观察者模式（Observer Pattern）
策略模式（Strategy Pattern）
模板方法模式（Template Method Pattern）
适配器模式（Adapter Pattern）
责任链模式（Chain of Responsibility Pattern）

1.单例模式（Singleton Pattern）

核心思想：封装化所有构造方法确保一个类只有一个实例，并提供一个全局访问点。

示例：

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

2.工厂模式（Factory Pattern）

核心思想：他通过封装对象的创建逻辑，实现了对象创建和使用的分离，提高了代码的可维护性和可扩展性。

示例：

// 接口
interface Shape {
    void draw();
}

// 实现类
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个圆形");
    }
}

class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("画一个矩形");
    }
}

// 工厂类
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;
    }
}

3.代理模式（Proxy Pattern）

核心思想：为其他对象提供一种代理以控制对这个对象的访问。

示例：

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

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

// 代理类
public class Proxy implements Subject {
    private RealSubject realSubject;

    @Override
    public void request() {
        if (realSubject == null) {
            realSubject = new RealSubject();
        }
        realSubject.request();  // 代理控制对真实主题的访问
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Subject proxy = new Proxy();
        proxy.request();  // 通过代理访问真实主题
    }
}

4.装饰器模式（Decorator Pattern）

核心思想：装饰器模式动态地给一个对象添加一些额外的职责。

示例：

// 接口
interface Coffee {
    double getCost();
    String getDescription();
}

// 基础实现
class SimpleCoffee implements Coffee {
    @Override
    public double getCost() {
        return 1.0;
    }
    @Override
    public String getDescription() {
        return "简单咖啡";
    }
}

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

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

5.观察者模式（Observer Pattern）

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

示例：

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

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

// 观察者接口
interface Observer {
    void update(double temperature, double humidity, double pressure);
}

// 具体主题
class WeatherData implements Subject {
    private List<Observer> observers;
    private double temperature;
    private double humidity;
    private double pressure;

    public WeatherData() {
        observers = new ArrayList<>();
    }

    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update(temperature, humidity, pressure);
        }
    }

    public void measurementsChanged() {
        notifyObservers();
    }

    public void setMeasurements(double temperature, double humidity, double pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        measurementsChanged();
    }
}

6.策略模式（Strategy Pattern）

核心思想：策略模式定义一系列的算法，并将每个算法封装起来，使他们可以相互替换。

示例：

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

// 具体策略
class CreditCardStrategy implements PaymentStrategy {
    private String cardNumber;
    private String cvv;
    private String dateOfExpiry;

    public CreditCardStrategy(String cardNumber, String cvv, String dateOfExpiry) {
        this.cardNumber = cardNumber;
        this.cvv = cvv;
        this.dateOfExpiry = dateOfExpiry;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount + " 元使用信用卡支付");
    }
}

class PayPalStrategy implements PaymentStrategy {
    private String emailId;
    private String password;

    public PayPalStrategy(String emailId, String password) {
        this.emailId = emailId;
        this.password = password;
    }

    @Override
    public void pay(int amount) {
        System.out.println(amount + " 元使用PayPal支付");
    }
}

// 上下文
class ShoppingCart {
    private PaymentStrategy paymentStrategy;

    public void setPaymentStrategy(PaymentStrategy paymentStrategy) {
        this.paymentStrategy = paymentStrategy;
    }

    public void pay(int amount) {
        paymentStrategy.pay(amount);
    }
}

7.模板方法模式（Template Method Pattern）

核心思想：模板方法模式定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

示例：

// 抽象类
abstract class Game {
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();

    // 模板方法
    public final void play() {
        // 初始化游戏
        initialize();
        // 开始游戏
        startPlay();
        // 结束游戏
        endPlay();
    }
}

// 具体类
class Cricket extends Game {
    @Override
    void initialize() {
        System.out.println("板球游戏初始化，准备场地");
    }
    @Override
    void startPlay() {
        System.out.println("板球游戏开始，玩起来！");
    }
    @Override
    void endPlay() {
        System.out.println("板球游戏结束，统计分数");
    }
}

class Football extends Game {
    @Override
    void initialize() {
        System.out.println("足球游戏初始化，准备场地和球");
    }
    @Override
    void startPlay() {
        System.out.println("足球游戏开始，踢起来！");
    }
    @Override
    void endPlay() {
        System.out.println("足球游戏结束，统计分数");
    }
}

8.适配器模式（Adapter Pattern）

核心思想：适配器模式将一个类的接口转换成客户希望的另外一个接口。

示例：

// 目标接口
interface MediaPlayer {
    void play(String audioType, String fileName);
}

// 被适配的类
class VlcPlayer {
    public void playVlc(String fileName) {
        System.out.println("播放VLC文件: " + fileName);
    }
}

// 适配器
class MediaAdapter implements MediaPlayer {
    private VlcPlayer vlcPlayer;

    public MediaAdapter() {
        vlcPlayer = new VlcPlayer();
    }

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("vlc")) {
            vlcPlayer.playVlc(fileName);
        }
    }
}

// 具体实现类
class AudioPlayer implements MediaPlayer {
    private MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("vlc")) {
            mediaAdapter = new MediaAdapter();
            mediaAdapter.play(audioType, fileName);
        } else {
            System.out.println("播放 " + audioType + " 文件: " + fileName);
        }
    }
}

9.责任链模式（Chain of Responsibility Pattern）

核心思想：责任链模式为请求创建了一个接收者对象的链，每个接收者都包含对另一个接收者的引用。

示例：

// 抽象处理者
abstract class Handler {
    protected Handler nextHandler;

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public abstract void handleRequest(int request);
}

// 具体处理者
class ConcreteHandler1 extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("处理请求: " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

class ConcreteHandler2 extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("处理请求: " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}

class ConcreteHandler3 extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 20) {
            System.out.println("处理请求: " + request);
        } else if (nextHandler != null) {
            nextHandler.handleRequest(request);
        }
    }
}