Java中设计模式的28种方式

最新推荐文章于 2023-09-01 19:36:49 发布

数字世界探索者

最新推荐文章于 2023-09-01 19:36:49 发布

阅读量435

点赞数 4

文章标签： java 设计模式开发语言

数字世界探险者

本文链接：https://blog.csdn.net/s55646nsn/article/details/131619850

版权

Java中设计模式的28种方式:

1、简单工厂模式（Simple Factory）
2、工厂方法模式（Factory Method）
3、抽象工厂模式（Abstract Factory）
4、单例模式（Singleton）
                    (1)懒汉式单例模式
                    (2)饿汉式单例模式
                    (3)双重检验锁式单例模式
5、建造者模式（Builder）
6、原型模式（Prototype）
7、适配器模式（Adapter）
8、桥接模式（Bridge）
9、组合模式（Composite）
10、装饰器模式（Decorator）
11、外观模式（Facade）
12、享元模式（Flyweight）
13、观察者模式（Observer）
14、策略模式（Strategy）
15、模板方法模式（Template Method）
16、命令模式（Command）
17、责任链模式（Chain of Responsibility）
18、状态模式（State）
19、访问者模式（Visitor）
20、中介者模式（Mediator）
21、备忘录模式（Memento）
22、解释器模式（Interpreter）
23、并发模式（Concurrency Patterns）
24、互斥锁模式（Mutex）
25、读写锁模式（Read-Write Lock）
26、线程池模式（Thread Pool）
27、生产者消费者模式（Producer-Consumer）
28、保护性暂停模式（Guarded Suspension）

1、简单工厂模式（Simple Factory）：例如，创建一个图形对象的简单工厂类，根据传入的参数创建对应类型的图形对象，如创建圆形、矩形或三角形对象。

// 定义图形接口
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 Triangle implements Shape {
    @Override
    public void draw() {
        System.out.println("绘制三角形");
    }
}

// 简单工厂类
class ShapeFactory {
    // 根据传入的参数创建相应的图形对象
    public static Shape createShape(String type) {
        if (type.equalsIgnoreCase("circle")) {
            return new Circle();
        } else if (type.equalsIgnoreCase("rectangle")) {
            return new Rectangle(); 
        } else if (type.equalsIgnoreCase("triangle")) {
            return new Triangle(); 
        }
        return null;
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 使用简单工厂创建不同类型的图形对象
        Shape circle = ShapeFactory.createShape("circle");
        Shape rectangle = ShapeFactory.createShape("rectangle");
        Shape triangle = ShapeFactory.createShape("triangle");
        
        // 调用图形对象的 draw 方法
        circle.draw();
        rectangle.draw();
        triangle.draw();
    }
}

2、工厂方法模式（Factory Method）：例如，一个网上商城的订单处理系统，每个订单类型都有对应的订单处理类，通过工厂方法根据不同类型的订单创建对应的订单处理对象。

// 定义订单接口
interface Order {
    void process();
}

// 实现普通订单类
class NormalOrder implements Order {
    @Override
    public void process() {
        System.out.println("处理普通订单");
    }
}

// 实现特殊订单类
class SpecialOrder implements Order {
    @Override
    public void process() {
        System.out.println("处理特殊订单");
    }
}

// 订单工厂接口
interface OrderFactory {
    Order createOrder();
}

// 实现普通订单工厂类
class NormalOrderFactory implements OrderFactory {
    @Override
    public Order createOrder() {
        return new NormalOrder();
    }
}

// 实现特殊订单工厂类
class SpecialOrderFactory implements OrderFactory {
    @Override
    public Order createOrder() {
        return new SpecialOrder();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 使用普通订单工厂创建普通订单对象
        OrderFactory normalOrderFactory = new NormalOrderFactory();
        Order normalOrder = normalOrderFactory.createOrder();
        normalOrder.process();

        // 使用特殊订单工厂创建特殊订单对象
        OrderFactory specialOrderFactory = new SpecialOrderFactory();
        Order specialOrder = specialOrderFactory.createOrder();
        specialOrder.process();
    }
}

3、抽象工厂模式（Abstract Factory）：例如，一个汽车工厂生产不同类型的汽车，每个类型的汽车由具体的工厂负责生产，如轿车工厂负责生产轿车、SUV工厂负责生产SUV等。

// 抽象汽车接口
interface Car {
    void produce();
}

// 具体轿车类
class SedanCar implements Car {
    @Override
    public void produce() {
        System.out.println("生产轿车");
    }
}

// 具体SUV类
class SuvCar implements Car {
    @Override
    public void produce() {
        System.out.println("生产SUV");
    }
}

// 抽象工厂接口
interface CarFactory {
    Car createCar();
}

// 轿车工厂类
class SedanCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SedanCar();
    }
}

// SUV工厂类
class SuvCarFactory implements CarFactory {
    @Override
    public Car createCar() {
        return new SuvCar();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 使用轿车工厂创建轿车对象
        CarFactory sedanCarFactory = new SedanCarFactory();
        Car sedanCar = sedanCarFactory.createCar();
        sedanCar.produce();

        // 使用SUV工厂创建SUV对象
        CarFactory suvCarFactory = new SuvCarFactory();
        Car suvCar = suvCarFactory.createCar();
        suvCar.produce();
    }
}

4、单例模式（Singleton）：例如，数据库连接池的管理类，确保只有一个数据库连接池实例，通过静态方法提供全局访问点。

(1)懒汉式单例模式

public class DatabaseConnectionPool {

    private static DatabaseConnectionPool instance;

    private DatabaseConnectionPool() {
        // 私有构造函数，避免外部实例化
    }

    public static synchronized DatabaseConnectionPool getInstance() {
        if (instance == null) {
            instance = new DatabaseConnectionPool();
        }
        return instance;
    }
    
    // 其他数据库连接池的相关方法和属性
}

(2)饿汉式单例模式

public class DatabaseConnectionPool {

    private static final DatabaseConnectionPool instance = new DatabaseConnectionPool();

    private DatabaseConnectionPool() {
        // 私有构造函数，避免外部实例化
    }

    public static DatabaseConnectionPool getInstance() {
        return instance;
    }
    
    // 其他数据库连接池的相关方法和属性
}

(3)双重检验锁式单例模式

public class DatabaseConnectionPool {

    private static volatile DatabaseConnectionPool instance;

    private DatabaseConnectionPool() {
        // 私有构造函数，避免外部实例化
    }

    public static DatabaseConnectionPool getInstance() {
        if (instance == null) {
            synchronized (DatabaseConnectionPool.class) {
                if (instance == null) {
                    instance = new DatabaseConnectionPool();
                }
            }
        }
        return instance;
    }
    
    // 其他数据库连接池的相关方法和属性
}

5、建造者模式（Builder）：例如，一个电脑生产线，通过建造者模式可以将电脑的组装过程与不同类型的电脑表示分离，通过相同的组装过程可以构建不同类型的电脑。

// 电脑类
class Computer {
    private String cpu;
    private String ram;
    private String storage;

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public void setRam(String ram) {
        this.ram = ram;
    }

    public void setStorage(String storage) {
        this.storage = storage;
    }

    public String getConfiguration() {
        return "CPU: " + cpu + ", RAM: " + ram + ", Storage: " + storage;
    }
}

// 电脑建造者接口
interface ComputerBuilder {
    void buildCpu();

    void buildRam();

    void buildStorage();

    Computer getComputer();
}

// 具体电脑建造者类
class DesktopComputerBuilder implements ComputerBuilder {
    private Computer computer;

    public DesktopComputerBuilder() {
        computer = new Computer();
    }

    @Override
    public void buildCpu() {
        computer.setCpu("Desktop CPU");
    }

    @Override
    public void buildRam() {
        computer.setRam("16GB");
    }

    @Override
    public void buildStorage() {
        computer.setStorage("1TB HDD");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

// 具体电脑建造者类
class LaptopComputerBuilder implements ComputerBuilder {
    private Computer computer;

    public LaptopComputerBuilder() {
        computer = new Computer();
    }

    @Override
    public void buildCpu() {
        computer.setCpu("Laptop CPU");
    }

    @Override
    public void buildRam() {
        computer.setRam("8GB");
    }

    @Override
    public void buildStorage() {
        computer.setStorage("512GB SSD");
    }

    @Override
    public Computer getComputer() {
        return computer;
    }
}

// 电脑生产线
class ComputerAssemblyLine {
    public void assembleComputer(ComputerBuilder computerBuilder) {
        computerBuilder.buildCpu();
        computerBuilder.buildRam();
        computerBuilder.buildStorage();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        ComputerBuilder desktopBuilder = new DesktopComputerBuilder();
        ComputerAssemblyLine assemblyLine = new ComputerAssemblyLine();
        
        assemblyLine.assembleComputer(desktopBuilder);
        Computer desktop = desktopBuilder.getComputer();
        System.out.println(desktop.getConfiguration());
        
        ComputerBuilder laptopBuilder = new LaptopComputerBuilder();
        assemblyLine.assembleComputer(laptopBuilder);
        Computer laptop = laptopBuilder.getComputer();
        System.out.println(laptop.getConfiguration());
    }
}

6、原型模式（Prototype）：例如，一个文件管理系统中，复制文件时可以使用原型模式，通过复制已有的文件对象来创建新的文件对象。

// 文件类
class File implements Cloneable {
    private String name;
    private String path;

    public File(String name, String path) {
        this.name = name;
        this.path = path;
    }

    // Getters and setters

    public String getName() {
        return name;
    }

    public String getPath() {
        return path;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setPath(String path) {
        this.path = path;
    }

    // 克隆方法
    @Override
    public File clone() throws CloneNotSupportedException {
        return (File) super.clone();
    }
}

// 文件管理系统
class FileManager {
    private File file;

    public FileManager(File file) {
        this.file = file;
    }

    // 复制文件
    public File copyFile() throws CloneNotSupportedException {
        return file.clone();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 创建原始文件对象
        File originalFile = new File("original.txt", "/path/to/original.txt");

        // 创建文件管理系统
        FileManager fileManager = new FileManager(originalFile);

        try {
            // 复制文件
            File copiedFile = fileManager.copyFile();

            // 修改副本文件的相关属性
            copiedFile.setName("copied.txt");
            copiedFile.setPath("/path/to/copied.txt");

            // 打印原始文件和副本文件的信息
            System.out.println("Original File: " + originalFile.getName() + ", " + originalFile.getPath());
            System.out.println("Copied File: " + copiedFile.getName() + ", " + copiedFile.getPath());
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

7、适配器模式（Adapter）：例如，一个音频播放器只支持MP3格式的音乐文件，但是有一个新的音乐格式需要播放，可以通过适配器模式，创建一个适配器，将新的音乐格式转换为MP3格式。

// MP3音乐播放器接口
interface Mp3Player {
    void playMp3(String fileName);
}

// MP3音乐播放器实现类
class SimpleMp3Player implements Mp3Player {
    @Override
    public void playMp3(String fileName) {
        System.out.println("Playing MP3 file: " + fileName);
    }
}

// 新的音乐格式接口
interface NewMusicFormatPlayer {
    void play(String fileName);
}

// 新的音乐格式实现类
class NewMusicFormatPlayerImpl implements NewMusicFormatPlayer {
    @Override
    public void play(String fileName) {
        System.out.println("Playing new music format file: " + fileName);
    }
}

// 适配器类
class MusicFormatAdapter implements Mp3Player {
    private NewMusicFormatPlayer newMusicFormatPlayer;

    public MusicFormatAdapter(NewMusicFormatPlayer newMusicFormatPlayer) {
        this.newMusicFormatPlayer = newMusicFormatPlayer;
    }

    @Override
    public void playMp3(String fileName) {
        // 调用新的音乐格式播放器，将新的音乐格式转换为MP3格式
        newMusicFormatPlayer.play(fileName);
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 创建MP3音乐播放器对象
        Mp3Player mp3Player = new SimpleMp3Player();
        
        // 播放MP3格式音乐文件
        mp3Player.playMp3("music.mp3");
        
        // 创建新的音乐格式播放器对象
        NewMusicFormatPlayer newMusicFormatPlayer = new NewMusicFormatPlayerImpl();
        
        // 使用适配器将新的音乐格式转换为MP3格式，并播放
        MusicFormatAdapter adapter = new MusicFormatAdapter(newMusicFormatPlayer);
        adapter.playMp3("music.m4a");
    }
}

8、桥接模式（Bridge）：例如，一个绘图软件，可以选择不同的绘图工具（如画笔、画刷），可以通过桥接模式将绘图工具的实现与绘图操作分离，使得可以独立地扩展和变化。

// 绘图工具接口
interface DrawingTool {
    void draw();
}

// 具体的绘图工具实现类：画笔
class Pen implements DrawingTool {
    @Override
    public void draw() {
        System.out.println("Using pen to draw.");
    }
}

// 具体的绘图工具实现类：画刷
class Brush implements DrawingTool {
    @Override
    public void draw() {
        System.out.println("Using brush to draw.");
    }
}

// 绘图操作抽象类
abstract class DrawingOperation {
    protected DrawingTool drawingTool;

    public DrawingOperation(DrawingTool drawingTool) {
        this.drawingTool = drawingTool;
    }

    public abstract void performDraw();
}

// 具体的绘图操作实现类：自由绘图
class FreeDrawOperation extends DrawingOperation {
    public FreeDrawOperation(DrawingTool drawingTool) {
        super(drawingTool);
    }

    @Override
    public void performDraw() {
        System.out.println("Performing free drawing operation.");
        drawingTool.draw();
    }
}

// 具体的绘图操作实现类：填充绘图
class FillDrawOperation extends DrawingOperation {
    public FillDrawOperation(DrawingTool drawingTool) {
        super(drawingTool);
    }

    @Override
    public void performDraw() {
        System.out.println("Performing fill drawing operation.");
        drawingTool.draw();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 创建画笔绘图工具
        DrawingTool pen = new Pen();
        
        // 创建自由绘图操作，并传入画笔绘图工具
        DrawingOperation freeDraw = new FreeDrawOperation(pen);
        
        // 执行自由绘图操作
        freeDraw.performDraw();
        
        // 创建画刷绘图工具
        DrawingTool brush = new Brush();
        
        // 创建填充绘图操作，并传入画刷绘图工具
        DrawingOperation fillDraw = new FillDrawOperation(brush);
        
        // 执行填充绘图操作
        fillDraw.performDraw();
    }
}

9、组合模式（Composite）：例如，一个目录结构，目录可以包含文件和其他目录，通过组合模式可以将文件和目录统一看做成组件，可以递归处理整个目录结构。

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

// 组件接口
interface Component {
    void display();
}

// 文件类，实现了组件接口
class File implements Component {
    private String name;

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

    @Override
    public void display() {
        System.out.println("File: " + name);
    }
}

// 目录类，实现了组件接口
class Directory implements Component {
    private String name;
    private List<Component> components;

    public Directory(String name) {
        this.name = name;
        this.components = new ArrayList<>();
    }

    // 添加组件
    public void addComponent(Component component) {
        components.add(component);
    }

    // 移除组件
    public void removeComponent(Component component) {
        components.remove(component);
    }

    @Override
    public void display() {
        System.out.println("Directory: " + name);
        for (Component component : components) {
            component.display();
        }
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 创建文件对象
        File file1 = new File("file1.txt");
        File file2 = new File("file2.txt");

        // 创建目录对象
        Directory directory1 = new Directory("dir1");
        Directory directory2 = new Directory("dir2");

        // 将文件添加到目录中
        directory1.addComponent(file1);
        directory2.addComponent(file2);

        // 创建更高层次的目录对象
        Directory root = new Directory("root");

        // 将目录添加到更高层次的目录中
        root.addComponent(directory1);
        root.addComponent(directory2);

        // 执行递归显示整个目录结构
        root.display();
    }
}

10、装饰器模式（Decorator）：例如，一个咖啡店可以在咖啡基础上加入不同的配料，通过装饰器模式可以动态地给咖啡添加配料，实现不同口味的咖啡。

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

// 基础咖啡类
class BasicCoffee implements Coffee {
    @Override
    public String getDescription() {
        return "Basic Coffee";
    }

    @Override
    public double getCost() {
        return 2.0;
    }
}

// 抽象装饰器类
abstract class CoffeeDecorator implements Coffee {
    protected Coffee coffee;

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

    @Override
    public String getDescription() {
        return coffee.getDescription();
    }

    @Override
    public double getCost() {
        return coffee.getCost();
    }
}

// 具体装饰器类：加糖
class SugarDecorator extends CoffeeDecorator {
    public SugarDecorator(Coffee coffee) {
        super(coffee);
    }

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

    @Override
    public double getCost() {
        return coffee.getCost() + 0.5;
    }
}

// 具体装饰器类：加奶泡
class MilkFoamDecorator extends CoffeeDecorator {
    public MilkFoamDecorator(Coffee coffee) {
        super(coffee);
    }

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

    @Override
    public double getCost() {
        return coffee.getCost() + 1.0;
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        // 创建基础咖啡对象
        Coffee coffee = new BasicCoffee();

        // 加糖
        Coffee sugarCoffee = new SugarDecorator(coffee);
        System.out.println("Description: " + sugarCoffee.getDescription());
        System.out.println("Cost: " + sugarCoffee.getCost());

        // 加奶泡
        Coffee milkFoamCoffee = new MilkFoamDecorator(coffee);
        System.out.println("Description: " + milkFoamCoffee.getDescription());
        System.out.println("Cost: " + milkFoamCoffee.getCost());

        // 加糖和奶泡
        Coffee sugarAndMilkFoamCoffee = new MilkFoamDecorator(new SugarDecorator(coffee));
        System.out.println("Description: " + sugarAndMilkFoamCoffee.getDescription());
        System.out.println("Cost: " + sugarAndMilkFoamCoffee.getCost());
    }
}

11、外观模式（Facade）：例如，一个计算器类，提供了加减乘除等操作，通过外观模式可以将计算器类的复杂操作封装成简单的接口，供客户端直接调用。

// 计算器类
class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public int subtract(int a, int b) {
        return a - b;
    }

    public int multiply(int a, int b) {
        return a * b;
    }

    public int divide(int a, int b) {
        if (b != 0) {
            return a / b;
        }
        throw new ArithmeticException("Cannot divide by zero");
    }
}

// 外观类
class CalculatorFacade {
    private Calculator calculator;

    public CalculatorFacade() {
        this.calculator = new Calculator();
    }

    public int add(int a, int b) {
        return calculator.add(a, b);
    }

    public int subtract(int a, int b) {
        return calculator.subtract(a, b);
    }

    public int multiply(int a, int b) {
        return calculator.multiply(a, b);
    }

    public int divide(int a, int b) {
        return calculator.divide(a, b);
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        CalculatorFacade calculator = new CalculatorFacade();

        // 直接调用外观类提供的简单接口
        int additionResult = calculator.add(5, 3);
        System.out.println("Addition Result: " + additionResult);

        int subtractionResult = calculator.subtract(5, 3);
        System.out.println("Subtraction Result: " + subtractionResult);

        int multiplicationResult = calculator.multiply(5, 3);
        System.out.println("Multiplication Result: " + multiplicationResult);

        int divisionResult = calculator.divide(5, 3);
        System.out.println("Division Result: " + divisionResult);
    }
}

12、享元模式（Flyweight）：例如，一个文字处理软件，通过享元模式可以共享字体库中的相同字符，减少内存消耗。

import java.util.HashMap;
import java.util.Map;

// 字符类
class Character {
    private char symbol;
    private String fontFamily;
    private int fontSize;

    public Character(char symbol, String fontFamily, int fontSize) {
        this.symbol = symbol;
        this.fontFamily = fontFamily;
        this.fontSize = fontSize;
    }

    public void display() {
        System.out.println("Character: " + symbol + ", Font Family: " + fontFamily + ", Font Size: " + fontSize);
    }
}

// 字符工厂类
class CharacterFactory {
    private Map<Character, Character> characters;

    public CharacterFactory() {
        this.characters = new HashMap<>();
    }

    public Character getCharacter(char symbol, String fontFamily, int fontSize) {
        Character character = new Character(symbol, fontFamily, fontSize);
        if (characters.containsKey(character)) {
            return characters.get(character);
        } else {
            characters.put(character, character);
            return character;
        }
    }
}

// 文字处理软件类
class TextProcessor {
    private CharacterFactory characterFactory;

    public TextProcessor(CharacterFactory characterFactory) {
        this.characterFactory = characterFactory;
    }

    public void displayCharacter(char symbol, String fontFamily, int fontSize) {
        Character character = characterFactory.getCharacter(symbol, fontFamily, fontSize);
        character.display();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        CharacterFactory characterFactory = new CharacterFactory();
        TextProcessor textProcessor = new TextProcessor(characterFactory);

        // 显示字符'A'
        textProcessor.displayCharacter('A', "Arial", 12);

        // 再次显示字符'A'
        textProcessor.displayCharacter('A', "Arial", 12);

        // 显示字符'B'
        textProcessor.displayCharacter('B', "Times New Roman", 16);
    }
}

13、观察者模式（Observer）：例如，一个天气应用程序，多个观察者（如显示器、手机等）可以订阅天气数据，当天气数据发生变化时，观察者会自动得到通知并更新显示。

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

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

// 具体主题类：天气数据
class WeatherData implements Subject {
    private double temperature;
    private double humidity;
    private double pressure;
    private List<Observer> observers;

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

    @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(temperature, humidity, pressure);
        }
    }

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

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

// 具体观察者类：显示器
class Display implements Observer {
    private double temperature;
    private double humidity;
    private double pressure;

    @Override
    public void update(double temperature, double humidity, double pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }

    public void display() {
        System.out.println("Display - Temperature: " + temperature + ", Humidity: " + humidity + ", Pressure: " + pressure);
    }
}

// 具体观察者类：手机
class Phone implements Observer {
    private double temperature;
    private double humidity;
    private double pressure;

    @Override
    public void update(double temperature, double humidity, double pressure) {
        this.temperature = temperature;
        this.humidity = humidity;
        this.pressure = pressure;
        display();
    }

    public void display() {
        System.out.println("Phone - Temperature: " + temperature + ", Humidity: " + humidity + ", Pressure: " + pressure);
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        WeatherData weatherData = new WeatherData();

        Observer display = new Display();
        Observer phone = new Phone();

        weatherData.registerObserver(display);
        weatherData.registerObserver(phone);

        // 模拟天气数据变化，通知观察者更新显示
        weatherData.setMeasurements(25.0, 60.0, 1013.0);
    }
}

14、策略模式（Strategy）：例如，一个支付系统可以根据不同的支付方式（如支付宝、微信、银联）选择不同的支付策略，灵活地切换支付方式。

// 支付策略接口
interface PaymentStrategy {
    void pay(double amount);
}

// 支付宝支付策略
class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid " + amount + " RMB using Alipay.");
    }
}

// 微信支付策略
class WechatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid " + amount + " RMB using Wechat Pay.");
    }
}

// 银联支付策略
class UnionPayStrategy implements PaymentStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("Paid " + amount + " RMB using Union Pay.");
    }
}

// 支付系统类
class PaymentSystem {
    private PaymentStrategy paymentStrategy;

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

    public void makePayment(double amount) {
        paymentStrategy.pay(amount);
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        PaymentSystem paymentSystem = new PaymentSystem();

        // 使用支付宝支付
        PaymentStrategy alipay = new AlipayStrategy();
        paymentSystem.setPaymentStrategy(alipay);
        paymentSystem.makePayment(100.0);

        // 使用微信支付
        PaymentStrategy wechatPay = new WechatPayStrategy();
        paymentSystem.setPaymentStrategy(wechatPay);
        paymentSystem.makePayment(200.0);

        // 使用银联支付
        PaymentStrategy unionPay = new UnionPayStrategy();
        paymentSystem.setPaymentStrategy(unionPay);
        paymentSystem.makePayment(300.0);
    }
}

15、模板方法模式（Template Method）：例如，一个算法类中有多个具体的算法步骤，通过模板方法模式可以定义算法的骨架，并由子类实现具体的算法步骤。

// 算法类
abstract class Algorithm {
    // 模板方法
    public void execute() {
        step1(); // 执行算法步骤1
        step2(); // 执行算法步骤2
        step3(); // 执行算法步骤3
        // ...
    }

    // 抽象方法，由子类实现具体的算法步骤1
    protected abstract void step1();

    // 抽象方法，由子类实现具体的算法步骤2
    protected abstract void step2();

    // 抽象方法，由子类实现具体的算法步骤3
    protected abstract void step3();
}

// 具体算法类A
class ConcreteAlgorithmA extends Algorithm {
    @Override
    protected void step1() {
        System.out.println("ConcreteAlgorithmA - Step 1");
    }

    @Override
    protected void step2() {
        System.out.println("ConcreteAlgorithmA - Step 2");
    }

    @Override
    protected void step3() {
        System.out.println("ConcreteAlgorithmA - Step 3");
    }
}

// 具体算法类B
class ConcreteAlgorithmB extends Algorithm {
    @Override
    protected void step1() {
        System.out.println("ConcreteAlgorithmB - Step 1");
    }

    @Override
    protected void step2() {
        System.out.println("ConcreteAlgorithmB - Step 2");
    }

    @Override
    protected void step3() {
        System.out.println("ConcreteAlgorithmB - Step 3");
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Algorithm algorithmA = new ConcreteAlgorithmA();
        algorithmA.execute();

        Algorithm algorithmB = new ConcreteAlgorithmB();
        algorithmB.execute();
    }
}

16、命令模式（Command）：例如，一个遥控器类，可以将各种设备（如电视、音响）的操作封装成命令对象，然后通过遥控器发送命令执行相应的操作。

// 命令接口
interface Command {
    void execute();
}

// 具体命令类：打开电视
class TVOnCommand implements Command {
    private TV tv;

    public TVOnCommand(TV tv) {
        this.tv = tv;
    }

    @Override
    public void execute() {
        tv.turnOn();
    }
}

// 具体命令类：关闭电视
class TVOffCommand implements Command {
    private TV tv;

    public TVOffCommand(TV tv) {
        this.tv = tv;
    }

    @Override
    public void execute() {
        tv.turnOff();
    }
}

// 电视类
class TV {
    public void turnOn() {
        System.out.println("TV is turned on.");
    }

    public void turnOff() {
        System.out.println("TV is turned off.");
    }
}

// 音响类
class Stereo {
    public void playMusic() {
        System.out.println("Stereo is playing music.");
    }

    public void stopMusic() {
        System.out.println("Stereo stopped playing music.");
    }
}

// 具体命令类：播放音乐
class StereoPlayCommand implements Command {
    private Stereo stereo;

    public StereoPlayCommand(Stereo stereo) {
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.playMusic();
    }
}

// 具体命令类：停止音乐
class StereoStopCommand implements Command {
    private Stereo stereo;

    public StereoStopCommand(Stereo stereo) {
        this.stereo = stereo;
    }

    @Override
    public void execute() {
        stereo.stopMusic();
    }
}

// 遥控器类
class RemoteControl {
    private Command[] commands;

    public RemoteControl() {
        commands = new Command[2];
    }

    public void setCommand(int slot, Command command) {
        commands[slot] = command;
    }

    public void pressButton(int slot) {
        commands[slot].execute();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        RemoteControl remoteControl = new RemoteControl();

        TV tv = new TV();
        Command tvOnCommand = new TVOnCommand(tv);
        Command tvOffCommand = new TVOffCommand(tv);

        remoteControl.setCommand(0, tvOnCommand);
        remoteControl.setCommand(1, tvOffCommand);

        // 模拟按下遥控器的按钮，执行相应的操作
        remoteControl.pressButton(0); // 打开电视
        remoteControl.pressButton(1); // 关闭电视

        Stereo stereo = new Stereo();
        Command stereoPlayCommand = new StereoPlayCommand(stereo);
        Command stereoStopCommand = new StereoStopCommand(stereo);

        remoteControl.setCommand(0, stereoPlayCommand);
        remoteControl.setCommand(1, stereoStopCommand);

        remoteControl.pressButton(0); // 播放音乐
        remoteControl.pressButton(1); // 停止音乐
    }
}

17、责任链模式（Chain of Responsibility）：例如，一个审批流程，多个审批者可以按照一定顺序处理请求，如果一个审批者无法处理，则将请求传递给下一个审批者，直到有一个审批者能够处理。

// 请求类
class Request {
    private String content;
    private int level;

    public Request(String content, int level) {
        this.content = content;
        this.level = level;
    }

    public String getContent() {
        return content;
    }

    public int getLevel() {
        return level;
    }
}

// 抽象审批者类
abstract class Approver {
    protected Approver nextApprover;

    public void setNextApprover(Approver nextApprover) {
        this.nextApprover = nextApprover;
    }

    public void processRequest(Request request) {
        if (canApprove(request)) {
            approve(request);
        } else if (nextApprover != null) {
            nextApprover.processRequest(request);
        } else {
            System.out.println("No one can handle the request.");
        }
    }

    protected abstract boolean canApprove(Request request);

    protected abstract void approve(Request request);
}

// 具体审批者类: 主任
class Director extends Approver {
    @Override
    protected boolean canApprove(Request request) {
        return request.getLevel() <= 1;
    }

    @Override
    protected void approve(Request request) {
        System.out.println("Director approved the request: " + request.getContent());
    }
}

// 具体审批者类: 经理
class Manager extends Approver {
    @Override
    protected boolean canApprove(Request request) {
        return request.getLevel() <= 3;
    }

    @Override
    protected void approve(Request request) {
        System.out.println("Manager approved the request: " + request.getContent());
    }
}

// 具体审批者类: 总经理
class CEO extends Approver {
    @Override
    protected boolean canApprove(Request request) {
        return request.getLevel() <= 5;
    }

    @Override
    protected void approve(Request request) {
        System.out.println("CEO approved the request: " + request.getContent());
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Approver director = new Director();
        Approver manager = new Manager();
        Approver ceo = new CEO();

        director.setNextApprover(manager);
        manager.setNextApprover(ceo);

        // 创建请求
        Request request1 = new Request("Request 1", 2);
        Request request2 = new Request("Request 2", 4);
        Request request3 = new Request("Request 3", 6);

        // 处理请求
        director.processRequest(request1);
        director.processRequest(request2);
        director.processRequest(request3);
    }
}

18、状态模式（State）：例如，一个电梯系统，电梯可以根据不同的状态（如停止、运行、故障）做出不同的响应。

// 电梯状态接口
interface ElevatorState {
    void open();
    void close();
    void run();
    void stop();
}

// 具体状态类：停止状态
class StopState implements ElevatorState {
    @Override
    public void open() {
        System.out.println("The elevator door is opened.");
    }

    @Override
    public void close() {
        System.out.println("The elevator door is already closed.");
    }

    @Override
    public void run() {
        System.out.println("The elevator starts running.");
    }

    @Override
    public void stop() {
        System.out.println("The elevator has already stopped.");
    }
}

// 具体状态类：运行状态
class RunState implements ElevatorState {
    @Override
    public void open() {
        System.out.println("The elevator is running and cannot be opened.");
    }

    @Override
    public void close() {
        System.out.println("The elevator is already closed.");
    }

    @Override
    public void run() {
        System.out.println("The elevator is already running.");
    }

    @Override
    public void stop() {
        System.out.println("The elevator stops running.");
    }
}

// 具体状态类：故障状态
class ErrorState implements ElevatorState {
    @Override
    public void open() {
        System.out.println("The elevator is not functioning and cannot be opened.");
    }

    @Override
    public void close() {
        System.out.println("The elevator is not functioning and cannot be closed.");
    }

    @Override
    public void run() {
        System.out.println("The elevator is not functioning and cannot run.");
    }

    @Override
    public void stop() {
        System.out.println("The elevator is not functioning and has stopped.");
    }
}

// 电梯类
class Elevator {
    private ElevatorState state;

    public Elevator() {
        state = new StopState();
    }

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

    public void open() {
        state.open();
    }

    public void close() {
        state.close();
    }

    public void run() {
        state.run();
    }

    public void stop() {
        state.stop();
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Elevator elevator = new Elevator();

        // 测试停止状态
        elevator.open();
        elevator.close();
        elevator.run();
        elevator.stop();

        // 测试运行状态
        elevator.setState(new RunState());
        elevator.open();
        elevator.close();
        elevator.run();
        elevator.stop();

        // 测试故障状态
        elevator.setState(new ErrorState());
        elevator.open();
        elevator.close();
        elevator.run();
        elevator.stop();
    }
}

19、访问者模式（Visitor）：例如，一个图形绘制系统，通过访问者模式可以定义一个访问者对象，用于访问不同类型的图形，并进行相应的处理。

// 抽象图形接口
interface Shape {
    void accept(Visitor visitor);
}

// 具体图形类：圆形
class Circle implements Shape {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// 具体图形类：矩形
class Rectangle implements Shape {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

// 访问者接口
interface Visitor {
    void visit(Circle circle);
    void visit(Rectangle rectangle);
}

// 具体访问者类：绘制访问者
class DrawVisitor implements Visitor {
    @Override
    public void visit(Circle circle) {
        System.out.println("绘制圆形");
    }

    @Override
    public void visit(Rectangle rectangle) {
        System.out.println("绘制矩形");
    }
}

// 具体访问者类：计算面积访问者
class AreaVisitor implements Visitor {
    @Override
    public void visit(Circle circle) {
        System.out.println("计算圆形的面积");
    }

    @Override
    public void visit(Rectangle rectangle) {
        System.out.println("计算矩形的面积");
    }
}

// 测试代码
public class Main {
    public static void main(String[] args) {
        Shape circle = new Circle();
        Shape rectangle = new Rectangle();

        Visitor drawVisitor = new DrawVisitor();
        Visitor areaVisitor = new AreaVisitor();

        circle.accept(drawVisitor);
        rectangle.accept(drawVisitor);

        circle.accept(areaVisitor);
        rectangle.accept(areaVisitor);
    }
}

20、中介者模式（Mediator）：例如，一个聊天室系统，多个用户之间通过中介者进行消息的传递，避免了用户之间的直接耦合。

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

// 抽象中介者
interface ChatRoomMediator {
    void sendMessage(String message, User user);
    void addUser(User user);
}

// 具体中介者类：聊天室
class ChatRoom implements ChatRoomMediator {
    private List<User> users;

    public ChatRoom() {
        users = new ArrayList<>();
    }

    @Override
    public void sendMessage(String message, User user) {
        for (User u : users) {
            if (u != user) {
                u.receiveMessage(message);
            }
        }
    }

    @Override
    public void addUser(User user) {
        users.add(user);
    }
}

// 抽象用户类
abstract class User {
    protected ChatRoomMediator mediator;
    protected String name;

    public User(ChatRoomMediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

    public abstract void sendMessage(String message);
    public abstract void receiveMessage(String message);
}

// 具体用户类
class ChatUser extends User {
    public ChatUser(ChatRoomMediator mediator, String name) {
        super(mediator, name);
    }

    @Override
    public void sendMessage(String message) {
        System.out.println(name + " sends message: " + message);
        mediator.sendMessage(message, this);
    }

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

// 测试代码
public class Main {
    public static void main(String[] args) {
        ChatRoomMediator chatRoom = new ChatRoom();

        User user1 = new ChatUser(chatRoom, "User 1");
        User user2 = new ChatUser(chatRoom, "User 2");
        User user3 = new ChatUser(chatRoom, "User 3");

        chatRoom.addUser(user1);
        chatRoom.addUser(user2);
        chatRoom.addUser(user3);

        user1.sendMessage("Hello, everyone!");
        user2.sendMessage("Hi, User 1!");
        user3.sendMessage("Nice to meet you all!");
    }
}

21、备忘录模式（Memento）：例如，一个文本编辑器，用户可以对文本

import java.io.*;

class TextEditor {
    private String text;

    public void createNewFile() {
        text = "";
        System.out.println("New file created.");
    }

    public void openFile(String fileName) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader(fileName));
            StringBuilder stringBuilder = new StringBuilder();
            String line;
            
            while ((line = reader.readLine()) != null) {
                stringBuilder.append(line);
                stringBuilder.append(System.lineSeparator());
            }
            
            text = stringBuilder.toString();
            reader.close();
            
            System.out.println("File opened: " + fileName);
        } catch (IOException e) {
            System.out.println("Error opening file: " + fileName);
        }
    }

    public void saveFile(String fileName) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter(fileName));
            writer.write(text);
            writer.close();
            
            System.out.println("File saved: " + fileName);
        } catch (IOException e) {
            System.out.println("Error saving file: " + fileName);
        }
    }

    public void copyText() {
        // 实现文本复制的逻辑
        System.out.println("Text copied.");
    }

    public void pasteText() {
        // 实现文本粘贴的逻辑
        System.out.println("Text pasted.");
    }

    public String getText() {
        return text;
    }

    public void setText(String newText) {
        text = newText;
        System.out.println("Text set.");
    }
}

public class Main {
    public static void main(String[] args) {
        TextEditor editor = new TextEditor();
        
        // 创建新文件
        editor.createNewFile();

        // 写入文本内容
        editor.setText("Hello, world!");

        // 打开文件
        editor.openFile("example.txt");

        // 保存文件
        editor.saveFile("example.txt");

        // 复制粘贴操作
        editor.copyText();
        editor.pasteText();
    }
}

22、解释器模式（Interpreter）：例如，一个简单的正则表达式解释器，可以将正则表达式语言解释成可执行的匹配逻辑。

import java.util.regex.Matcher;
import java.util.regex.Pattern;

// 抽象表达式类
interface Expression {
    boolean interpret(String text);
}

// 具体表达式类：正则表达式
class RegexExpression implements Expression {
    private String pattern;

    public RegexExpression(String pattern) {
        this.pattern = pattern;
    }

    @Override
    public boolean interpret(String text) {
        Pattern regexPattern = Pattern.compile(pattern);
        Matcher matcher = regexPattern.matcher(text);
        return matcher.matches();
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        String pattern = "^\\d{3}-\\d{4}$"; // 匹配形如 xxx-xxxx 的字符串
        String text1 = "123-4567";
        String text2 = "1234-56789";

        Expression expression = new RegexExpression(pattern);

        boolean isMatch1 = expression.interpret(text1);
        System.out.println("Pattern: " + pattern);
        System.out.println("Text: " + text1);
        System.out.println("Match: " + isMatch1);

        boolean isMatch2 = expression.interpret(text2);
        System.out.println("Pattern: " + pattern);
        System.out.println("Text: " + text2);
        System.out.println("Match: " + isMatch2);
    }
}

23、并发模式（Concurrency Patterns）：例如，一个线程池的实现，通过并发模式可以管理多个线程的执行和资源的调度。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class ThreadPoolExample {
    public static void main(String[] args) {
        // 创建线程池
        ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
                2, // 核心线程数
                4, // 最大线程数
                10, // 线程空闲时间
                TimeUnit.SECONDS, // 时间单位
                new ArrayBlockingQueue<>(2) // 任务队列
        );

        // 提交任务给线程池
        for (int i = 1; i <= 6; i++) {
            final int taskId = i;
            threadPool.execute(() -> {
                System.out.println("Task " + taskId + " is executing by " + Thread.currentThread().getName());
                try {
                    Thread.sleep(2000); // 模拟任务执行时间
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Task " + taskId + " is completed by " + Thread.currentThread().getName());
            });
        }

        // 关闭线程池
        threadPool.shutdown();
    }
}

24、互斥锁模式（Mutex）：例如，多个线程共享一个临界资源时，通过互斥锁模式可以确保同一时刻只有一个线程访问该资源。

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class MutexExample {
    private static final int NUM_THREADS = 5;
    private static final int NUM_ITERATIONS = 3;
    private static int sharedResource = 0;
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        // 创建并启动多个线程
        for (int i = 1; i <= NUM_THREADS; i++) {
            Thread thread = new Thread(new WorkerThread(i));
            thread.start();
        }
    }

    static class WorkerThread implements Runnable {
        private int threadId;

        public WorkerThread(int threadId) {
            this.threadId = threadId;
        }

        @Override
        public void run() {
            for (int i = 1; i <= NUM_ITERATIONS; i++) {
                lock.lock(); // 获取锁

                try {
                    // 访问共享资源
                    sharedResource++;
                    System.out.println("Thread " + threadId + " modified shared resource: " + sharedResource);
                } finally {
                    lock.unlock(); // 释放锁
                }

                // 模拟其他操作
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

25、读写锁模式（Read-Write Lock）：例如，一个数据缓存系统，通过读写锁模式可以实现读操作的并发性和写操作的互斥性，提高系统的性能。

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class DataCache {
    private Map<String, String> cache = new HashMap<>();
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    public String get(String key) {
        lock.readLock().lock(); // 获取读锁

        try {
            // 读取缓存
            return cache.get(key);
        } finally {
            lock.readLock().unlock(); // 释放读锁
        }
    }

    public void put(String key, String value) {
        lock.writeLock().lock(); // 获取写锁

        try {
            // 写入缓存
            cache.put(key, value);
        } finally {
            lock.writeLock().unlock(); // 释放写锁
        }
    }

    public static void main(String[] args) {
        DataCache dataCache = new DataCache();

        // 启动多个读线程并发读取缓存
        for (int i = 1; i <= 5; i++) {
            final int threadId = i;
            new Thread(() -> {
                String value = dataCache.get("key");
                System.out.println("Thread " + threadId + " read: " + value);
            }).start();
        }

        // 启动写线程写入缓存
        new Thread(() -> {
            dataCache.put("key", "value");
            System.out.println("Thread write: key=value");
        }).start();
    }
}

26、线程池模式（Thread Pool）：例如，一个Web服务器，通过线程池模式可以复用线程，减少线程创建和销毁的开销。

import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class WebServer {
    private static final int PORT = 8080;
    private static final int THREAD_POOL_SIZE = 10;

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(PORT);
        ExecutorService threadPool = Executors.newFixedThreadPool(THREAD_POOL_SIZE);

        while (true) {
            Socket clientSocket = serverSocket.accept(); // 等待客户端连接

            // 使用线程池处理请求
            threadPool.execute(() -> handleRequest(clientSocket));
        }
    }

    private static void handleRequest(Socket clientSocket) {
        try {
            // 处理请求逻辑
            OutputStream outputStream = clientSocket.getOutputStream();
            String response = "HTTP/1.1 200 OK\r\n"
                    + "Content-Type: text/plain\r\n"
                    + "\r\n"
                    + "Hello, World!\r\n";
            outputStream.write(response.getBytes("UTF-8"));
            outputStream.flush();

            Thread.sleep(1000); // 模拟处理请求所需要的时间

            clientSocket.close(); // 关闭客户端连接
        } catch (IOException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

27、生产者消费者模式（Producer-Consumer）：例如，一个消息队列系统，生产者生成消息并放入队列，消费者从队列中获取消息进行处理，通过生产者消费者模式可以实现异步消息的处理。

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class MessageQueue {
    private static final int QUEUE_CAPACITY = 10;
    private static BlockingQueue<String> queue = new ArrayBlockingQueue<>(QUEUE_CAPACITY);

    public static void main(String[] args) {
        // 创建生产者线程和消费者线程
        Thread producerThread = new Thread(new ProducerThread());
        Thread consumerThread = new Thread(new ConsumerThread());

        // 启动生产者线程和消费者线程
        producerThread.start();
        consumerThread.start();

        // 等待生产者线程和消费者线程执行完毕
        try {
            producerThread.join();
            consumerThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    static class ProducerThread implements Runnable {
        @Override
        public void run() {
            try {
                // 生产消息并放入队列
                for (int i = 1; i <= 10; i++) {
                    String message = "Message " + i;
                    queue.put(message);
                    System.out.println("Produced: " + message);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ConsumerThread implements Runnable {
        @Override
        public void run() {
            try {
                // 从队列中获取消息并处理
                while (true) {
                    String message = queue.take();
                    System.out.println("Consumed: " + message);
                    // 模拟消息处理的耗时
                    Thread.sleep(2000);
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

28、保护性暂停模式（Guarded Suspension）：例如，一个网络请求的处理，当网络连接不可用时，通过保护性暂停模式可以使请求线程等待，直到网络恢复后再继续处理请求。

public class NetworkRequestHandler {
    private boolean networkAvailable = false;

    public synchronized void processRequest() {
        // 检查网络连接是否可用
        while (!networkAvailable) {
            try {
                System.out.println("Network is not available. Waiting...");
                wait(); // 网络不可用，请求线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        // 执行网络请求的逻辑
        System.out.println("Processing network request...");
        // ...
        System.out.println("Network request processed successfully!");
    }

    public synchronized void networkAvailable() {
        networkAvailable = true;
        System.out.println("Network is available now.");
        notifyAll(); // 唤醒所有等待的请求线程
    }

    public static void main(String[] args) throws InterruptedException {
        NetworkRequestHandler requestHandler = new NetworkRequestHandler();

        // 创建并启动多个请求线程
        for (int i = 1; i <= 5; i++) {
            Thread thread = new Thread(() -> requestHandler.processRequest());
            thread.start();
        }

        Thread.sleep(2000); // 模拟网络连接不可用的情况
        requestHandler.networkAvailable(); // 模拟网络恢复，通知请求线程继续处理请求
    }
}

数字世界探索者

关注

4
点赞
踩
6

收藏

觉得还不错? 一键收藏
2
评论
Java中设计模式的28种方式

1、简单工厂模式（Simple Factory）2、工厂方法模式（Factory Method）3、抽象工厂模式（Abstract Factory）4、单例模式（Singleton） (1)懒汉式单例模式 (2)饿汉式单例模式 (3)双重检验锁式单例模式5、建造者模式（Builder）6、原型模式（Prototype）7、适配器模式（Adapter）8、桥接模式（Bridge
复制链接

扫一扫