二十三种设计模式

创建型模式

创建型模式涉及对象的创建过程。它们的目的是封装实例化逻辑，以便在不影响客户端代码的情况下能够灵活地更改创建逻辑。

工厂模式（Factory Pattern）

工厂模式是一种创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们创建对象而不是直接通过 new 关键字来创建对象。这种方式可以帮助我们隐藏创建对象的复杂性，并使代码更易于维护。

// 定义一个 Shape 接口，表示图形
interface Shape {
    void draw();
}

// 定义一个 Circle 类，实现 Shape 接口，表示圆形
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

// 定义一个 Rectangle 类，实现 Shape 接口，表示矩形
class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

// 定义一个 ShapeFactory 类，用于创建 Shape 对象
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 FactoryPatternDemo {
    public static void main(String[] args) {
    	// 创建一个 ShapeFactory 对象
        ShapeFactory shapeFactory = new ShapeFactory(); 
        // 通过 ShapeFactory 对象创建 Circle 对象
        Shape circle = shapeFactory.getShape("CIRCLE"); 
        // 调用 Circle 对象的 draw() 方法
        circle.draw(); 
		 // 通过 ShapeFactory 对象创建 Rectangle 对象
        Shape rectangle = shapeFactory.getShape("RECTANGLE");
        // 调用 Rectangle 对象的 draw() 方法
        rectangle.draw(); 
    }
}

抽象工厂模式（Abstract Factory Pattern）

抽象工厂模式是一种创建型模式，它提供了一种创建一组相关或相互依赖对象的最佳方式。在抽象工厂模式中，我们不仅要创建对象，还要创建对象的工厂。

// 定义一个 Shape 接口，表示图形
interface Shape {
    void draw();
}

// 定义一个 Circle 类，实现 Shape 接口，表示圆形
class Circle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a circle.");
    }
}

// 定义一个 Rectangle 类，实现 Shape 接口，表示矩形
class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("Drawing a rectangle.");
    }
}

// 定义一个 Color 接口，表示颜色
interface Color {
    void fill();
}

// 定义一个 Red 类，实现 Color 接口，表示红色
class Red implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with red color.");
    }
}

// 定义一个 Blue 类，实现 Color 接口，表示蓝色
class Blue implements Color {
    @Override
    public void fill() {
        System.out.println("Filling with blue color.");
    }
}

// 定义一个抽象工厂类 AbstractFactory，用于创建 Shape 和 Color 对象
abstract class AbstractFactory {
 	// 创建 Color 对象的抽象方法
    abstract Color getColor(String color);
	 // 创建 Shape 对象的抽象方法
    abstract Shape getShape(String shape);
}

// 定义一个 ShapeFactory 类，实现 AbstractFactory 接口，用于创建 Shape 对象
class ShapeFactory extends AbstractFactory {
    @Override
    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;
    }

    @Override
    Color getColor(String color) {
        return null;
    }
}

// 定义一个 ColorFactory 类，实现 AbstractFactory 接口，用于创建 Color 对象
class ColorFactory extends AbstractFactory {
    @Override
    public Color getColor(String color) {
        if (color == null) {
            return null;
        }
        if (color.equalsIgnoreCase("RED")) {
            return new Red();
        } else if (color.equalsIgnoreCase("BLUE")) {
            return new Blue();
        }
        return null;
    }

    @Override
    Shape getShape(String shape) {
        return null;
    }
}

// 定义一个 FactoryProducer 类，用于创建 AbstractFactory 对象
class FactoryProducer {
    public static AbstractFactory getFactory(String choice) {
        if (choice.equalsIgnoreCase("SHAPE")) {
            return new ShapeFactory();
        } else if (choice.equalsIgnoreCase("COLOR")) {
            return new ColorFactory();
        }
        return null;
    }
}

public class AbstractFactoryPatternDemo {
    public static void main(String[] args) {
    	// 创建一个 ShapeFactory 对象
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE"); 
		// 通过 ShapeFactory 对象创建 Circle 对象
        Shape circle = shapeFactory.getShape("CIRCLE"); 
        // 调用 Circle 对象的 draw() 方法
        circle.draw(); 
		// 通过 ShapeFactory 对象创建 Rectangle 对象
        Shape rectangle = shapeFactory.getShape("RECTANGLE"); 
        // 调用 Rectangle 对象的 draw() 方法
        rectangle.draw(); 
        // 创建一个 ColorFactory 对象
        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR"); 
		// 通过 ColorFactory 对象创建 Red 对象
        Color red = colorFactory.getColor("RED"); 
        // 调用 Red 对象的 fill() 方法
        red.fill(); 
		// 通过 ColorFactory 对象创建 Blue 对象
        Color blue = colorFactory.getColor("BLUE"); 
        // 调用 Blue 对象的 fill() 方法
        blue.fill(); 
    }
}

单例模式（Singleton Pattern）

单例模式是一种创建型模式，它确保一个类只有一个实例，并提供一个全局访问点。这种方式可以避免多个对象对同一资源的竞争，并且可以使代码更易于维护。

// 定义一个 Singleton 类，用于创建单例对象
class Singleton {
    private static Singleton instance = null; // 定义一个静态变量 instance，用于存储唯一的 Singleton 对象

    private Singleton() { // 将构造方法设为私有，禁止外部创建 Singleton 对象
    }

    public static Singleton getInstance() { // 定义一个静态方法 getInstance，用于获取 Singleton 对象
        if (instance == null) { // 如果 instance 为 null，则创建一个新的 Singleton 对象
            instance = new Singleton();
        }
        return instance; // 返回 Singleton 对象
    }
}

public class SingletonPatternDemo {
    public static void main(String[] args) {
   		// 获取 Singleton 对象
        Singleton singleton = Singleton.getInstance(); 
        // 再次获取 Singleton 对象
        Singleton anotherSingleton = Singleton.getInstance(); 
		// 输出 true，说明两个对象是同一个对象
        System.out.println(singleton == anotherSingleton); 
    }
}

建造者模式（Builder Pattern）

建造者模式是一种创建型模式，它允许我们使用相同的创建过程来构建不同的对象。这种方式可以避免创建过多的构造函数，并且可以使代码更易于维护。

// 定义一个 Meal 类，表示一份餐
class Meal {
	// 定义一个 List，用于存储餐的所有条目
    private List<Item> items = new ArrayList<>(); 
	// 定义一个 addItem() 方法，用于向餐中添加条目
    public void addItem(Item item) { 
        items.add(item);
    }
	// 定义一个 getCost() 方法，用于计算餐的总价
    public float getCost() { 
        float cost = 0.0f;
        for (Item item : items) {
            cost += item.price();
        }
        return cost;
    }
	// 定义一个 showItems() 方法，用于显示餐的所有条目
    public void showItems() { 
        for (Item item : items) {
            System.out.print("Item : " + item.name());
            System.out.print(", Packing : " + item.packing().pack());
            System.out.println(", Price : " + item.price());
        }
    }
}

// 定义一个 Item 接口，表示餐的一项条目
interface Item {
    String name();

    Packing packing();

    float price();
}

// 定义一个 Packing 接口，表示餐的包装
interface Packing {
    String pack();
}

// 定义一个 Wrapper 类，实现 Packing 接口，表示餐的包装为包装纸
class Wrapper implements Packing {
    @Override
    public String pack() {
        return "Wrapper";
    }
}

// 定义一个 Bottle 类，实现 Packing 接口，表示餐的包装为瓶子
class Bottle implements Packing {
    @Override
    public String pack() {
        return "Bottle";
    }
}

// 定义一个 Burger 抽象类，实现 Item 接口，表示汉堡
abstract class Burger implements Item {
@Override
public Packing packing() {
 // 汉堡的包装为包装纸
return new Wrapper();
}

// 汉堡的价格由具体的类实现
@Override
public abstract float price(); 
}

// 定义一个 ColdDrink 抽象类，实现 Item 接口，表示冷饮
abstract class ColdDrink implements Item {
@Override
public Packing packing() {
// 冷饮的包装为瓶子
return new Bottle(); 
}
// 冷饮的价格由具体的类实现
@Override
public abstract float price(); 
}

// 定义一个 VegBurger 类，继承 Burger 类，表示素汉堡
class VegBurger extends Burger {
@Override
public float price() {
return 25.0f;
}

@Override
public String name() {
    return "Veg Burger";
}
}

// 定义一个 ChickenBurger 类，继承 Burger 类，表示鸡肉汉堡
class ChickenBurger extends Burger {
@Override
public float price() {
return 50.5f;
}

@Override
public String name() {
    return "Chicken Burger";
}
}

// 定义一个 Coke 类，继承 ColdDrink 类，表示可乐
class Coke extends ColdDrink {
@Override
public float price() {
return 30.0f;
}

@Override
public String name() {
    return "Coke";
}
}

// 定义一个 Pepsi 类，继承 ColdDrink 类，表示百事可乐
class Pepsi extends ColdDrink {
@Override
public float price() {
return 35.0f;
}

@Override
public String name() {
    return "Pepsi";
}
}

// 定义一个 MealBuilder 类，用于创建餐
class MealBuilder {
// 定义一个 prepareVegMeal() 方法，用于创建素食餐
public Meal prepareVegMeal() { 
Meal meal = new Meal();
meal.addItem(new VegBurger());
meal.addItem(new Coke());
return meal;
}
// 定义一个 prepareNonVegMeal() 方法，用于创建非素食餐
public Meal prepareNonVegMeal() { 
    Meal meal = new Meal();
    meal.addItem(new ChickenBurger());
    meal.addItem(new Pepsi());
    return meal;
}
}

public class BuilderPatternDemo {
public static void main(String[] args) {
// 创建一个 MealBuilder 对象
MealBuilder mealBuilder = new MealBuilder(); 
	// 通过 MealBuilder 对象创建素食餐
    Meal vegMeal = mealBuilder.prepareVegMeal(); 
    System.out.println("Veg Meal");
    // 显示素食餐的所有条目
    vegMeal.showItems(); 
    // 显示素食餐的总价
    System.out.println("Total Cost: " + vegMeal.getCost()); 
	// 通过 MealBuilder 对象创建非素食
    Meal nonVegMeal = mealBuilder.prepareNonVegMeal(); 餐
    System.out.println("\nNon-Veg Meal");
    // 显示非素食餐的所有条目
    nonVegMeal.showItems(); 
    // 显示非素食餐的总价
    System.out.println("Total Cost: " + nonVegMeal.getCost()); 
	}
}

原型模式（Prototype Pattern）

原型模式是一种创建型模式，它通过复制现有的对象来创建新的对象。这种方式可以避免创建过多的子类，并且可以使代码更易于维护。

// 定义一个 Shape 接口，表示图形
interface Shape extends Cloneable {
    void draw();
    Object clone();
}

// 定义一个 Circle 类，实现 Shape 接口，表示圆形
class Circle implements Shape {
    private String id; // 定义一个字符串类型的 id，用于标识圆形
    private int x; // 定义一个整型的 x，表示圆形的 x 坐标
    private int y; // 定义一个整型的 y，表示圆形的 y 坐标
    private int radius; // 定义一个整型的 radius，表示圆形的半径
	// 定义一个无参构造方法，用于创建一个空的 Circle 对象
    public Circle() { 
    }
	 // 定义一个带参构造方法，用于创建一个带有指定参数的 Circle 对象
    public Circle(String id, int x, int y, int radius) {
        this.id = id;
        this.x = x;
        this.y = y;
        this.radius = radius;
    }
	 // 实现 Shape 接口中的 draw() 方法
    @Override
    public void draw() {
        System.out.println("Drawing a circle with id: " + id + ", x: " + x + ", y: " + y + ", radius: " + radius);
    }
	 // 实现 Shape 接口中的 clone() 方法
    @Override
    public Object clone() {
        Object clone = null;
        try {
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return clone;
    }
	// 定义一个 getId() 方法，用于获取圆形的 id
    public String getId() { 
        return id;
    }
	// 定义一个 setId() 方法，用于设置圆形的 id
    public void setId(String id) { 
        this.id = id;
    }
}

// 定义一个 ShapeCache 类，用于缓存 Shape 对象
class ShapeCache {
	 // 定义一个静态变量 shapeMap，用于存储 Shape 对象
    private static Map<String, Shape> shapeMap = new HashMap<>();
	// 定义一个 getShape() 方法，用于获取 Shape 对象
    public static Shape getShape(String shapeId) { 
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape) cachedShape.clone();
    }
	// 定义一个 loadCache() 方法，用于加载 Shape 对象
    public static void loadCache() { 
        Circle circle = new Circle();
        circle.setId("1");
        shapeMap.put(circle.getId(), circle);
        Circle anotherCircle = new Circle();
        anotherCircle.setId("2");
        shapeMap.put(anotherCircle.getId(), anotherCircle);
    }
}

public class PrototypePatternDemo {
    public static void main(String[] args) {
        ShapeCache.loadCache(); // 加载 Shape 对象
		// 通过 ShapeCache 对象获取 Circle 对象
        Shape clonedShape = ShapeCache.getShape("1"); 
        // 输出 Circle 对象的 id
        System.out.println("Shape : " + clonedShape.getId()); 
		// 通过 ShapeCache 对象获取另一个 Circle 对象
        Shape clonedShape2 = ShapeCache.getShape("2"); 
        // 输出另一个 Circle 对象的 id
        System.out.println("Shape : " + clonedShape2.getId()); 
    }
}

结构型模式

结构型模式涉及类和对象的组合。它们旨在建立对象间的关系，以便它们可以协同工作。

适配器模式（Adapter Pattern）

适配器模式是一种结构型模式，它允许我们将一个类的接口转换成客户希望的另一个接口。这种方式可以使原本不兼容的类能够一起工作，并且可以使代码更易于维护。

// 定义一个 MediaPlayer 接口，表示媒体播放器
interface MediaPlayer {
    void play(String audioType, String fileName);
}

// 定义一个 AdvancedMediaPlayer 接口，表示高级媒体播放器
interface AdvancedMediaPlayer {
    void playVlc(String fileName);

    void playMp4(String fileName);
}

// 定义一个 VlcPlayer 类，实现 AdvancedMediaPlayer 接口，表示 Vlc 播放器
class VlcPlayer implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: " + fileName);
    }

    @Override
    public void playMp4(String fileName) {
        // 什么也不做
    }
}

// 定义一个 Mp4Player 类，实现 AdvancedMediaPlayer 接口，表示 Mp4 播放器
class Mp4Player implements AdvancedMediaPlayer {
    @Override
    public void playVlc(String fileName) {
        // 什么也不做
    }

    @Override
    public void playMp4(String fileName) {
        System.out.println("Playing mp4 file. Name: " + fileName);
    }
}

// 定义一个 MediaAdapter 类，实现 MediaPlayer 接口，用于将 AdvancedMediaPlayer 接口转换成 MediaPlayer 接口
class MediaAdapter implements MediaPlayer {
    AdvancedMediaPlayer advancedMusicPlayer;

    public MediaAdapter(String audioType) {
        if (audioType.equalsIgnoreCase("vlc")) {
            advancedMusicPlayer = new VlcPlayer();
        } else if (audioType.equalsIgnoreCase("mp4")) {
            advancedMusicPlayer = new Mp4Player();
        }
    }

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

// 定义一个 AudioPlayer 类，实现 MediaPlayer 接口，表示音频播放器
class AudioPlayer implements MediaPlayer {
    MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        if (audioType.equalsIgnoreCase("mp3")) {
            System.out.println("Playing mp3 file. Name: " + fileName);
        } else if (audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")) {
            mediaAdapter = new MediaAdapter(audioType);
            mediaAdapter.play(audioType, fileName);
        } else {
            System.out.println("Invalid media. " + audioType + " format not supported");
        }
    }
}

public class AdapterPatternDemo {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer(); // 创建一个 AudioPlayer 对象

        audioPlayer.play("mp3", "beyond the horizon.mp3"); // 播放 mp3 文件
        audioPlayer.play("mp4", "alone.mp4"); // 播放 mp4 文件
        audioPlayer.play("vlc", "far far away.vlc"); // 播放 vlc 文件
        audioPlayer.play("avi", "mind me.avi"); // 输出 Invalid media. avi format not supported
    }
}

桥接模式（Bridge Pattern）

桥接模式是一种结构型模式，它将抽象部分与它的实现部分分离，以便它们可以独立地变化。这种方式可以使代码更易于维护，并且可以使系统更加灵活。

// 定义一个 DrawAPI 接口，表示绘图接口
interface DrawAPI {
    void drawCircle(int radius, int x, int y);
}

// 定义一个 RedCircle 类，实现 DrawAPI 接口，表示红色圆形
class RedCircle implements DrawAPI {
    @Override
    public void drawCircle(int radius, int x, int y) {
        System.out.println("Drawing Circle[ color: red, radius: " + radius + ", x: " + x + ", y: " + y + "]");
    }
}

// 定义一个 GreenCircle 类，实现 DrawAPI 接口，表示绿色圆形
class GreenCircle implements DrawAPI {
    @Override
    public void drawCircle(int radius, int x, int y) {
        System.out.println("Drawing Circle[ color: green, radius: " + radius + ", x: " + x + ", y: " + y + "]");
    }
}

// 定义一个 Shape 抽象类，表示图形
abstract class Shape {
    protected DrawAPI drawAPI;

    protected Shape(DrawAPI drawAPI) { // 定义一个带参构造方法，用于创建 Shape 对象
        this.drawAPI = drawAPI;
    }

    public abstract void draw(); // 定义一个抽象方法 draw()
}

// 定义一个 Circle 类，继承 Shape 抽象类，表示圆形
class Circle extends Shape {
    private int x;
    private int y;
    private int radius;

    public Circle(int x, int y, int radius, DrawAPI drawAPI) { // 定义一个带参构造方法，用于创建 Circle 对象
        super(drawAPI);
        this.x = x;
        this.y = y;
        this.radius = radius;
    }

    @Override
    public void draw() { // 实现 Shape 抽象类中的 draw() 方法
        drawAPI.drawCircle(radius, x, y);
    }
}

public class BridgePatternDemo {
    public static void main(String[] args) {
        Shape redCircle = new Circle(100, 100, 10, new RedCircle()); // 创建一个 RedCircle 对象
        Shape greenCircle = new Circle(100, 100, 10, new GreenCircle()); // 创建一个 GreenCircle 对象

        redCircle.draw(); // 调用 RedCircle 对象的 draw() 方法
        greenCircle.draw(); // 调用 GreenCircle 对象的 draw() 方法
    }
}

过滤器模式（Filter Pattern）

过滤器模式是一种结构型模式，它允许我们使用不同的标准来过滤一组对象。这种方式可以使代码更易于维护，并且可以使系统更加灵活。

// 定义一个 Person 类，表示人
class Person {
    private String name; // 定义一个字符串类型的 name，表示人的姓名
    private String gender; // 定义一个字符串类型的 gender，表示人的性别
    private String maritalStatus; // 定义一个字符串类型的 maritalStatus，表示人的婚姻状况

    public Person(String name, String gender, String maritalStatus) { // 定义一个带参构造方法，用于创建 Person 对象
        this.name = name;
        this.gender = gender;
        this.maritalStatus = maritalStatus;
    }

    public String getName() { // 定义一个 getName() 方法，用于获取人的姓名
        return name;
    }

    public String getGender() { // 定义一个 getGender() 方法，用于获取人的性别
        return gender;
    }

    public String getMaritalStatus() { // 定义一个 getMaritalStatus() 方法，用于获取人的婚姻状况
        return maritalStatus;
    }
}

// 定义一个 Criteria 接口，表示过滤器接口
interface Criteria {
    List<Person> meetCriteria(List<Person> persons);
}

// 定义一个 CriteriaMale 类，实现 Criteria 接口，表示男性过滤器
class CriteriaMale implements Criteria {
    @Override
    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> malePersons = new ArrayList<>();
        for (Person person : persons) {
            if (person.getGender().equalsIgnoreCase("MALE")) {
                malePersons.add(person);
            }
        }
        return malePersons;
    }
}

// 定义一个 CriteriaFemale 类，实现 Criteria 接口，表示女性过滤器
class CriteriaFemale implements Criteria {
    @Override
    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> femalePersons = new ArrayList<>();
        for (Person person : persons) {
            if (person.getGender().equalsIgnoreCase("FEMALE")) {
                femalePersons.add(person);
            }
        }
        return femalePersons;
    }
}

// 定义一个 CriteriaSingle 类，实现 Criteria 接口，表示单身过滤器
class CriteriaSingle implements Criteria {
    @Override
    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> singlePersons = new ArrayList<>();
        for (Person person : persons) {
            if (person.getMaritalStatus().equalsIgnoreCase("SINGLE")) {
                singlePersons.add(person);
            }
        }
        return singlePersons;
    }
}

// 定义一个 AndCriteria 类，实现 Criteria 接口，表示 And 过滤器
class AndCriteria implements Criteria {
    private Criteria criteria;
    private Criteria otherCriteria;

    public AndCriteria(Criteria criteria, Criteria otherCriteria) { // 定义一个带参构造方法，用于创建 AndCriteria 对象
        this.criteria = criteria;
        this.otherCriteria = otherCriteria;
    }

    @Override
    public List<Person> meetCriteria(List<Person> persons) { // 实现 Criteria 接口中的 meetCriteria() 方法
        List<Person> firstCriteriaPersons = criteria.meetCriteria(persons);
        return otherCriteria.meetCriteria(firstCriteriaPersons);
    }
}

// 定义一个 OrCriteria 类，实现 Criteria 接口，表示 Or 过滤器
class OrCriteria implements Criteria {
    private Criteria criteria;
    private Criteria otherCriteria;

    public OrCriteria(Criteria criteria, Criteria otherCriteria) { // 定义一个带参构造方法，用于创建 OrCriteria 对象
        this.criteria = criteria;
        this.otherCriteria = otherCriteria;
    }

    @Override
    public List<Person> meetCriteria(List<Person> persons) { // 实现 Criteria 接口中的 meetCriteria() 方法
        List<Person> firstCriteriaItems = criteria.meetCriteria(persons);
        List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons);

        for (Person person : otherCriteriaItems) {
            if (!firstCriteriaItems.contains(person)) {
                firstCriteriaItems.add(person);
            }
        }
        return firstCriteriaItems;
    }
}

public class FilterPatternDemo {
    public static void main(String[] args) {
        List<Person> persons = new ArrayList<>(); // 创建一个 List，用于存储 Person 对象

        persons.add(new Person("Robert", "Male", "Single"));
        persons.add(new Person("John", "Male", "Married"));
        persons.add(new Person("Laura", "Female", "Married"));
        persons.add(new Person("Diana", "Female", "Single"));
        persons.add(new Person("Mike", "Male", "Single"));
        persons.add(new Person("Bobby", "Male", "Single"));

        Criteria male = new CriteriaMale(); // 创建一个 CriteriaMale 对象
        Criteria female = new CriteriaFemale(); // 创建一个 CriteriaFemale 对象
        Criteria single = new CriteriaSingle(); // 创建一个 CriteriaSingle 对象
        Criteria singleMale = new AndCriteria(single, male); // 创建一个 AndCriteria 对象，表示单身男性过滤器
        Criteria singleOrFemale = new OrCriteria(single, female); // 创建一个 OrCriteria 对象，表示单身或女性过滤器

        System.out.println("Males:"); // 输出 Males:
        printPersons(male.meetCriteria(persons)); // 调用 male.meetCriteria() 方法，输出男性过滤器的结果

        System.out.println("\nFemales:"); // 输出 Females:
        printPersons(female.meetCriteria(persons)); // 调用 female.meetCriteria() 方法，输出女性过滤器的结果

        System.out.println("\nSingle Males:"); // 输出 Single Males:
        printPersons(singleMale.meetCriteria(persons)); // 调用 singleMale.meetCriteria() 方法，输出单身男性过滤器的结果

        System.out.println("\nSingle Or Females:"); // 输出 Single Or Females:
        printPersons(singleOrFemale.meetCriteria(persons)); // 调用 singleOrFemale.meetCriteria() 方法，输出单身或女性过滤器的结果
    }

    public static void printPersons(List<Person> persons) { // 定义一个 printPersons() 方法，用于输出 Person 对象的信息
        for (Person person : persons) {
            System.out.println("Person : [ Name : " + person.getName() + ", Gender : " + person.getGender()
                    + ", Marital Status : " + person.getMaritalStatus() + " ]");
        }
    }
}

组合模式（Composite Pattern）

组合模式是一种结构型模式，它将对象组合成树形结构以表示“部分-整体”的层次结构。这种方式可以使代码更易于维护，并且可以使系统更加灵活。

// 定义一个 Employee 类，表示员工
class Employee {
    private String name; // 定义一个字符串类型的 name，表示员工的姓名
    private String dept; // 定义一个字符串类型的 dept，表示员工的部门
    private int salary; // 定义一个整型的 salary，表示员工的薪水
    private List<Employee> subordinates; // 定义一个 List，用于存储下属员工

    public Employee(String name, String dept, int salary) { // 定义一个带参构造方法，用于创建 Employee 对象
        this.name = name;
        this.dept = dept;
        this.salary = salary;
        subordinates = new ArrayList<>();
    }

    public void add(Employee e) { // 定义一个 add() 方法，用于添加下属员工
        subordinates.add(e);
    }

    public void remove(Employee e) { // 定义一个 remove() 方法，用于移除下属员工
        subordinates.remove(e);
    }

    public List<Employee> getSubordinates() { // 定义一个 getSubordinates() 方法，用于获取下属员工
        return subordinates;
    }

    @Override
    public String toString() { // 重写 toString() 方法，用于输出员工的信息
        return ("Employee :[ Name : " + name + ", dept : " + dept + ", salary :" + salary + " ]");
    }
}

public class CompositePatternDemo {
    public static void main(String[] args) {
        Employee CEO = new Employee("John", "CEO", 30000); // 创建一个 CEO 对象

        Employee headSales = new Employee("Robert", "Head Sales", 20000); // 创建一个 Head Sales 对象

        Employee headMarketing = new Employee("Michel", "Head Marketing", 20000); // 创建一个 Head Marketing 对象

        Employee clerk1 = new Employee("Laura", "Marketing", 10000); // 创建一个 Marketing Clerk1 对象
        Employee clerk2 = new Employee("Bob", "Marketing", 10000); // 创建一个 Marketing Clerk2 对象

        Employee salesExecutive1 = new Employee("Richard", "Sales", 10000); // 创建一个 Sales Executive1 对象
        Employee salesExecutive2 = new Employee("Rob", "Sales", 10000); // 创建一个 Sales Executive2 对象

        CEO.add(headSales); // 将 Head Sales 对象添加到 CEO 对象中
        CEO.add(headMarketing); // 将 Head Marketing 对象添加到 CEO 对象中

        headSales.add(salesExecutive1); // 将 Sales Executive1 对象添加到 Head Sales 对象中
        headSales.add(salesExecutive2); // 将 Sales Executive2 对象添加到 Head Sales 对象中

        headMarketing.add(clerk1); // 将 Marketing Clerk1 对象添加到 Head Marketing 对象中
        headMarketing.add(clerk2); // 将 Marketing Clerk2 对象添加到 Head Marketing 对象中
        System.out.println(CEO); // 输出 CEO 对象的信息
        for (Employee headEmployee : CEO.getSubordinates()) { // 遍历 CEO 对象的下属员工
            System.out.println(headEmployee); // 输出下属员工的信息
            for (Employee employee : headEmployee.getSubordinates()) { // 遍历下属员工的下属员工
                System.out.println(employee); // 输出下属员工的下属员工的信息
            }
        }
    }
}

装饰器模式（Decorator Pattern）

装饰器模式是一种结构型模式，它允许我们动态地给一个对象添加一些额外的职责。这种方式可以避免创建过多的子类，并且可以使代码更易于维护。

// 定义一个 Shape 接口，表示图形
interface Shape {
    void draw();
}

// 定义一个 Circle 类，实现 Shape 接口，表示圆形
class Circle implements Shape {
@Override
public void draw() { // 实现 Shape 接口中的 draw() 方法
System.out.println("Shape: Circle");
	}
}

// 定义一个 Rectangle 类，实现 Shape 接口，表示矩形
class Rectangle implements Shape {
@Override
public void draw() { // 实现 Shape 接口中的 draw() 方法
System.out.println("Shape: Rectangle");
	}
}

// 定义一个 ShapeDecorator 抽象类，实现 Shape 接口，表示图形装饰器
abstract class ShapeDecorator implements Shape {
protected Shape decoratedShape; // 定义一个 Shape 类型的 decoratedShape，表示被装饰的图形

public ShapeDecorator(Shape decoratedShape) { // 定义一个带参构造方法，用于创建 ShapeDecorator 对象
    this.decoratedShape = decoratedShape;
	}

public void draw() { // 实现 Shape 接口中的 draw() 方法
    decoratedShape.draw();
	}
}

// 定义一个 RedShapeDecorator 类，继承 ShapeDecorator 抽象类，表示红色图形装饰器
class RedShapeDecorator extends ShapeDecorator {
public RedShapeDecorator(Shape decoratedShape) { // 定义一个带参构造方法，用于创建 RedShapeDecorator 对象
super(decoratedShape);
	}

@Override
public void draw() { // 实现 ShapeDecorator 抽象类中的 draw() 方法
    decoratedShape.draw();
    setRedBorder(decoratedShape);
	}

private void setRedBorder(Shape decoratedShape) { // 定义一个 setRedBorder() 方法，用于设置红色边框
    System.out.println("Border Color: Red");
	}
}

public class DecoratorPatternDemo {
public static void main(String[] args) {
Shape circle = new Circle(); // 创建一个 Circle 对象

    Shape redCircle = new RedShapeDecorator(new Circle()); // 创建一个 RedShapeDecorator 对象，用于装饰 Circle 对象
    Shape redRectangle = new RedShapeDecorator(new Rectangle()); // 创建一个 RedShapeDecorator 对象，用于装饰 Rectangle 对象

    System.out.println("Circle with normal border"); // 输出 Circle with normal border
    circle.draw(); // 调用 Circle 对象的 draw() 方法

    System.out.println("\nCircle of red border"); // 输出 Circle of red border
    redCircle.draw(); // 调用 RedShapeDecorator 对象的 draw() 方法

    System.out.println("\nRectangle of red border"); // 输出 Rectangle of red border
    redRectangle.draw(); // 调用 RedShapeDecorator 对象的 draw() 方法
	}
}

外观模式（Facade Pattern）

外观模式是一种结构型模式，它为子系统中的一组接口提供一个统一的接口。这种方式可以使代码更易于使用，并且可以使系统更加灵活。

// 定义一个 Shape 接口，表示图形
interface Shape {
    void draw();
}

// 定义一个 Rectangle 类，实现 Shape 接口，表示矩形
class Rectangle implements Shape {
    @Override
    public void draw() { // 实现 Shape 接口中的 draw() 方法
        System.out.println("Rectangle::draw()");
    }
}

// 定义一个 Square 类，实现 Shape 接口，表示正方形
class Square implements Shape {
    @Override
    public void draw() { // 实现 Shape 接口中的 draw() 方法
        System.out.println("Square::draw()");
    }
}

// 定义一个 Circle 类，实现 Shape 接口，表示圆形
class Circle implements Shape {
    @Override
    public void draw() { // 实现 Shape 接口中的 draw() 方法
        System.out.println("Circle::draw()");
    }
}

// 定义一个 ShapeMaker 类，用于创建图形
class ShapeMaker {
    private Shape circle; // 定义一个 Shape 类型的 circle，表示圆形
    private Shape rectangle; // 定义一个 Shape 类型的 rectangle，表示矩形
    private Shape square; // 定义一个 Shape 类型的 square，表示正方形

    public ShapeMaker() { // 定义一个无参构造方法，用于创建 ShapeMaker 对象
        circle = new Circle();
        rectangle = new Rectangle();
        square = new Square();
    }

    public void drawCircle() { // 定义一个 drawCircle() 方法，用于绘制圆形
        circle.draw();
    }

    public void drawRectangle() { // 定义一个 drawRectangle() 方法，用于绘制矩形
        rectangle.draw();
    }

    public void drawSquare() { // 定义一个 drawSquare() 方法，用于绘制正方形
        square.draw();
    }
}

public class FacadePatternDemo {
    public static void main(String[] args) {
        ShapeMaker shapeMaker = new ShapeMaker(); // 创建一个 ShapeMaker 对象

        shapeMaker.drawCircle(); // 调用 drawCircle() 方法，绘制圆形
        shapeMaker.drawRectangle(); // 调用 drawRectangle() 方法，绘制矩形
        shapeMaker.drawSquare(); // 调用 drawSquare() 方法，绘制正方形
    }
}

享元模式（Flyweight Pattern）

享元模式是一种结构型模式，它通过共享已经存在的对象来减少创建对象的数量。这种方式可以减少内存的占用，并且可以使代码更易于维护。

// 定义一个 Shape 接口，表示图形
interface Shape {
    void draw();
}

// 定义一个 Circle 类，实现 Shape 接口，表示圆形
class Circle implements Shape {
    private String color; // 定义一个字符串类型的 color，表示圆形的颜色
    private int x; // 定义一个整型的 x，表示圆形的 x 坐标
    private int y; // 定义一个整型的 y，表示圆形的 y 坐标
    private int radius; // 定义一个整型的 radius，表示圆形的半径

    public Circle(String color) { // 定义一个带参构造方法，用于创建 Circle 对象
        this.color = color;
    }

    public void setX(int x) { // 定义一个 setX() 方法，用于设置圆形的 x 坐标
        this.x = x;
    }

    public void setY(int y) { // 定义一个 setY() 方法，用于设置圆形的 y 坐标
        this.y = y;
    }

    public void setRadius(int radius) { // 定义一个 setRadius() 方法，用于设置圆形的半径
        this.radius = radius;
    }

    @Override
    public void draw() { // 实现 Shape 接口中的 draw() 方法
        System.out.println("Circle: Draw() [Color : " + color + ", x : " + x + ", y :" + y + ", radius :" + radius + "]");
    }
}

// 定义一个 ShapeFactory 类，用于创建 Shape 对象
class ShapeFactory {
    private static final Map<String, Shape> circleMap = new HashMap<>(); // 定义一个静态变量 circleMap，用于存储 Circle 对象

    public static Shape getCircle(String color) { // 定义一个 getCircle() 方法，用于获取 Circle 对象
        Circle circle = (Circle) circleMap.get(color);

        if (circle == null) {
            circle = new Circle(color);
            circleMap.put(color, circle);
            System.out.println("Creating circle of color : " + color);
        }
        return circle;
    }
}

public class FlyweightPatternDemo {
    private static final String colors[] = { "Red", "Green", "Blue", "White", "Black" }; // 定义一个字符串数组 colors，表示圆形的颜色

    public static void main(String[] args) {
        for (int i = 0; i < 20; ++i) { // 循环 20 次
            Circle circle = (Circle) ShapeFactory.getCircle(getRandomColor()); // 通过 ShapeFactory 对象获取 Circle 对象
            circle.setX(getRandomX()); // 设置圆形的 x 坐标
            circle.setY(getRandomY()); // 设置圆形的 y 坐标
            circle.setRadius(100); // 设置圆形的半径
            circle.draw(); // 调用 Circle 对象的 draw() 方法
        }
    }

    private static String getRandomColor() { // 定义一个 getRandomColor() 方法，用于获取随机颜色
        return colors[(int) (Math.random() * colors.length)];
    }

    private static int getRandomX() { // 定义一个 getRandomX() 方法，用于获取随机 x 坐标
        return (int) (Math.random() * 100);
    }

    private static int getRandomY() { // 定义一个 getRandomY() 方法，用于获取随机 y 坐标
        return (int) (Math.random() * 100);
    }
}

代理模式（Proxy Pattern）

代理模式是一种结构型模式，它为其他对象提供一种代理以控制对这个对象的访问。这种方式可以增加访问的控制，可以实现远程访问，可以实现延迟加载等功能。

// 定义一个 Image 接口，表示图片
interface Image {
    void display();
}

// 定义一个 RealImage 类，实现 Image 接口，表示真实的图片
class RealImage implements Image {
    private String fileName; // 定义一个字符串类型的 fileName，表示图片的文件名

    public RealImage(String fileName) { // 定义一个带参构造方法，用于创建 RealImage 对象
        this.fileName = fileName;
        loadFromDisk(fileName); // 调用 loadFromDisk() 方法，从磁盘中加载图片
    }

    @Override
    public void display() { // 实现 Image 接口中的 display() 方法
        System.out.println("Displaying " + fileName);
    }

    private void loadFromDisk(String fileName) { // 定义一个 loadFromDisk() 方法，用于从磁盘中加载图片
        System.out.println("Loading " + fileName);
    }
}

// 定义一个 ProxyImage 类，实现 Image 接口，表示代理图片
class ProxyImage implements Image {
    private RealImage realImage; // 定义一个 RealImage 类型的 realImage，表示真实的图片
    private String fileName; // 定义一个字符串类型的 fileName，表示图片的文件名

    public ProxyImage(String fileName) { // 定义一个带参构造方法，用于创建 ProxyImage 对象
        this.fileName = fileName;
    }

    @Override
    public void display() { // 实现 Image 接口中的 display() 方法
        if (realImage == null) { // 如果 realImage 为空
            realImage = new RealImage(fileName); // 创建一个 RealImage 对象
        }
        realImage.display(); // 调用 RealImage 对象的 display() 方法
    }
}

public class ProxyPatternDemo {
    public static void main(String[] args) {
        Image image = new ProxyImage("test.jpg"); // 创建一个 ProxyImage 对象

        image.display(); // 调用 ProxyImage 对象的 display() 方法
        System.out.println("");

        image.display(); // 再次调用 ProxyImage 对象的 display() 方法
    }
}

行为型模式

行为型模式涉及对象之间的通信。它们专注于对象之间的算法分配和对象状态的管理。

职责链模式（Chain of Responsibility Pattern）

职责链模式是一种行为型模式，它为多个对象提供一种避免耦合的方式，将请求的发送者和接收者解耦。这种方式可以使代码更加灵活，并且可以使系统更加易于维护。

// 定义一个 AbstractLogger 抽象类，表示日志记录器
abstract class AbstractLogger {
    public static int INFO = 1; // 定义一个静态变量 INFO，表示信息级别
    public static int DEBUG = 2; // 定义一个静态变量 DEBUG，表示调试级别
    public static int ERROR = 3; // 定义一个静态变量 ERROR，表示错误级别

    protected int level; // 定义一个整型的 level，表示日志级别
    protected AbstractLogger nextLogger; // 定义一个 AbstractLogger 类型的 nextLogger，表示下一个日志记录器

    public void setNextLogger(AbstractLogger nextLogger) { // 定义一个 setNextLogger() 方法，用于设置下一个日志记录器
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message) { // 定义一个 logMessage() 方法，用于记录日志
        if (this.level <= level) { // 如果当前的日志级别小于等于指定的日志级别
            write(message); // 调用 write() 方法，输出日志信息
        }
        if (nextLogger != null) { // 如果下一个日志记录器不为空
            nextLogger.logMessage(level, message); // 调用下一个日志记录器的 logMessage() 方法
        }
    }

    abstract protected void write(String message); // 定义一个抽象方法 write()，用于输出日志信息
}

// 定义一个 ConsoleLogger 类，继承 AbstractLogger 抽象类，表示控制台日志记录器
class ConsoleLogger extends AbstractLogger {
    public ConsoleLogger(int level) { // 定义一个带参构造方法，用于创建 ConsoleLogger 对象
        this.level = level;
    }

    @Override
    protected void write(String message) { // 实现 AbstractLogger 抽象类中的 write() 方法
        System.out.println("Standard Console::Logger: " + message);
    }
}

// 定义一个 ErrorLogger 类，继承 AbstractLogger 抽象类，表示错误日志记录器
class ErrorLogger extends AbstractLogger {
    public ErrorLogger(int level) { // 定义一个带参构造方法，用于创建 ErrorLogger 对象
        this.level = level;
    }

    @Override
    protected void write(String message) { // 实现 AbstractLogger 抽象类中的 write() 方法
        System.out.println("Error Console::Logger: " + message);
    }
}

// 定义一个 FileLogger 类，继承 AbstractLogger 抽象类，表示文件日志记录器
class FileLogger extends AbstractLogger {
    public FileLogger(int level) { // 定义一个带参构造方法，用于创建 FileLogger 对象
        this.level = level;
    }

    @Override
    protected void write(String message) { // 实现 AbstractLogger 抽象类中的 write() 方法
        System.out.println("File::Logger: " + message);
    }
}

public class ChainOfResponsibilityPatternDemo {
    private static AbstractLogger getChainOfLoggers() { // 定义一个 getChainOfLoggers() 方法，用于获取日志记录器链
        AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR); // 创建一个 ErrorLogger 对象
        AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG); // 创建一个 FileLogger 对象
        AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO); // 创建一个 ConsoleLogger 对象

        errorLogger.setNextLogger(fileLogger); // 设置下一个日志记录器为 FileLogger 对象
        fileLogger.setNextLogger(consoleLogger); // 设置下一个日志记录器为 ConsoleLogger 对象

        return errorLogger; // 返回 ErrorLogger 对象
    }

    public static void main(String[] args) {
        AbstractLogger loggerChain = getChainOfLoggers(); // 获取日志记录器链

        loggerChain.logMessage(AbstractLogger.INFO, "This is an information."); // 记录信息级别的日志
        loggerChain.logMessage(AbstractLogger.DEBUG, "This is a debug level information."); // 记录调试级别的日志
        loggerChain.logMessage(AbstractLogger.ERROR, "This is an error information."); // 记录错误级别的日志
    }
}

命令模式（Command Pattern）

命令模式是一种行为型模式，它将请求封装成对象，从而使得请求可以被不同的请求者进行参数化，可以对请求进行排队或记录请求日志，可以支持可撤销的操作等功能。

// 定义一个 Order 接口，表示订单
interface Order {
    void execute();
}

// 定义一个 Stock 类，表示库存
class Stock {
    private String name = "ABC"; // 定义一个字符串类型的 name，表示库存名称
    private int quantity = 10; // 定义一个整型的 quantity，表示库存数量

    public void buy() { // 定义一个 buy() 方法，用于购买库存
        System.out.println("Stock [ Name: " + name + ", Quantity: " + quantity + " ] bought");
    }

    public void sell() { // 定义一个 sell() 方法，用于出售库存
        System.out.println("Stock [ Name: " + name + ", Quantity: " + quantity + " ] sold");
    }
}

// 定义一个 BuyStock 类，实现 Order 接口，表示购买订单
class BuyStock implements Order {
    private Stock abcStock; // 定义一个 Stock 类型的 abcStock，表示库存

    public BuyStock(Stock abcStock) { // 定义一个带参构造方法，用于创建 BuyStock 对象
        this.abcStock = abcStock;
    }

    @Override
    public void execute() { // 实现 Order 接口中的 execute() 方法
        abcStock.buy(); // 调用 Stock 对象的 buy() 方法
    }
}

// 定义一个 SellStock 类，实现 Order 接口，表示出售订单
class SellStock implements Order {
    private Stock abcStock; // 定义一个 Stock 类型的 abcStock，表示库存

    public SellStock(Stock abcStock) { // 定义一个带参构造方法，用于创建 SellStock 对象
        this.abcStock = abcStock;
    }

    @Override
    public void execute() { // 实现 Order 接口中的 execute() 方法
        abcStock.sell(); // 调用 Stock 对象的 sell() 方法
    }
}

// 定义一个 Broker 类，表示经纪人
class Broker {
    private List<Order> orderList = new ArrayList<Order>(); // 定义一个 List<Order> 类型的 orderList，表示订单列表

    public void takeOrder(Order order) { // 定义一个 takeOrder() 方法，用于添加订单
        orderList.add(order);
    }

    public void placeOrders() { // 定义一个 placeOrders() 方法，用于执行订单
        for (Order order : orderList) { // 遍历订单列表
            order.execute(); // 执行订单
        }
        orderList.clear(); // 清空订单列表
    }
}

public class CommandPatternDemo {
    public static void main(String[] args) {
        Stock abcStock = new Stock(); // 创建一个 Stock 对象

        BuyStock buyStockOrder = new BuyStock(abcStock); // 创建一个 BuyStock 对象
        SellStock sellStockOrder = new SellStock(abcStock); // 创建一个 SellStock 对象

        Broker broker = new Broker(); // 创建一个 Broker 对象
        broker.takeOrder(buyStockOrder); // 添加购买订单
        broker.takeOrder(sellStockOrder); // 添加出售订单

        broker.placeOrders(); // 执行订单
    }
}

解释器模式（Interpreter Pattern）

解释器模式是一种行为型模式，它定义了一种语言，用于解释和执行特定的操作。这种方式可以通过解释器来实现复杂的语言，并且可以在运行时动态地修改语言。

// 定义一个 Expression 接口，表示表达式
interface Expression {
    boolean interpret(String context); // 定义一个 interpret() 方法，用于解释表达式
}

// 定义一个 TerminalExpression 类，实现 Expression 接口，表示终端表达式
class TerminalExpression implements Expression {
    private String data; // 定义一个字符串类型的 data，表示数据

    public TerminalExpression(String data) { // 定义一个带参构造方法，用于创建 TerminalExpression 对象
        this.data = data;
    }

    @Override
    public boolean interpret(String context) { // 实现 Expression 接口中的 interpret() 方法
        if (context.contains(data)) { // 如果上下文中包含数据
            return true; // 返回 true
        }
        return false; // 返回 false
    }
}

// 定义一个 OrExpression 类，实现 Expression 接口，表示或表达式
class OrExpression implements Expression {
    private Expression expr1 = null; // 定义一个 Expression 类型的 expr1，表示表达式1
    private Expression expr2 = null; // 定义一个 Expression 类型的 expr2，表示表达式2

    public OrExpression(Expression expr1, Expression expr2) { // 定义一个带参构造方法，用于创建 OrExpression 对象
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    @Override
    public boolean interpret(String context) { // 实现 Expression 接口中的 interpret() 方法
        return expr1.interpret(context) || expr2.interpret(context); // 返回表达式1或表达式2的结果
    }
}

// 定义一个 AndExpression 类，实现 Expression 接口，表示与表达式
class AndExpression implements Expression {
    private Expression expr1 = null; // 定义一个 Expression 类型的 expr1，表示表达式1
    private Expression expr2 = null; // 定义一个 Expression 类型的 expr2，表示表达式2

    public AndExpression(Expression expr1, Expression expr2) { // 定义一个带参构造方法，用于创建 AndExpression 对象
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    @Override
    public boolean interpret(String context) { // 实现 Expression 接口中的 interpret() 方法
        return expr1.interpret(context) && expr2.interpret(context); // 返回表达式1和表达式2的结果
    }
}

// 定义一个 Rule 类，表示规则
class Rule {
    private Expression ruleExpression; // 定义一个 Expression 类型的 ruleExpression，表示规则表达式

    public Rule(String rule) { // 定义一个带参构造方法，用于创建 Rule 对象
        Expression person = new TerminalExpression("person"); // 创建一个 TerminalExpression 对象，表示人
        Expression location = new TerminalExpression("location"); // 创建一个 TerminalExpression 对象，表示地点

        Expression orExpression = new OrExpression(person, location); // 创建一个 OrExpression 对象，表示或表达式
        Expression andExpression = new AndExpression(orExpression, new TerminalExpression(rule)); // 创建一个 AndExpression 对象，表示与表达式

        this.ruleExpression = andExpression; // 将 AndExpression 对象赋值给 ruleExpression
    }

    public boolean interpret(String context) { // 定义一个 interpret() 方法，用于解释规则
        return ruleExpression.interpret(context); // 调用 ruleExpression 的 interpret() 方法
    }
}

public class InterpreterPatternDemo {
    public static void main(String[] args) {
        Rule rule1 = new Rule("person location"); // 创建一个 Rule 对象，表示人和地点
        Rule rule2 = new Rule("person"); // 创建一个 Rule 对象，表示人

        System.out.println("rule1: " + rule1.interpret("person")); // 输出 rule1 的解释结果
        System.out.println("rule2: " + rule2.interpret("person")); // 输出 rule2 的解释结果
    }
}

迭代器模式（Iterator Pattern）

迭代器模式是一种行为型模式，它提供一种方法，使得可以顺序访问一个聚合对象中的各个元素，而又不暴露该对象的内部表示。这种方式可以使得聚合对象的数据结构可以独立于遍历算法，可以支持多种遍历方式，可以提供一种统一的遍历接口等功能。

// 定义一个 Iterator 接口，表示迭代器
interface Iterator {
    boolean hasNext(); // 定义一个 hasNext() 方法，用于判断是否还有下一个元素
    Object next(); // 定义一个 next() 方法，用于获取下一个元素
}

// 定义一个 Container 接口，表示容器
interface Container {
    Iterator getIterator(); // 定义一个 getIterator() 方法，用于获取迭代器
}

// 定义一个 NameRepository 类，实现 Container 接口，表示名称仓库
class NameRepository implements Container {
    public String names[] = { "Robert", "John", "Julie", "Lora" }; // 定义一个字符串数组 names，表示名称列表

    @Override
    public Iterator getIterator() { // 实现 Container 接口中的 getIterator() 方法
        return new NameIterator(); // 返回一个 NameIterator 对象
    }

    // 定义一个 NameIterator 类，实现 Iterator 接口，表示名称迭代器
    private class NameIterator implements Iterator {
        int index; // 定义一个整型的 index，表示名称列表的索引

        @Override
        public boolean hasNext() { // 实现 Iterator 接口中的 hasNext() 方法
            if (index < names.length) { // 如果索引小于名称列表的长度
                return true; // 返回 true
            }
            return false; // 返回 false
        }

        @Override
        public Object next() { // 实现 Iterator 接口中的 next() 方法
            if (this.hasNext()) { // 如果还有下一个元素
                return names[index++]; // 返回下一个元素
            }
            return null; // 返回 null
        }
    }
}

public class IteratorPatternDemo {
    public static void main(String[] args) {
        NameRepository namesRepository = new NameRepository(); // 创建一个 NameRepository 对象

        for (Iterator iter = namesRepository.getIterator(); iter.hasNext();) { // 使用迭代器遍历名称列表
            String name = (String) iter.next(); // 获取下一个名称
            System.out.println("Name : " + name); // 输出名称
        }
    }
}

中介者模式（Mediator Pattern）

中介者模式是一种行为型模式，它定义了一种中介者对象，用于封装一系列对象之间的交互。这种方式可以使得对象之间的交互变得简单而直接，可以减少对象之间的耦合度，可以使得系统更加易于维护。

// 定义一个 ChatRoom 类，表示聊天室
class ChatRoom {
    public static void showMessage(User user, String message) { // 定义一个 showMessage() 方法，用于显示消息
        System.out.println(new Date().toString() + " [" + user.getName() + "] : " + message);
    }
}

// 定义一个 User 类，表示用户
class User {
    private String name; // 定义一个字符串类型的 name，表示用户名

    public User(String name) { // 定义一个带参构造方法，用于创建 User 对象
        this.name = name;
    }

    public String getName() { // 定义一个 getName() 方法，用于获取用户名
        return name;
    }

    public void setName(String name) { // 定义一个 setName() 方法，用于设置用户名
        this.name = name;
    }

    public void sendMessage(String message) { // 定义一个 sendMessage() 方法，用于发送消息
        ChatRoom.showMessage(this, message); // 调用 ChatRoom 类的 showMessage() 方法
    }
}

public class MediatorPatternDemo {
    public static void main(String[] args) {
        User robert = new User("Robert"); // 创建一个 User 对象，表示 Robert
        User john = new User("John"); // 创建一个 User 对象，表示 John

        robert.sendMessage("Hi! John!"); // 发送消息给 John
        john.sendMessage("Hello! Robert!"); // 发送消息给 Robert
    }
}

备忘录模式（Memento Pattern）

备忘录模式是一种行为型模式，它可以将对象的状态保存在备忘录中，从而可以在需要的时候恢复对象的状态。这种方式可以使得对象的状态可以被保存和恢复，可以使得对象的实现细节被封装起来，可以支持撤销操作等功能。

// 定义一个 Memento 类，表示备忘录
class Memento {
    private String state; // 定义一个字符串类型的 state，表示状态

    public Memento(String state) { // 定义一个带参构造方法，用于创建 Memento 对象
        this.state = state;
    }

    public String getState() { // 定义一个 getState() 方法，用于获取状态
        return state;
    }
}

// 定义一个 Originator 类，表示原始对象
class Originator {
    private String state; // 定义一个字符串类型的 state，表示状态

    public void setState(String state) { // 定义一个 setState() 方法，用于设置状态
        this.state = state;
    }

    public String getState() { // 定义一个 getState() 方法，用于获取状态
        return state;
    }

    public Memento saveStateToMemento() { // 定义一个 saveStateToMemento() 方法，用于将状态保存到备忘录中
        return new Memento(state); // 返回一个 Memento 对象
    }

    public void getStateFromMemento(Memento memento) { // 定义一个 getStateFromMemento() 方法，用于从备忘录中恢复状态
        state = memento.getState(); // 获取备忘录中的状态，并赋值给 state
    }
}

// 定义一个 CareTaker 类，表示备忘录管理器
class CareTaker {
    private List<Memento> mementoList = new ArrayList<Memento>(); // 定义一个 List<Memento> 类型的 mementoList，表示备忘录列表

    public void add(Memento state) { // 定义一个 add() 方法，用于添加备忘录
        mementoList.add(state);
    }

    public Memento get(int index) { // 定义一个 get() 方法，用于获取备忘录
        return mementoList.get(index);
    }
}

public class MementoPatternDemo {
    public static void main(String[] args) {
        Originator originator = new Originator(); // 创建一个 Originator 对象

        originator.setState("State #1"); // 设置状态为 State #1
        originator.setState("State #2"); // 设置状态为 State #2

        CareTaker careTaker = new CareTaker(); // 创建一个 CareTaker 对象

        careTaker.add(originator.saveStateToMemento()); // 将状态保存到备忘录中
        originator.setState("State #3"); // 设置状态为 State #3

        careTaker.add(originator.saveStateToMemento()); // 将状态保存到备忘录中
        originator.setState("State #4"); // 设置状态为 State #4

        System.out.println("Current State: " + originator.getState()); // 输出当前状态

        originator.getStateFromMemento(careTaker.get(0)); // 从备忘录中恢复状态
        System.out.println("First Saved State: " + originator.getState()); // 输出第一个保存的状态

        originator.getStateFromMemento(careTaker.get(1)); // 从备忘录中恢复状态
        System.out.println("Second Saved State: " + originator.getState()); // 输出第二个保存的状态
    }
}

观察者模式（Observer Pattern）

观察者模式是一种行为型模式，它定义了一种一对多的依赖关系，使得多个观察者对象可以同时监听某一个主题对象，当主题对象发生变化时，它会通知所有的观察者对象，使得它们可以自动更新自己的状态。这种方式可以使得主题对象和观察者对象之间的耦合度降低，可以支持广播通信等功能。

// 定义一个 Subject 接口，表示主题
interface Subject {
    void attach(Observer observer); // 定义一个 attach() 方法，用于添加观察者
    void detach(Observer observer); // 定义一个 detach() 方法，用于删除观察者
    void notifyObservers(); // 定义一个 notifyObservers() 方法，用于通知观察者
    String getState(); // 定义一个 getState() 方法，用于获取状态
    void setState(String state); // 定义一个 setState() 方法，用于设置状态
}

// 定义一个 Observer 接口，表示观察者
interface Observer {
    void update(); // 定义一个 update() 方法，用于更新状态
}

// 定义一个 ConcreteSubject 类，实现 Subject 接口，表示具体主题
class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<Observer>(); // 定义一个 List<Observer> 类型的 observers，表示观察者列表
    private String state; // 定义一个字符串类型的 state，表示状态

    @Override
    public void attach(Observer observer) { // 实现 Subject 接口中的 attach() 方法
        observers.add(observer); // 添加观察者
    }

    @Override
    public void detach(Observer observer) { // 实现 Subject 接口中的 detach() 方法
        observers.remove(observer); // 删除观察者
    }

    @Override
    public void notifyObservers() { // 实现 Subject 接口中的 notifyObservers() 方法
        for (Observer observer : observers) { // 遍历观察者列表
            observer.update(); // 更新观察者
        }
    }

    @Override
    public String getState() { // 实现 Subject 接口中的 getState() 方法
        return state; // 返回状态
    }

    @Override
    public void setState(String state) { // 实现 Subject 接口中的 setState() 方法
        this.state = state; // 设置状态
        notifyObservers(); // 通知观察者
    }
}

// 定义一个 ConcreteObserver 类，实现 Observer 接口，表示具体观察者
class ConcreteObserver implements Observer {
    private String name; // 定义一个字符串类型的 name，表示观察者名称
    private Subject subject; // 定义一个 Subject 类型的 subject，表示主题对象

    public ConcreteObserver(String name, Subject subject) { // 定义一个带参构造方法，用于创建 ConcreteObserver 对象
        this.name = name;
        this.subject = subject;
    }

    @Override
    public void update() { // 实现 Observer 接口中的 update() 方法
        System.out.println(name + " received the message: " + subject.getState()); // 输出更新的状态
    }
}

public class ObserverPatternDemo {
    public static void main(String[] args) {
        ConcreteSubject subject = new ConcreteSubject(); // 创建一个 ConcreteSubject 对象

        Observer observer1 = new ConcreteObserver("Observer1", subject); // 创建一个 ConcreteObserver 对象，表示观察者1
        Observer observer2 = new ConcreteObserver("Observer2", subject); // 创建一个 ConcreteObserver 对象，表示观察者2

        subject.attach(observer1); // 添加观察者1
        subject.attach(observer2); // 添加观察者2

        subject.setState("new state"); // 设置新的状态
    }
}

状态模式（State Pattern）

状态模式是一种行为型模式，它允许对象在其内部状态改变时改变它的行为。这种方式可以使得对象的状态可以被封装起来，可以支持状态转换的自动化，可以使得对象的行为可以随着状态的改变而改变等功能。

// 定义一个 State 接口，表示状态
interface State {
    void doAction(Context context); // 定义一个 doAction() 方法，用于执行操作
}

// 定义一个 StartState 类，实现 State 接口，表示开始状态
class StartState implements State {
    @Override
    public void doAction(Context context) { // 实现 State 接口中的 doAction() 方法
        System.out.println("Player is in start state"); // 输出当前状态
        context.setState(this); // 将状态设置为当前状态
    }

    public String toString() { // 重写 toString() 方法
        return "Start State";
    }
}

// 定义一个 StopState 类，实现 State 接口，表示停止状态
class StopState implements State {
    @Override
    public void doAction(Context context) { // 实现 State 接口中的 doAction() 方法
        System.out.println("Player is in stop state"); // 输出当前状态
        context.setState(this); // 将状态设置为当前状态
    }

    public String toString() { // 重写 toString() 方法
        return "Stop State";
    }
}

// 定义一个 Context 类，表示上下文
class Context {
    private State state; // 定义一个 State 类型的 state，表示状态

    public Context() { // 定义一个无参构造方法，用于创建 Context 对象
        state = null; // 将 state 设置为 null
    }

    public void setState(State state) { // 定义一个 setState() 方法，用于设置状态
        this.state = state;
    }

    public State getState() { // 定义一个 getState() 方法，用于获取状态
        return state;
    }
}

public class StatePatternDemo {
    public static void main(String[] args) {
        Context context = new Context(); // 创建一个 Context 对象

        StartState startState = new StartState(); // 创建一个 StartState 对象
        startState.doAction(context); // 执行开始状态的操作
        System.out.println(context.getState().toString()); // 输出当前状态

        StopState stopState = new StopState(); // 创建一个 StopState 对象
        stopState.doAction(context); // 执行停止状态的操作
        System.out.println(context.getState().toString()); // 输出当前状态
    }
}

策略模式（Strategy Pattern）

策略模式是一种行为型模式，它定义了一系列算法，将每个算法都封装起来，并且可以相互替换。这种方式可以使得算法可以独立于使用它的客户端而变化，可以支持动态地切换算法等功能。

// 定义一个 Strategy 接口，表示策略
interface Strategy {
    int doOperation(int num1, int num2); // 定义一个 doOperation() 方法，用于执行操作
}

// 定义一个 OperationAdd 类，实现 Strategy 接口，表示加法策略
class OperationAdd implements Strategy {
    @Override
    public int doOperation(int num1, int num2) { // 实现 Strategy 接口中的 doOperation() 方法
        return num1 + num2; // 返回两个数的和
    }
}

// 定义一个 OperationSubtract 类，实现 Strategy 接口，表示减法策略
class OperationSubtract implements Strategy {
    @Override
    public int doOperation(int num1, int num2) { // 实现 Strategy 接口中的 doOperation() 方法
        return num1 - num2; // 返回两个数的差
    }
}

// 定义一个 OperationMultiply 类，实现 Strategy 接口，表示乘法策略
class OperationMultiply implements Strategy {
    @Override
    public int doOperation(int num1, int num2) { // 实现 Strategy 接口中的 doOperation() 方法
        return num1 * num2; // 返回两个数的积
    }
}

// 定义一个 Context 类，表示上下文
class Context {
    private Strategy strategy; // 定义一个 Strategy 类型的 strategy，表示策略

    public Context(Strategy strategy) { // 定义一个带参构造方法，用于创建 Context 对象
        this.strategy = strategy;
    }

    public int executeStrategy(int num1, int num2) { // 定义一个 executeStrategy() 方法，用于执行策略
        return strategy.doOperation(num1, num2); // 调用 Strategy 接口中的 doOperation() 方法
    }
}

public class StrategyPatternDemo {
    public static void main(String[] args) {
        Context context = new Context(new OperationAdd()); // 创建一个 Context 对象，表示加法策略
        System.out.println("10 + 5 = " + context.executeStrategy(10, 5)); // 输出两个数的和

        context = new Context(new OperationSubtract()); // 创建一个 Context 对象，表示减法策略
        System.out.println("10 - 5 = " + context.executeStrategy(10, 5)); // 输出两个数的差

        context = new Context(new OperationMultiply()); // 创建一个 Context 对象，表示乘法策略
        System.out.println("10 * 5 = " + context.executeStrategy(10, 5)); // 输出两个数的积
    }
}

模板方法模式（Template Method Pattern）

模板方法模式是一种行为型模式，它定义了一个操作中的算法骨架，将一些步骤延迟到子类中。这种方式可以使得子类可以不改变算法的结构即可重定义该算法的某些特定步骤，可以提高代码的复用性和可维护性。

// 定义一个 Game 抽象类，表示游戏
abstract class Game {
    abstract void initialize(); // 定义一个抽象的 initialize() 方法，用于初始化游戏
    abstract void startPlay(); // 定义一个抽象的 startPlay() 方法，用于开始游戏
    abstract void endPlay(); // 定义一个抽象的 endPlay() 方法，用于结束游戏

    public final void play() { // 定义一个 final 的 play() 方法，用于执行游戏
        initialize(); // 调用 initialize() 方法
        startPlay(); // 调用 startPlay() 方法
        endPlay(); // 调用 endPlay() 方法
    }
}
// 定义一个 Cricket 类，继承 Game 抽象类，表示板球游戏
class Cricket extends Game {
@Override
void endPlay() { // 实现 Game 抽象类中的 endPlay() 方法
System.out.println("Cricket Game Finished!"); // 输出游戏结束信息
}

@Override
void initialize() { // 实现 Game 抽象类中的 initialize() 方法
    System.out.println("Cricket Game Initialized! Start playing."); // 输出游戏初始化信息
}

@Override
void startPlay() { // 实现 Game 抽象类中的 startPlay() 方法
    System.out.println("Cricket Game Started. Enjoy the game!"); // 输出游戏开始信息
}
}

// 定义一个 Football 类，继承 Game 抽象类，表示足球游戏
class Football extends Game {
@Override
void endPlay() { // 实现 Game 抽象类中的 endPlay() 方法
System.out.println("Football Game Finished!"); // 输出游戏结束信息
}

@Override
void initialize() { // 实现 Game 抽象类中的 initialize() 方法
    System.out.println("Football Game Initialized! Start playing."); // 输出游戏初始化信息
}

@Override
void startPlay() { // 实现 Game 抽象类中的 startPlay() 方法
    System.out.println("Football Game Started. Enjoy the game!"); // 输出游戏开始信息
}
}

public class TemplatePatternDemo {
public static void main(String[] args) {
Game game = new Cricket(); // 创建一个 Cricket 对象
game.play(); // 执行 Cricket 游戏

    System.out.println();

    game = new Football(); // 创建一个 Football 对象
    game.play(); // 执行 Football 游戏
}
}