Java设计模式-学习

JAVA 设计模式

目录

设计模式的类型

编号	模式和说明
1	创造模式 -这些设计模式提供了一种创建对象而隐藏逻辑的方法，而不是直接使用 new 操作符来实例化对象。这使程序在决定对于给定的用例需要哪些对象时具有更大的灵活性。
2	结构模式 -这些设计模式设计类和对象的组成。继承概念用于组成接口并定义方法组合对象以获得新功能。
3	行为模式 -这些设计模式是特别侧重于对象之间的通信。
4	J2EE 模式 -这些设计模式特别设计表示层。这些模式由 Sun Java Center 标识。

在核心 Java 中，主要有三种类型的设计模式，可进一步细分：

1. 创造设计模式

• 工厂模式
• 抽象工厂模式
• 单例模式
• 原型模式
• Builder模式

2. 结构设计模式

• 适配器（Adapter）模式
• 桥接（Bridge）模式
• 组合模式
• 装饰者（Decorator）模式
• 外观（Facade）模式
• 享元（Flyweight）模式
• 代理（Proxy）模式

3. 行为设计模式

• 责任链模式
• 命令模式
• 解释器模式
• 迭代器模式
• 调节者（Mediator）模式
• 备忘录模式
• 观察者模式
• 状态模式
• 策略模式
• 模板模式
• 访问者模式

一. 工厂模式实现方法

​ 返回目录

​ 工厂模式是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建模式，因为此模式提供了创建对象的最佳方法之一。

**1. 创建一个接口 **

// Shape.java
package mode.factory;

public interface Shape {
    void draw();
}

2. 创建实现相同接口的具体类

// Rectangle.java
package mode.factory;

public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Recangle::draw() method.");
    }
}

// Square.java
package mode.factory;

public class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

// Circle.java
package mode.factory;

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

3. 创建工厂根据给定的信息生成具体类的对象

// ShapeFactory.java
package mode.factory;
public class ShapeFactory {
    //use getShape method to get object of type shape
    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();
        } else if(shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }

        return  null;
    }
}

4. 创建演示类，使用工厂通过传递类型等信息来获取具体类的对象

// FactoryPatternDemo
package mode.factory;
public class FactoryPatternDemo {
    public static void main(String[] args) {
        ShapeFactory shapeFactory = new ShapeFactory();

        //get an object of Circle and call its draw method.
        Shape shape1 = shapeFactory.getShape("CIRCLE");

        //call draw method of Circle
        shape1.draw();

        // Rectangle
        Shape shape2 = shapeFactory.getShape("RECTANGLE");
        shape2.draw();

        // SQUARE
        Shape shape3 = shapeFactory.getShape("SQUARE");
        shape3.draw();
    }
}

运行 FactoryPatternDemo.java 得到结果：

二. 抽象工厂模式实现方法

​ 返回目录

​ 抽象工厂模式是一个超级工厂，用来创建其它工厂。这个工厂也被称为工厂的工厂，这种类型的设计模式属于创建模式，因为此模式提供了创建对象的最佳方法之一。在抽象工厂模式中，接口负责创建相关对象的工厂，而不明确指定它们的类，每个生成的工厂可以按照工厂模式提供对象。

1. 创建一个 Square 接口

// Shape.java
package mode.abstractfactory;

public interface Shape {
    void draw();
}

2. 创建实现相同接口的具体类

// Rectangle.java
package mode.abstractfactory;

public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

// Square.java
package mode.abstractfactory;

public class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

// Circle.java
package mode.abstractfactory;

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

3. 创建一个 Color 接口

// Color.java
package mode.abstractfactory;

public interface Color {
    void fill();
}

4. 创建实现相同接口的具体类

//Red.java
package mode.abstractfactory;

public class Red implements Color {

    @Override
    public void fill() {
        System.out.println("Inside Red::fill() method.");
    }
}

//Green.java
package mode.abstractfactory;

public class Green implements Color {

    @Override
    public void fill() {
        System.out.println("Inside Green::fill() method.");
    }
}

// Bule.java
package mode.abstractfactory;

public class Blue implements Color {

    @Override
    public void fill() {
        System.out.println("Inside Blue::fill() method.");
    }
}

5. 创建实现 Shape Color 接口的具体类

// AbstractFactory.java
package mode.abstractfactory;

public abstract class AbstractFactory {
    abstract Color getColor(String color);
    abstract Shape getShape(String shape);
}

6. 创建工厂类，根据给定信息扩展 AbstractFactory 以生成具体类的对象

// ShapeFactory.java
package mode.abstractfactory;

public class ShapeFactory extends AbstractFactory{
    @Override
    Color getColor(String color) {
        return null;
    }

    @Override
    Shape getShape(String shapeType) {

        if(shapeType == null){
            return null;
        }

        if(shapeType.equalsIgnoreCase("CIRCLE")){
            return new Circle();
        } else if(shapeType.equalsIgnoreCase("RECTANGLE")){
            return new Rectangle();
        } else if(shapeType.equalsIgnoreCase("SQUARE")){
            return new Square();
        }

        return null;
    }
}

// ColorFactory.java
package mode.abstractfactory;

public class ColorFactory extends AbstractFactory{
    @Override
    Color getColor(String color) {

        if(color == null){
            return null;
        }

        if(color.equalsIgnoreCase("RED")){
            return new Red();
        } else if(color.equalsIgnoreCase("GREEN")){
            return new Green();
        } else if(color.equalsIgnoreCase("BLUE")){
            return new Blue();
        }

        return null;
    }

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

7. 创建工厂生成器/生产器类

通过传递如 Shape Color 等信息来获取工厂

// FactoryProducer.java
package mode.abstractfactory;

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

8. 创建演示类，调用实例

// AbstractFactoryPatternDemo.java
package mode.abstractfactory;

public class AbstractFactoryPatternDemo {
    public static void main(String[] args) {

        //get shape factory
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");

        //get an object of Shape Circle
        Shape shape1 = shapeFactory.getShape("CIRCLE");

        //call draw method of Shape Circle
        shape1.draw();

        //get an object of Shape Rectangle
        Shape shape2 = shapeFactory.getShape("RECTANGLE");

        //call draw method of Shape Rectangle
        shape2.draw();

        //get an object of Shape Square
        Shape shape3 = shapeFactory.getShape("SQUARE");

        //call draw method of Shape Square
        shape3.draw();

        //get color factory
        AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");

        //get an object of Color Red
        Color color1 = colorFactory.getColor("RED");

        //call fill method of Red
        color1.fill();

        //get an object of Color Green
        Color color2 = colorFactory.getColor("Green");

        //call fill method of Green
        color2.fill();

        //get an object of Color Blue
        Color color3 = colorFactory.getColor("BLUE");

        //call fill method of Color Blue
        color3.fill();
    }
}

9. 验证输出，结果如下

三. 单例模式

​ 返回目录

​ 单例（Singleton）模式属于创建模式；该模式设计一个类，它负责创建一个对象。这个类提供了一个方法来访问它的唯一对象，可以直接访问而不需要实例化类的对象。

SingleObject 类提供了一个静态方法来获取其静态实例到外部世界。 SingletonPatternDemo 或示例类将使用 SingleObject 类来获取 SingleObject 对象。

1. 创建一个 Singleton 类

// SingleObject.java
package mode.Singleton;

public class SingleObject {
    // create an object of SingleObject
    private static SingleObject instance = new SingleObject();

    // make the constructor private so that this class cannot be
    // instantiated
    private SingleObject(){}

    // Get the only object avaiable
    public static SingleObject getInstance(){
        return instance;
    }

    public void showMessage(){
        System.out.println("Hello World!");
    }
}

2. 创建演示类，从单例类中获取唯一的对象

// SinglePatternDemo.java
package mode.Singleton;

public class SinglePatternDemo {
    public static void main(String[] args) {

        // illegal construct
        // Compile Time Error: The constructor SingleObject() is not visible
        // SingleObject object = new SingleObject();

        //Get the only object available
        SingleObject object = SingleObject.getInstance();

        // show the message
        object.showMessage();
    }
}

3. 验证输出，结果如下

四. 建造者（Builder）模式

​ 返回目录

​ 构建器（Builder）模式使用简单对象并使用逐步方法构建复杂对象，属于创建模式中的一种。构建器（Builder）模式，构建器逐步构建最终对象，此构建器独立于其它对象。

1. 创建接口

创建两个接口分别代表食品和包装的项目（Item 和 Packing）

//Item.java
package mode.builder;

public interface Item {
    public String name();
    public Packing packing();
    public float price();
}

//Packing.java
package mode.builder;

public interface Packing {
    public String pack();
}

2. 创建实现 Packing 接口的具体实现类

//Wrapper.java
package mode.builder;

public class Wrapper implements Packing{

    @Override
    public String pack() {
        return "Wrapper";
    }
}

//Bottle.java
package mode.builder;

public class Bottle implements Packing{
    @Override
    public String pack() {
        return "Bottle";
    }
}

3. 创建抽象类实现 Item 接口提供默认功能

//Burger.java
package mode.builder;

public abstract class Burger implements Item {

    @Override
    public Packing packing() {
        return new Wrapper();
    }

    @Override
    public abstract float price();
}

//ColdDrink.java
package mode.builder;

public abstract class ColdDrink implements Item {

    @Override
    public Packing packing() {
        return new Bottle();
    }

    @Override
    public abstract float price();
}

4. 创建扩展汉堡(Burger) 和冷饮( ColdDrink )类的具体类

//VegBurger.java
package mode.builder;

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

    @Override
    public float price() {
        return 25.0f;
    }
}

//ChickenBurger.java
package mode.builder;

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

    @Override
    public float price() {
        return 50.5f;
    }
}

// Coke.java
package mode.builder;

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

    @Override
    public float price() {
        return 30.0f;
    }
}

// Pepsi.java
package mode.builder;

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

    @Override
    public float price() {
        return 35.0f;
    }
}

5. 创建一个具有上面定义的 Item 对象的 Meal 类

// Meal.java
package mode.builder;

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

public class Meal {
    private List<Item> items = new ArrayList<Item>();

    public void addItem(Item item){
        items.add(item);
    }

    public float getCost(){
        float cost = 0.0f;

        for(Item item : items){
            cost += item.price();
        }
        return cost;
    }

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

6. 创建一个 MealBuilder 类，这是一个实际的构建类，负责构建 Meal 对象

// MealBuilder.java
package mode.builder;

public class MealBuilder {

    public Meal prepareVegMeal(){
        Meal meal = new Meal();
        meal.addItem(new VegBurger());
        meal.addItem(new Coke());
        return meal;
    }

    public Meal prepareNonVegMeal(){
        Meal meal = new Meal();
        meal.addItem(new ChickenBurger());
        meal.addItem(new Pepsi());
        return meal;
    }
}

7. BuilderPatternDemo 类使用 MealBuilder 对象来演示构建器模式

// BuilderPatternDemo.java
package mode.builder;

public class BuilderPatternDemo {
    public static void main(String[] args) {

        MealBuilder mealBuilder = new MealBuilder();

        Meal vegMeal = mealBuilder.prepareVegMeal();
        System.out.println("Veg Meal");
        vegMeal.showItems();
        System.out.println("Total Cost: " + vegMeal.getCost());

        Meal noVegMeal = mealBuilder.prepareNonVegMeal();
        System.out.println("\nNon-Veg Meal");
        noVegMeal.showItems();
        System.out.println("Total Cost: " + noVegMeal.getCost());
    }
}

8. 验证结果，输出如下

五. 原型模式

​ 返回目录

​ 原型模式指在创建重复对象的同事保持性能，属于创建模式。

这个模式涉及实现一个原型接口，它只创建当前对象的克隆。有事直接创建对象时使用这种模式是昂贵的。例如，在昂贵的数据库操作之后创建对象，可以先缓存对象，在下一个请求返回时克隆，并在需要时更新数据库，从而减少数据库调用。

1. 创建一个实现 Clonable 接口的抽象类

// Shape.java
package mode.prototype;

public abstract class Shape implements Cloneable {
    private String id;
    protected String type;

    abstract void draw();

    public String getId() {
        return id;
    }

    public String getType() {
        return type;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Object clone(){
        Object clone = null;

        try{
            clone = super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }

        return clone;
    }
}

2. 创建扩展上述类的具体类

// Rectangle.java
package mode.prototype;

public class Rectangle extends Shape{

    public Rectangle(){
        type = "Square";
    }

    @Override
    void draw() {
        System.out.println("Inside Rectangle::draw() method.");
    }
}

// Square.java
package mode.prototype;

public class Square extends Shape {

    public Square(){
        type = "Square";
    }

    @Override
    void draw() {
        System.out.println("Inside Square::draw() method.");
    }
}

// Circle.java
package mode.prototype;

public class Circle extends Shape{

    public Circle(){
        type = "Circle";
    }

    @Override
    void draw() {
        System.out.println("Inside Circle::draw() method.");
    }
}

3. 创建一个类来获取具体的类，并将它们存储在 Hashtable 中

// ShapeCache.java
package mode.prototype;

import java.util.Hashtable;

public class ShapeCache {

    private static Hashtable<String, Shape> shapeMap = new Hashtable<String, Shape>();

    public static Shape getShape(String shapeId){
        Shape cachedShape = shapeMap.get(shapeId);
        return (Shape) cachedShape.clone();
    }

    // for each shape run database query and create shape
    // shapeMap.put(shapeKey, shape);
    // for example, we are adding three shapes

    public static void loadCache(){
        Circle circle =new Circle();
        circle.setId("1");
        shapeMap.put(circle.getId(),circle);

        Square square = new Square();
        square.setId("2");
        shapeMap.put(square.getId(),square);

        Rectangle rectangle = new Rectangle();
        rectangle.setId("3");
        shapeMap.put(rectangle.getId(),rectangle);
    }
}

**4. PrototypeDemo 使用 ShapeCache 类来获取在 Hashtable 中的形状（shape）**的克隆

// PrototypePatternDemo.java
package mode.prototype;

public class PrototypePatternDemo {
    public static void main(String[] args) {
        ShapeCache.loadCache();

        Shape cloneShape = (Shape) ShapeCache.getShape("1");
        System.out.println("Shape : " + cloneShape.getType());

        Shape cloneShape2 = (Shape) ShapeCache.getShape("2");
        System.out.println("Shape : " + cloneShape2.getType());

        Shape cloneShape3 = (Shape) ShapeCache.getShape("3");
        System.out.println("Shape : " + cloneShape3.getType());
    }
}

5. 验证结果，输出如下

六. 适配器模式

​ 返回目录

​ 适配器模式作为两个不兼容接口之间的桥梁。这种类型的设计模式属于结构模式，因为该模式组合了两个独立接口。这种模式涉及一个单独类，它负责连接独立或不兼容接口的功能。

1. 分别创建媒体播放器和高级媒体播放器接口

// MediaPlayer.java
package pattern.adapter;

public interface MediaPlayer {
    public void play(String audioType, String fileName);
}

// AdvancedMediaPlayer.java
package pattern.adapter;

public interface AdvancedMediaPlayer {
    public void playVlc(String fileName);
    public void playMp4(String fileName);
}

2. 创建实现 AdvancedMediaPlayer 接口的具体类

// VlcPlayer.java
package pattern.adapter;

public class VlcPlayer implements AdvancedMediaPlayer{
    @Override
    public void playVlc(String fileName) {
        System.out.println("Playing vlc file. Name: " + fileName);
    }

    @Override
    public void playMp4(String fileName) {
        //do nothing
    }
}

// Mp4Player.java
package pattern.adapter;

public class Mp4Player implements AdvancedMediaPlayer{
    @Override
    public void playVlc(String fileName) {
        // do nothing
    }

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

3. 创建实现 MediaPlayer 接口的适配器类

// MediaAdapter.java
public class MediaAdapter implements MediaPlayer{

    AdvancedMediaPlayer advancedMediaPlayer;

    public MediaAdapter(String audioType){

        if(audioType.equalsIgnoreCase("vlc")){
            advancedMediaPlayer = new VlcPlayer();
        } else if(audioType.equalsIgnoreCase("mp4")){
            advancedMediaPlayer = new Mp4Player();
        }
    }

    @Override
    public void play(String audioType, String fileName) {

        if(audioType.equalsIgnoreCase("vlc")){
            advancedMediaPlayer.playVlc(fileName);
        } else if(audioType.equalsIgnoreCase("mp4")){
            advancedMediaPlayer.playMp4(fileName);
        }
    }
}

4. 创建一个实现 MediaPlayer 接口的具体类

// AudioPlayer.java
package pattern.adapter;

public class AudioPlayer implements MediaPlayer{

    MediaAdapter mediaAdapter;

    @Override
    public void play(String audioType, String fileName) {
        //inbuilt support to play mp3 music files
        if(audioType.equalsIgnoreCase("mp3")){
            System.out.println("Playing mp3 file. Name: " + fileName);
        }

        //mediaAdapter is providing support to play other file formats
        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");
        }
    }
}

5. 使用 AudioPlayer 播放不同类型的音频格式

// AdapterPatternDemo.java
package pattern.adapter;

public class AdapterPatternDemo {
    public static void main(String[] args) {
        AudioPlayer audioPlayer = new AudioPlayer();

        audioPlayer.play("mp3", "beyond the horizon.mp3");
        audioPlayer.play("mp4", "alone.mp4");
        audioPlayer.play("vlc", "far far away.vlc");
        audioPlayer.play("avi", "mind me.avi");
    }
}

6. 验证输出，结果如下

七. 桥接模式

​ 返回目录

​ 桥接模式将定义与其实现分离，是一种结构模式。桥接（Bridge）模式设计充当桥接的接口，桥接使得具体类与接口实现者类无关，这两种类型的类可以改变单不会影响对方。

​ 当需要将抽象与其实现去耦合时使用桥接解耦，使得两者可以独立地变化，该模式属于结构模式汇中的一种，因为此模式通过在它们之间提供桥接结构来实现类和抽象类解耦。

1. 创建桥实现者接口

// DrawAPI.java
package pattern.bridge;

public interface DrawAPI {
    public void drawCircle(int radius, int x, int y);
}

2. 创建实现 DrawAPI 接口的具体桥接实现者类

// RedCircle.java
package pattern.bridge;

public 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 + "]");
    }
}

// GreenCircle.java
package pattern.bridge;

public 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 + "]");
    }
}

3. 使用 DrawAPI 接口创建一个抽象类 Shape

// Shape.java
package pattern.bridge;

public abstract class Shape {
    protected DrawAPI drawAPI;

    protected Shape(DrawAPI drawAPI){
        this.drawAPI = drawAPI;
    }
    public abstract void draw();
}

4. 创建实现 Shape 接口的具体类

// Circle.java
package pattern.bridge;

public class Circle extends Shape{

    private int x, y, radius;

    public Circle(int x, int y, int radius, DrawAPI drawAPI) {
        super(drawAPI);
        this.x = x;
        this.y = y;
        this.radius = radius;
    }

    @Override
    public void draw() {
        drawAPI.drawCircle(radius, x, y);
    }
}

5. 使用 Shape 和 DrawAPI 类来绘制不同的彩色圆形

// BridgePatternDemo.java
package pattern.bridge;

public class BridgePatternDemo {
    public static void main(String[] args) {
        Shape redCircle = new Circle(100, 100, 10, new RedCircle());
        Shape greenCircle = new Circle(100, 100, 10, new GreenCircle());

        redCircle.draw();
        greenCircle.draw();
    }
}

6. 验证输出，结果如下

八. 过滤器模式

​ 返回目录

​ 过滤器模式或条件模式是一种设计模式，使开发人员可以使用不同的条件过滤一组对象，并通过逻辑操作以解耦方式将其链接；该模式属于结构模式的一种，因为该模式组合对个标准以获得单个标准。

1. 创建要应用标准的类

// Personal.java
package pattern.Criteria;

public class Person {

    private String name;
    private String gender;
    private String maritalStatus;  // 婚姻状况

    public Person(String name, String gender, String maritalStatus) {
        this.name = name;
        this.gender = gender;
        this.maritalStatus = maritalStatus;
    }

    public String getName() {
        return name;
    }

    public String getGender() {
        return gender;
    }

    public String getMaritalStatus() {
        return maritalStatus;
    }
}

2. 创建 Criteria 的接口

// Criteria.java
package pattern.Criteria;

import java.util.List;

public interface Criteria {
    public List<Person> meetCriteria(List<Person> persons);
}

3. 创建实现 Criteria 接口的具体类

// CriteriaMale.java
package pattern.Criteria;

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

public class CriteriaMale implements Criteria{
    @Override
    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> malePersons = new ArrayList<Person>();

        for (Person person : persons){
            if(person.getGender().equalsIgnoreCase("MALE")){
                malePersons.add(person);
            }
        }
        return malePersons;
    }
}

// CriteriaFemale.java
package pattern.Criteria;

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

public class CriteriaFemale implements Criteria{
    @Override
    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> femalePersons = new ArrayList<Person>();

        for(Person person : persons){
            if(person.getGender().equalsIgnoreCase("FEMALE")){
                femalePersons.add(person);
            }
        }
        return femalePersons;
    }
}

// CriteriaSingle.java
package pattern.Criteria;

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

public class CriteriaSingle implements Criteria{
    @Override
    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> singlePersons = new ArrayList<Person>();

        for(Person person : persons){
            if(person.getMaritalStatus().equalsIgnoreCase("SINGLE")){
                singlePersons.add(person);
            }
        }
        return singlePersons;
    }
}

// AndCriterial.java
package pattern.Criteria;

import java.util.List;

public class AndCriteria implements Criteria{

    private Criteria criteria;
    private Criteria otherCriteria;

    public AndCriteria(Criteria criteria, Criteria otherCriteria) {
        this.criteria = criteria;
        this.otherCriteria = otherCriteria;
    }

    @Override
    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> firstCriteriaPersons = criteria.meetCriteria(persons);
        return otherCriteria.meetCriteria(firstCriteriaPersons);


    }
}

// OrCriteria.java
package pattern.Criteria;

import java.util.List;

public class OrCriteria implements Criteria{

    private Criteria criteria;
    private Criteria otherCriteria;

    public OrCriteria(Criteria criteria, Criteria otherCriteria) {
        this.criteria = criteria;
        this.otherCriteria = otherCriteria;
    }

    @Override
    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> firstCriteriaItems = criteria.meetCriteria(persons);
        List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons);

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

4. 使用不同的条件及其组合进行过滤

// CriteriaPatternDemo.java
package pattern.Criteria;

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

public class CriteriaPatternDemo {
    public static void main(String[] args) {
        List<Person> persons = new ArrayList<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();
        Criteria female = new CriteriaFemale();
        Criteria single = new CriteriaSingle();
        Criteria singleMale = new AndCriteria(single, male);
        Criteria singleOrFemale = new OrCriteria(single, female);

        System.out.println("Males: ");
        printPersons(male.meetCriteria(persons));

        System.out.println("\nFemales: ");
        printPersons(female.meetCriteria(persons));

        System.out.println("\nSingle Males: ");
        printPersons(singleMale.meetCriteria(persons));

        System.out.println("\nSingle Or Females: ");
        printPersons(singleOrFemale.meetCriteria(persons));
    }

    public static void printPersons(List<Person> persons){
        for(Person person : persons){
            System.out.println("Person : [ Name : " + person.getName() + ", Gender : " + person.getGender() + ", Marital Status : " + person.getMaritalStatus() + " ]");
        }
    }
}

5. 验证结果，输出如下

九. 组合模式

​ 返回目录

​ 组合模式用于需要一同样的方式处理一组对象，组合模式根据树结构对象，一表示部分以及整个层次结构。这种类型的设计模式属于结构模式，因为次模式创建了一组对象的树结构。

​ 此模式创建了一个包含其自身对象的组的类，此类提供了修改相同对象的组的方法。

1. 创建具有 Employee 对象列表的 Employee 类

// Employee.java
package pattern.composite;

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

public class Employee {
    private String name;
    private String dept;
    private int salary;
    private List<Employee> subordinates; // 下属

    //constructor
    public Employee(String name, String dept, int salary) {
        this.name = name;
        this.dept = dept;
        this.salary = salary;
        this.subordinates = new ArrayList<Employee>();
    }

    public void add(Employee e){
        subordinates.add(e);
    }

    public void remove(Employee e){
        subordinates.remove(e);
    }

    public List<Employee> getSubordinates(){
        return subordinates;
    }

    public String toString(){
        return ("Employee :[ Name : " + name + "," + ", dept :" + dept + ", salary : " + salary + "]");
    }

}

2. 使用 Employee 类来创建和打印员工层次结构

// CompositePatternDemo.java
package pattern.composite;

public class CompositePatternDemo {
    public static void main(String[] args) {

        Employee CEO = new Employee("John", "CEO", 30000);

        Employee headSales = new Employee("Robert", "Head Sales", 20000);

        Employee heardMarketing =new Employee("Michel", "Head Marketing", 20000);

        Employee clerk1 = new Employee("Laura", "Marketing", 10000);
        Employee clerk2 = new Employee("Bob", "Marketing", 10000);

        Employee salesExecutive1 = new Employee("Richard", "Sales", 10000);
        Employee salesExecutive2 = new Employee("Rob", "Sales", 10000);

        CEO.add(headSales);
        CEO.add(heardMarketing);

        headSales.add(salesExecutive1);
        headSales.add(salesExecutive2);

        heardMarketing.add(clerk1);
        heardMarketing.add(clerk2);

        //print all employees of the organization
        System.out.println(CEO);

        for(Employee headEmployee : CEO.getSubordinates()){
            System.out.println(headEmployee);

            for(Employee employee : headEmployee.getSubordinates()){
                System.out.println(employee);
            }
        }
    }
}

3. 验证结果，输出如下

十. 装饰模式

​ 返回目录

​ 装饰器模式允许用户向现有对象添加新功能而不改变其结构。这种类型的设计模式属于结构模式，因为此模式充当现有类的包装器。

1. 创建一个简单的接口

// Shape.java
package pattern.decorator;

public interface Shape {
    void draw();
}

2. 创建两个实现相同接口的具体类

// Rectangle.java
package pattern.decorator;

public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("Shape: Rectangle");
    }
}

// Circle.java
package pattern.decorator;

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Shape: Circle");
    }
}

3. 创建实现 Shape 接口的抽象装饰器类

// ShapeDecorator.java
package pattern.decorator;

public class ShapeDecorator implements Shape{
    protected Shape decoratedShape;

    public ShapeDecorator(Shape decoratedShape) {
        this.decoratedShape = decoratedShape;
    }

    @Override
    public void draw() {
        decoratedShape.draw();
    }
}

4. 创建扩展 ShapeDecorator 类具体装饰器

// RedShapeDecorator.java
package pattern.decorator;

public class RedShapeDecorator extends ShapeDecorator{
    public RedShapeDecorator(Shape decoratedShape) {
        super(decoratedShape);
    }

    @Override
    public void draw(){
        decoratedShape.draw();
        setRedBorder(decoratedShape);
    }

    private void setRedBorder(Shape decoratedShape){
        System.out.println("Border Color: Red");
    }
}

5. 使用 RedShapeDecorator 装饰 Shape 对象

// DecoratorPatternDemo.java
package pattern.decorator;

public class DecoratorPatternDemo {
    public static void main(String[] args) {

        Shape circle = new Circle();

        Shape redCircle = new RedShapeDecorator(new Circle());

        Shape redRectangle = new RedShapeDecorator(new Rectangle());
        System.out.println("Circle with normal border");
        circle.draw();

        System.out.println("\nCircle of red border");
        redCircle.draw();

        System.out.println("\nRectangle of red border");
        redRectangle.draw();
    }
}

6. 验证结果，输出如下

十一. 门面模式

​ 返回目录

​ 门面模式（或外观模式）隐藏系统的复杂性，并为客户端提供了一个可以访问系统的接口。这种类型的设计模式属于结构模式，因为此模式为现有系统添加了一个接口以隐藏其复杂性。

​ 门面模式涉及一个类，它提供客户端所需的简化方法和委托调用现有系统类的方法。

1. 创建一个接口

// Shape.java
package pattern.facade;

public interface Shape {
    void draw();
}

2. 创建实现几个相同接口的具体类

// Rectangle.java
package pattern.facade;

public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("Rectangle::draw()");
    }
}

// Square.java
package pattern.facade;

public class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("Square::draw()");
    }
}

// Circle.java
package pattern.facade;

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("Circle::draw()");
    }
}

3. 创建一个外观类

// ShapeMaker.java
package pattern.facade;

public class ShapeMaker {
    private Shape circle;
    private Shape rectangle;
    private Shape square;

    public ShapeMaker() {
        this.circle = new Circle();
        this.rectangle = new Rectangle();
        this.square = new Square();
    }

    public void drawCircle(){
        circle.draw();
    }

    public void drawRectangle(){
        rectangle.draw();
    }

    public void drawSquare(){
        square.draw();
    }
}

4. 使用装饰类来绘制各种类型的形状

// FacadePatternDemo.java
package pattern.facade;

public class FacadePatternDemo {
    public static void main(String[] args) {
        ShapeMaker shapeMaker = new ShapeMaker();

        shapeMaker.drawCircle();
        shapeMaker.drawRectangle();
        shapeMaker.drawSquare();
    }
}

5. 验证输出，结果如下

十二. 享元模式

​ 返回目录

​ 享元模式（Flyweight Pattern）主要用于减少创建的对象数量，减少内存占用并提高性能，这种类型的设计模式属于结构模式，因为该模式提供了减少对象计数的方法，从而改善应用的对象结构.

​ 享元模式（Flyweight Pattern）尝试通过存储已经存在的类似对象以重用，并在找不到匹配的对象是创建新对象。

1. 创建一个接口

// Shape.java
package pattern.flyweight;

public interface Shape {
    void draw();
}

2. 创建一个实现相同接口的具体类

// Circle.java
package pattern.flyweight;

public class Circle implements Shape{
    private String color;
    private int x;
    private int y;
    private int radius;

    public Circle(String color) {
        this.color = color;
    }

    public void setX(int x) {
        this.x = x;
    }

    public void setY(int y) {
        this.y = y;
    }

    public void setRadius(int radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Circle: Draw() [Color : " + color + ", \t\tx : " + x + ", \t\ty :" + y + ", \t\tradius :" + radius);
    }
}

3. 创建一个工厂根据给定的信息生产具体类的对象

// ShapeFactory.java
package pattern.flyweight;

import java.util.HashMap;

public class ShapeFactory {
    private static final HashMap<String, Shape> circleMap = new HashMap<>();

    public static Shape getCircle(String color){
        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;
    }
}

4. 使用工厂并通过传递诸如颜色的信息来获得具体类的对象

// FlyweightPatternDemo.java
package pattern.flyweight;

public class FlyweightPatternDemo {
    private static final String colors[] = {"Red", "Green", "Blue", "White", "Black"};

    public static void main(String[] args) {
        for(int i=0; i<20; i++){
            Circle circle = (Circle) ShapeFactory.getCircle(getRandomColor());
            circle.setX(getRandomX());
            circle.setY(getRandomY());
            circle.setRadius(100);
            circle.draw();
        }
    }

    private static String getRandomColor(){
        return colors[(int)(Math.random()*colors.length)];
    }
    private static int getRandomX(){
        return (int)(Math.random()*100);
    }
    private static int getRandomY(){
        return (int) (Math.random()*100);
    }
}

5. 验证输出，结果如下

十三. 责任链模式

​ 返回目录

​ 顾名思义，责任链模式为请求创建一系列，此模式基于请求的类型将请求的发送和接收方分离，这种模式是行为模式。

​ 在这种模式中，通常每个接收器包含对另一个接收器的引用，如果一个对象不能处理请求，则它将相同的对象传递给下一个接收者。

1. 创建一个抽象记录类

// AbstractLogger.java
package pattern.chain;

public abstract class AbstractLogger {
    public static int INFO = 1;
    public static int DEBUG = 2;
    public static int ERROR = 3;

    protected int level;

    //next element in chain or responsibility
    protected AbstractLogger nextLogger;

    public void setNextLogger(AbstractLogger nextLogger) {
        this.nextLogger = nextLogger;
    }

    public void logMessage(int level, String message){
        if(this.level <= level){
            write(message);
        }
        if(nextLogger != null){
            nextLogger.logMessage(level, message);
        }
    }

    abstract protected void write(String message);
}

2. 创建几个扩展记录器的具体类

// ConsoleLogger.java
package pattern.chain;

public class ConsoleLogger extends AbstractLogger{
    @Override
    protected void write(String message) {
        System.out.println(":Standard Console::Logger: " + message);
    }

    public ConsoleLogger(int level) {
        this.level = level;
    }
}

// ErrorLogger.java
package pattern.chain;

public class ErrorLogger extends AbstractLogger{
    @Override
    protected void write(String message) {
        System.out.println("Error Console::Logger: " + message);
    }

    public ErrorLogger(int level) {
        this.level = level;
    }
}

// FilleLogger.java
package pattern.chain;

public class FileLogger extends AbstractLogger{
    @Override
    protected void write(String message) {
        System.out.println("File::Logger: " + message);
    }

    public FileLogger(int level) {
        this.level = level;
    }
}

3. 创建记录器

​ 创建不同类型的记录器，为它们分配错误级别，并在每个记录器中设置下一个记录器，每个记录器中的下一个记录器表示链的一部分。

// ChainPatternDemo.java
package pattern.chain;

public class ChainPatternDemo {
    private static AbstractLogger getChainOfLoggers() {

        AbstractLogger errorLogger = new ErrorLogger(AbstractLogger.ERROR);
        AbstractLogger fileLogger = new FileLogger(AbstractLogger.DEBUG);
        AbstractLogger consoleLogger = new ConsoleLogger(AbstractLogger.INFO);

        errorLogger.setNextLogger(fileLogger);
        fileLogger.setNextLogger(consoleLogger);

        return errorLogger;
    }

    public static void main(String[] args) {
        AbstractLogger loggerChain = getChainOfLoggers();

        loggerChain.logMessage(AbstractLogger.INFO, "This is an information");
        loggerChain.logMessage(AbstractLogger.DEBUG, "This is an debug level information");
        loggerChain.logMessage(AbstractLogger.ERROR, "This is an error information");
    }
}

4. 验证结果，输出如下

十四. 命令模式

​ 返回目录

​ 命令模式是数据驱动设计模式，属于行为模式类别。请求作为命令包装在一个对象下，并传递给调用器对象。调用者对象查找可以处理此命令的适当对象，并将命令传递到执行命令的响应对象。

1. 创建一个命令接口

// Order.java
package pattern.command;

public interface Order {
    void execute();
}

2. 创建一个请求对象

// Stock.java
package pattern.command;

public class Stock {
    private String name="ABC";
    private int quantity = 10;

    public void buy(){
        System.out.println("Stock [ Name: " + name + ", Quantity: " + quantity + " ] bought.");
    }

    public void sell(){
        System.out.println("Stock [ Name: " + name + ", Quantity: " + quantity + " ] sold.");
    }
}

3. 创建实现 Order 接口的具体类

// BuyStock.java
package pattern.command;

public class BuyStock implements Order{
    private Stock abcStock;

    public BuyStock(Stock abcStock) {
        this.abcStock = abcStock;
    }

    @Override
    public void execute() {
        abcStock.buy();
    }
}

// SellStock.java
package pattern.command;

public class SellStock implements Order{
    private Stock abcStock;

    public SellStock(Stock abcStock) {
        this.abcStock = abcStock;
    }

    @Override
    public void execute() {
        abcStock.sell();
    }
}

4. 创建命令调用程序类

// Broker.java
package pattern.command;

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

public class Broker {
    private List<Order> orderList = new ArrayList<Order>();

    public void takeOrder(Order order){
        orderList.add(order);
    }

    public void placeOrders(){
        for(Order order : orderList){
            order.execute();
        }
        orderList.clear();
    }
}

5. 使用 Broker 类来接收和执行命令

// CommandPatternDemo.java
package pattern.command;

public class CommandPatternDemo {
    public static void main(String[] args) {
        Stock abcStock = new Stock();

        BuyStock buyStockOrder = new BuyStock(abcStock);
        SellStock sellStockOrder = new SellStock(abcStock);

        Broker broker = new Broker();
        broker.takeOrder(buyStockOrder);
        broker.takeOrder(sellStockOrder);

        broker.placeOrders();
    }
}

6. 验证结果，输出如下

十五. 迭代器模式

​ 返回目录

​ 迭代器模式是 Java 和 .Net 编程环境中非常常用的设计模式。此模式 用于以顺序方式访问集合对象中的元素，而不需要知道其底层表示。

1. 创建两个简单的接口

// Iterator.java
package pattern.iterator;

public interface Iterator {
    public boolean hasNext();
    public Object next();
}

// Container.java
package pattern.iterator;

public interface Container {
    public Iterator getIterator();
}

2. 创建实现类接口

​ 创建实现 Container 接口的具体类。这个类有一个内部类 NameIterator,它实现了 Iterator接口。

// NameRepository.java
package pattern.iterator;

public class NameRepository implements Container{
    public String names[] = {"Robert", "John", "Julie", "Lora"};

    @Override
    public Iterator getIterator() {
        return new NameIterator();
    }

    private class NameIterator implements Iterator {

        int index;

        @Override
        public boolean hasNext() {
            if(index < names.length){
                return true;
            }
            return false;
        }

        @Override
        public Object next() {
            if(this.hasNext()){
                return names[index++];
            }
            return null;
        }
    }
}

3. 使用 NameRepository获取迭代器并打印其名称

// IteratorPatternDemo.java
package pattern.iterator;

public class IteratorPatternDemo {

    public static void main(String[] args) {
        NameRepository nameRepository = new NameRepository();

        for(Iterator iterator = nameRepository.getIterator(); iterator.hasNext();){
            String name = (String)iterator.next();
            System.out.println("Name : " + name);
        }
    }
}

4. 验证输出，结果如下

十六. 中介者模式

​ 返回目录

​ 中介者模式（Mediator Pattern）用于减少多个对象或类之间的通信复杂性，此模式提供了一个中介类，它通常处理不同类之间的所有通信，并支持通过

1. 创建一个聊天室类

// ChatRoom.java
package pattern.mediator;

import java.util.Date;

public class ChatRoom {
    public static void showMessage(User user, String message){
        System.out.println(new Date().toString() + " [" + user.getName() + "] : " + message);
    }
}

2. 创建一个用户类 User

// User.java
package pattern.mediator;

public class User {
    private String name;

    public String getName(){
        return name;
    }

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

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

    public void sendMessage(String message){
        ChatRoom.showMessage(this ,message);
    }
}

3. 使用 User 对象显示它们之间的通信

// MediatorPatternDemo.java
package pattern.mediator;

public class MediaPatternDemo {
    public static void main(String[] args) {
        User robert = new User("Robert");
        User john = new User("John");

        robert.sendMessage("Hi John!");
        john.sendMessage("Hello! Robert");
    }
}

4. 验证输出，结果如下

十七. 解释器模式

​ 返回目录

​ 解释器模式提供了一种评估计算语言语法或表达式的方法。这种类型的模式属于行为模式。这种模式设计实现一个表达式接口，它告诉解释一个指定的上下文，此模式用于 SQL 解析，符号处理引擎等。

1. 创建表达式接口

// Expression.java
package pattern.interpreter;

public interface Expression {
    public boolean interpret(String context);
}

2. 创建实现上述接口的具体类

// TerminalExpression.java
package pattern.interpreter;

public class TerminalExpression implements Expression{
    private String data;

    public TerminalExpression(String data) {
        this.data = data;
    }

    @Override
    public boolean interpret(String context) {
        if(context.contains(data)){
            return true;
        }
        return false;
    }
}

// OrExpression.java
package pattern.interpreter;

public class OrExpression implements Expression{
    private Expression expr1 = null;
    private Expression expr2 = null;

    public OrExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    @Override
    public boolean interpret(String context) {
        return false;
    }
}

// AndExpression.java
package pattern.interpreter;

public class AndExpression implements Expression{
    private Expression expr1 = null;
    private Expression expr2 = null;

    public AndExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }

    @Override
    public boolean interpret(String context) {
        return expr1.interpret(context) && expr2.interpret(context);
    }
}

3. 创建实例类

​ InterpreterPatternDemo 使用 Expression 类来创建规则，然后解析他们

// InterpreterPatternDeno.java
package pattern.interpreter;

public class InterpreterPatternDemo {

    // Rule: Robert and John are male
    public static Expression getMaleExpression(){
        Expression robert = new TerminalExpression("robert");
        Expression john = new TerminalExpression("john");
        return new OrExpression(robert, john);
    }

    // Rule: Julie is a married women
    public static Expression getMarriedWomenExpression(){
        Expression julie = new TerminalExpression("Julie");
        Expression married = new TerminalExpression("Married");
        return new AndExpression(julie, married);
    }

    public static void main(String[] args) {
        Expression isMale = getMaleExpression();
        Expression isMarriedWomen = getMarriedWomenExpression();

        System.out.println("John is male? " + isMale.interpret("John"));
        System.out.println("Julie is a married women? " + isMarriedWomen.interpret("Married Julie"));
    }
}

4. 验证输出，结果如下

十八. 备忘录模式

​ 返回目录

​ 备忘录模式（Memento Pattern）用来恢复一个对象的状态到以前的状态，备忘录模式下属于行为模式的类别。

1. 创建一个 Memento 类

// Memento.java
package pattern.memento;

public class Memento {
    private String state;

    public Memento(String state) {
        this.state = state;
    }

    public String getState() {
        return state;
    }
}

2. 创建一个 Originator 类

// Originator.java
package pattern.memento;

public class Originator {
    private String state;

    public String getState() {
        return state;
    }

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

    public Memento saveStateToMemento(){
        return new Memento(state);
    }

    public void getStateFromMemento(Memento memento){
        state = memento.getState();
    }
}

3. 创建一个 CareTaker 类

// CareTaker.java
package pattern.memento;

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

public class CareTaker {
    private List<Memento> mementoList = new ArrayList<Memento>();

    public void add(Memento state){
        mementoList.add(state);
    }

    public Memento get(int index){
        return mementoList.get(index);
    }
}

4. 创建示例类

// MementoPatternDemo.java
package pattern.memento;

public class MementoPatternDemo {
    public static void main(String[] args) {

        Originator originator = new Originator();
        CareTaker careTaker = new CareTaker();

        originator.setState("State #1");
        originator.setState("State #2");
        careTaker.add(originator.saveStateToMemento());

        originator.setState("State #3");
        careTaker.add(originator.saveStateToMemento());

        originator.setState("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());
    }
}

5. 验证输出，结果如下

十九. 观察者模式

​ 返回目录

​ 观察者模式在对象之间存在一对多关系式使用，例如，如果一个对象被修改，它的依赖对象被自动通知。观察者模式属于行为模式类别。

1. 创建一个 Subject 类

// Subject.java
package pattern.observer;

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

public class Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    private int state;

    public int getState(){
        return state;
    }

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

    public void attach(Observer observer){
        observers.add(observer);
    }

    public void notifyAllObserver(){
        for(Observer observer : observers){
            observer.update();
        }
    }
}

2. 创建一个 Observer 类

// Observer.java
package pattern.observer;

public abstract class Observer {
    protected Subject subject;
    public abstract void update();
}

3. 创建具体的观察者类

// BinaryObserver.java
package pattern.observer;

public class BinaryObserver extends Observer{
    public BinaryObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Binary String: " + Integer.toBinaryString(subject.getState()));
    }
}

// OctalObserver.java
package pattern.observer;

public class OctalObserver extends Observer{

    public OctalObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Octal String: " + Integer.toOctalString(subject.getState()));
    }
}

// HexaObserver.java
package pattern.observer;

public class HexaObserver extends Observer{

    public HexaObserver(Subject subject){
        this.subject = subject;
        this.subject.attach(this);
    }

    @Override
    public void update() {
        System.out.println("Hex String: " + Integer.toHexString(subject.getState()).toUpperCase());
    }
}

4. 使用 Subject 和具体的观察者对象

// ObserverPatternDemo.java
package pattern.observer;

public class ObserverPatternDemo {
    public static void main(String[] args) {
        Subject subject = new Subject();

        new HexObserver(subject);
        new OctalObserver(subject);
        new BinaryObserver(subject);

        System.out.println("First state change: 15");
        subject.setState(15);
        System.out.println("Second state change: 10");
        subject.setState(10);
    }
}

5. 验证输出，结果如下

二十. 状态模式

​ 返回目录

​ 在状态模式中，类行为根据其状态而改变，这种设计模式属于行为模式。

​ 在状态模式中，我们创建表示各种状态的对象，以及随状态对象变化而行为变化的上下文对象。

1. 创建一个接口

// State.java
package pattern.state;

public interface State {
    public void doAction(Context context);
}

2. 创建实现相同接口的具体类

// StartState.java
package pattern.state;

public class StartState implements State{

    @Override
    public void doAction(Context context) {
        System.out.println("Player is in start state");
        context.setState(this);
    }

    public String toString(){
        return "Start State";
    }
}

// StopState.java
package pattern.state;

public class StopState implements State{
    @Override
    public void doAction(Context context) {
        System.out.println("Player is in stop state");
        context.setState(this);
    }

    public String toString(){
        return "Stop State";
    }
}

3. 创建 Context 类

// Context.java
package pattern.state;

public class Context {
    private State state;

    public Context() {
        state = null;
    }

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

    public State getState() {
        return state;
    }
}

4. 使用 Context 查看状态更改时的行为更改

// StatePatternDemo.java
package pattern.state;

public class StatePatternDemo {
    public static void main(String[] args) {
        Context context = new Context();

        StartState startState = new StartState();
        startState.doAction(context);

        System.out.println(context.getState().toString());

        StopState stopState = new StopState();
        stopState.doAction(context);

        System.out.println(context.getState().toString());
    }
}

5. 验证结果，输出如下

廿一. 空对象模式

​ 返回目录
未完。。。

​