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. 验证结果，输出如下

输出结果

廿一. 空对象模式

返回目录
未完。。。