23种设计模式

女爷i 2024-03-23 16:09 27阅读 0赞

#### 本次主要是对23中设计模式的一次记录,有些去掉了注释把所有方法放在了一个代码块中,这样也是在拿出来自己练习的时候起个加强记忆的作用 ####

*  介绍
 *   *  1. 单例（Singleton）模式
     *  2. 工厂方法（Factory Method）模式
     *  3. 抽象工厂（Abstract Factory）模式
     *  4. 原型模式（Prototype Pattern）
     *  5. 建造者（Builder）模式
     *  6. 适配器（Adapter）模式
     *  7. 桥接（Bridge）模式
     *  8. 过滤器（Filter）模式
     *  9. 组合（Composite）模式
     *  10. 装饰（Decorator）模式
     *  11. 外观（Facade）模式
     *  12. 享元（Flyweight）模式
     *  13. 代理（Proxy）模式
     *  14. 责任链（Chain of Responsibility）模式
     *  15. 命令（Command）模式
     *  16. 解释器（Interpreter）模式
     *  17. 迭代器（Iterator）模式
     *  18. 中介者（Mediator）模式
     *  19. 备忘录（Memento）模式
     *  20. 观察者（Observer）模式
     *  21. 访问者（Visitor）模式
     *  22. 策略（Strategy）模式
     *  23. 模板方法（Template Method）模式

## 介绍 ##

Java的23种设计模式是一组指导设计方案的模样，这些模样已经被证明在开发Java应用程序时非常有效。这些设计模式可以帮助开发人员遵循最佳实践，并在处理各种问题时提供可重用的解决方案。  
 这些模式分为3类：创建型模式，结构型模式和行为模式。

*  创建型模式与对象的创建相关，帮助我们管理对象的创建方式。
 *  结构型模式帮助我们定义组件间的关系，使得不同的组件可以协同工作，交换信息。
 *  行为模式则关注对象之间的交互和职责分配。

这些设计模式的主要意义是，它们提供了一些灵活的，经过考验的，深入研究的解决方案，可以帮助开发人员更好地理解Java代码，并以更好的形式组织他们的代码，从而使代码更加可重用，可维护和可扩展。它们已经被广泛应用于许多Java应用程序领域，包括企业级应用程序，桌面应用程序，游戏应用程序以及移动设备应用程序。

### 1. 单例（Singleton）模式 ###

单例模式是指只允许一个实例化对象存在的模式。这种模式通常用于控制资源的共享，例如全局配置。

public class Singleton {
        
        private static Singleton instance;
        private Singleton() {
        }
        public static synchronized Singleton getInstance(){
        
            if(instance == null){
        
                instance = new Singleton();
            }
            return instance;
        }
    }

### 2. 工厂方法（Factory Method）模式 ###

工厂模式是一种创建型模式，提供一个创建对象的接口，但由子类决定要实例化对象的类是哪一个。这种模式可以将具体的类解耦合。

### 3. 抽象工厂（Abstract Factory）模式 ###

抽象工厂模式是一种创建型模式，提供一个创建对象的接口，可以创建一组相关或相互依赖的对象，而无需指定它们的具体类。

public interface Shape {
        
        void draw();
    }
    
    public class Rectangle implements Shape {
        
        @Override
        public void draw() {
        
            System.out.println("Draw Rectangle");    
        }
    }
    
    public class Circle implements Shape {
        
        @Override
        public void draw() {
        
            System.out.println("Draw Circle");    
        }
    }
    
    public interface AbstractFactory {
        
        Shape getShape(String shapeType);
    }
    
    public class ShapeFactory implements AbstractFactory {
        
        @Override
        public Shape getShape(String shapeType){
        
            if(shapeType == null){
        
                return null;
            }        
            if(shapeType.equalsIgnoreCase("Rectangle")){
        
                return new Rectangle();            
            } else if(shapeType.equalsIgnoreCase("Circle")){
        
                return new Circle();
            } 
            return null;
        }
    }
    
    public class Factory {
        
        public static AbstractFactory getFactory(String factoryType){
        
            if(factoryType.equalsIgnoreCase("SHAPE")){
        
                return new ShapeFactory();        
            }
            return null;
        }
    }

### 4. 原型模式（Prototype Pattern） ###

原型模式是一种创建型设计模式，它允许通过克隆现有的对象来创建新对象，而不是使用构造函数创建。它通常用于创建复杂的对象，因为复制现有对象比创建一个新对象更加高效。

public abstract class Shape implements Cloneable {
        
        private String id;
        protected String type;
    
        public String getId() {
        
            return id;
        }
    
        public void setId(String id) {
        
            this.id = id;
       }
    
        public String getType() {
        
            return type;
        }
    
        public void setType(String type) {
        
            this.type = type;
        }
    
        public abstract void draw();
    
        @Override
        public Object clone() {
        
            Object clone = null;
            try {
        
                clone = super.clone();
            } catch (CloneNotSupportedException e) {
        
                e.printStackTrace();
            }
            return clone;
        }
    }
    
    public class Rectangle extends Shape {
        
        public Rectangle() {
        
            type = "Rectangle";
        }
    
        @Override
        public void draw() {
        
            System.out.println("Inside Rectangle::draw() method.");
        }
    }
    
    public class Square extends Shape {
        
        public Square() {
        
            type = "Square";
        }
    
        @Override
        public void draw() {
        
            System.out.println("Inside Square::draw() method.");
        }
    }
    
    public class Circle extends Shape {
        
        public Circle() {
        
            type = "Circle";
        }
    
        @Override
        public void draw() {
        
            System.out.println("Inside Circle::draw() method.");
        }
    }
    
    public class ShapeCache {
        
        private static HashMap<String, Shape> shapeMap = new HashMap<>();
    
        public static Shape getShape(String shapeId) {
        
            Shape cachedShape = shapeMap.get(shapeId);
            return (Shape) cachedShape.clone();
        }
    
        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);
        }
    }
    
    public class PrototypePatternDemo {
        
        public static void main(String[] args) {
        
            ShapeCache.loadCache();
    
            Shape clonedShape = (Shape) ShapeCache.getShape("1");
            System.out.println("Shape : " + clonedShape.getType());
    
            Shape clonedShape2 = (Shape) ShapeCache.getShape("2");
            System.out.println("Shape : " + clonedShape2.getType());
    
            Shape clonedShape3 = (Shape) ShapeCache.getShape("3");
            System.out.println("Shape : " + clonedShape3.getType());
        }
    }

### 5. 建造者（Builder）模式 ###

建造者模式是一种创建型模式，将复杂对象的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。

public class House {
        
        private String foundation;
        private String walls;
        private String roof;
        public String getFoundation() {
         return foundation; }
        public void setFoundation(String foundation) {
         this.foundation = foundation; }
        public String getWalls() {
         return walls; }
        public void setWalls(String walls) {
         this.walls = walls; }
        public String getRoof() {
         return roof; }
        public void setRoof(String roof) {
         this.roof = roof; }  
    }
    
    public abstract class HouseBuilder {
        
        protected House house;
        public House getHouse() {
         return house; }
        public void createHouse() {
         house = new House(); }
        public abstract void buildFoundation();
        public abstract void buildWalls();
        public abstract void buildRoof();
    }
    
    public class RockyHouseBuilder extends HouseBuilder {
        
        public void buildFoundation() {
         house.setFoundation("Rocky Foundation"); }
        public void buildWalls() {
         house.setWalls("Rocky Walls"); }
        public void buildRoof() {
         house.setRoof("Rocky Roof"); }
    }
    
    public class PlainHouseBuilder extends HouseBuilder {
        
        public void buildFoundation() {
         house.setFoundation("Plain Foundation"); }
        public void buildWalls() {
         house.setWalls("Plain Walls"); }
        public void buildRoof() {
         house.setRoof("Plain Roof"); }
    }
    
    public class Director {
        
        private HouseBuilder houseBuilder;
        public void setHouseBuilder(HouseBuilder houseBuilder) {
         this.houseBuilder = houseBuilder; }
        public House getHouse() {
         return houseBuilder.getHouse(); }
        public void constructHouse() {
        
            houseBuilder.createHouse();
            houseBuilder.buildFoundation();
            houseBuilder.buildWalls();
            houseBuilder.buildRoof();
        }
    }

### 6. 适配器（Adapter）模式 ###

适配器模式是一种结构型模式，将一个类的接口转化成客户希望的另一个接口，使之相互兼容。

public interface MediaPlayer {
        
        void play(String audioType, String fileName);
    }
    
    public interface AdvancedMediaPlayer {
        
        void playVlc(String fileName);
        void playMp4(String fileName);
    }
    
    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) {
        }
    }
    
    public class Mp4Player implements AdvancedMediaPlayer{
        
        @Override
        public void playVlc(String fileName) {
        }
    
        @Override
        public void playMp4(String fileName) {
         System.out.println("Playing mp4 file. Name: "+ fileName); }
    }
    
    public class MediaAdapter implements MediaPlayer {
        
        AdvancedMediaPlayer advancedMusicPlayer;
        public MediaAdapter(String audioType){
        
            if(audioType.equalsIgnoreCase("vlc") ){
        
                advancedMusicPlayer = new VlcPlayer();            
            } else if (audioType.equalsIgnoreCase("mp4")){
        
                advancedMusicPlayer = new Mp4Player();
            }  
        }
        @Override
        public void play(String audioType, String fileName) {
        
            if(audioType.equalsIgnoreCase("vlc")){
        
                advancedMusicPlayer.playVlc(fileName);
            }else if(audioType.equalsIgnoreCase("mp4")){
        
                advancedMusicPlayer.playMp4(fileName);
            }
        }
    }
    
    public class AudioPlayer implements MediaPlayer {
        
        MediaAdapter mediaAdapter;
        @Override
        public void play(String audioType, String fileName) {
            
            if(audioType.equalsIgnoreCase("mp3")){
        
                System.out.println("Playing mp3 file. Name: "+ fileName); 
            } else if(audioType.equalsIgnoreCase("vlc") || audioType.equalsIgnoreCase("mp4")){
        
                mediaAdapter = new MediaAdapter(audioType);
                mediaAdapter.play(audioType, fileName);
            } else {
        
                System.out.println("Invalid media. "+ audioType + " format not supported");
            }
        }
    }

### 7. 桥接（Bridge）模式 ###

桥接模式是一种结构型设计模式，用于将抽象部分与其实现部分分离，以便它们可以独立进行修改、扩展和重用。它通过将抽象类与其实现类分离来实现这一目标，从而允许它们能够独立地变化，而不会相互影响。

public interface DrawAPI {
        
        public void drawCircle(int radius, int x, int y);
    }
    
    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 + "]");
        }
    }
    
    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 + "]");
        }
    }
    
    public abstract class Shape {
        
        protected DrawAPI drawAPI;
    
        protected Shape(DrawAPI drawAPI){
        
            this.drawAPI = drawAPI;
        }
    
        public abstract void draw();
    }
    
    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);
        }
    }
    
    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();
        }
    }

### 8. 过滤器（Filter）模式 ###

过滤器模式是一种结构型设计模式，它充分利用了OOP的组合原则，通过一系列过滤规则来过滤数据流中的数据。

在这个设计模式中，我们创建一个过滤器链，可以在数据流中添加多个过滤器，然后将数据流推送至过滤器链中，最终过滤出我们需要的数据。

在实际应用中，过滤器模式可以被用于各种场景，比如数据过滤、安全认证、事件处理等等。

代码示例:

我们定义一个Filter接口，其中包括一个process方法，方法返回一个过滤后的结果。

public interface Filter {
        
        String process(String request);
    }

然后我们实现两个具体的过滤器：HTMLFilter和SensitiveFilter。

public class HTMLFilter implements Filter {
        
        public String process(String request) {
        
    		// 将request中的<、>等HTML字符转义
            String result = request.replaceAll("<", "<").replaceAll(">", ">");
            return result;
        }
    }
    
    public class SensitiveFilter implements Filter {
        
        public String process(String request) {
        
    		// 将request中的敏感词替换成***
            String result = request.replaceAll("敏感词", "***").replaceAll("其他敏感词", "***");
            return result;
        }
    }

接下来我们实现过滤器链类FilterChain，其中包括一个过滤器列表和一个execute方法。

public class FilterChain {
        
        private List<Filter> filters = new ArrayList<Filter>();
    
        public FilterChain addFilter(Filter filter) {
        
            filters.add(filter);
            return this;
        }
    
        public String execute(String request) {
        
            for (Filter filter : filters) {
        
                request = filter.process(request);
            }
            return request;
        }
    }

最后我们写一个Test类进行测试。

public class Test {
        
        public static void main(String[] args) {
        
            String request = "敏感词数据<script>";
            String result = new FilterChain()
                    .addFilter(new HTMLFilter())
                    .addFilter(new SensitiveFilter())
                    .execute(request);
            System.out.println("request content: " + request);
            System.out.println("filtered content: " + result);
        }
    }

输出结果为：

request content: 敏感词数据<script>
    filtered content: ***数据<script>

### 9. 组合（Composite）模式 ###

组合模式是一种结构型设计模式，它可以将对象组合成树形结构，以表示“整体-部分”的关系，同时也使得用户对单个对象和组合对象的使用具有一致性。

在这个设计模式中，我们定义了一个抽象类Component作为组合对象的基类，其中包含了一个添加、删除以及获取子节点的方法。然后我们实现了两个具体的子类：Leaf和Composite。其中Leaf表示树的叶子节点，而Composite表示树的枝干节点。

在实际应用中，组合模式广泛应用于部件组合、文件系统、界面控件等等。

示例代码

我们定义了一个抽象类Component来表示组合对象，其中包含了三个方法：add、remove、getChild。

public abstract class Component {
        
        protected String name;
    
        public Component(String name) {
        
            this.name = name;
        }
    
        public abstract void add(Component component);
    
        public abstract void remove(Component component);
    
        public abstract Component getChild(int index);
    }

然后我们实现了两个具体的组件类：Leaf和Composite。

public class Leaf extends Component {
        
        public Leaf(String name) {
        
            super(name);
        }
    
        public void add(Component component) {
        
    // Leaf节点不支持添加操作
        }
    
        public void remove(Component component) {
        
    // Leaf节点不支持删除操作
        }
    
        public Component getChild(int index) {
        
    // Leaf节点不支持获取子节点操作
            return null;
        }
    
        public void operation() {
        
            System.out.println("Leaf " + name + " operation...");
        }
    }
    
    public class Composite extends Component {
        
        private List<Component> children = new ArrayList<Component>();
    
        public Composite(String name) {
        
            super(name);
        }
    
        public void add(Component component) {
        
            children.add(component);
        }
    
        public void remove(Component component) {
        
            children.remove(component);
        }
    
        public Component getChild(int index) {
        
            return children.get(index);
        }
    
        public void operation() {
        
            System.out.println("Composite " + name + " operation...");
            for (Component component : children) {
        
                component.operation();
            }
        }
    }

最后我们可以通过如下代码来创建一颗树形结构。

public class Test {
        
        public static void main(String[] args) {
        
            Component root = new Composite("root");
            Component node1 = new Composite("node1");
            Component node2 = new Composite("node2");
            Component leaf1 = new Leaf("leaf1");
            Component leaf2 = new Leaf("leaf2");
            Component leaf3 = new Leaf("leaf3");
    
            root.add(node1);
            root.add(node2);
            root.add(leaf1);
    
            node1.add(leaf2);
            node2.add(leaf3);
    
            root.operation();
        }
    }

输出结果为：

Composite root operation...
    Composite node1 operation...
    Leaf leaf2 operation...
    Composite node2 operation...
    Leaf leaf3 operation...
    Leaf leaf1 operation...

### 10. 装饰（Decorator）模式 ###

装饰模式是一种结构型设计模式，它允许在运行时动态地扩展一个对象的功能，同时不修改已经存在的代码。这种模式是通过继承实现的，这样可以使用已经存在的类而不需要修改代码。

装饰模式的核心思想是，将装饰的行为放置在装饰类中，而不是在被装饰的类中。装饰类和被装饰的类均继承自同一个基类。

实现装饰模式需要以下组件：

*  抽象构件：被装饰对象的抽象接口或类
 *  具体构件：实现抽象构件接口或继承抽象构件类的类
 *  抽象装饰器：继承抽象构件，并且包含一个指向抽象构件的引用
 *  具体装饰器：继承抽象装饰器，并实现抽象装饰器的方法

示例代码：

// 抽象构件

public interface Component {
        
        public void operation();
    }

// 具体构件

public class ConcreteComponent implements Component {
        
        public void operation() {
        
            System.out.println("ConcreteComponent.operation()");
        }
    }

// 抽象装饰器

public abstract class Decorator implements Component {
        
        protected Component component;
    
        public Decorator(Component component) {
        
            this.component = component;
        }
    
        public void operation() {
        
            component.operation();
        }
    }

// 具体装饰器

public class ConcreteDecorator extends Decorator {
        
        public ConcreteDecorator(Component component) {
        
            super(component);
        }
    
        public void operation() {
        
            super.operation();
            addedBehavior();
        }
    
        public void addedBehavior() {
        
            System.out.println("ConcreteDecorator.addedBehavior()");
        }
    }

// 客户端代码

Component component = new ConcreteComponent();
            component = new ConcreteDecorator(component);
            component.operation();

//输出：

ConcreteComponent.operation() ConcreteDecorator.addedBehavior()

### 11. 外观（Facade）模式 ###

外观模式是一种结构型设计模式，它允许简化复杂系统的访问。外观模式为系统中的子系统提供了一个单一的接口。

外观模式是通过创建一个简单的接口，来隐藏复杂系统的实现细节的。它通过将客户端与子系统解耦来提高子系统的可维护性和可扩展性。

实现外观模式需要以下组件：

*  子系统：所有需要被访问的类和方法
 *  外观类：封装子系统的简单接口

示例代码：  
//定义 子系统 A B C

public class SubSystemA {
        
        public void methodA() {
        
            System.out.println("SubSystemA.methodA()");
        }
    }
    
    public class SubSystemB {
        
        public void methodB() {
        
            System.out.println("SubSystemB.methodB()");
        }
    }
    
    public class SubSystemC {
        
        public void methodC() {
        
            System.out.println("SubSystemC.methodC()");
        }
    }

// 外观类

public class Facade {
        
        private SubSystemA subSystemA;
        private SubSystemB subSystemB;
        private SubSystemC subSystemC;
    
        public Facade() {
        
            subSystemA = new SubSystemA();
            subSystemB = new SubSystemB();
            subSystemC = new SubSystemC();
        }
    
        public void method() {
        
            subSystemA.methodA();
            subSystemB.methodB();
            subSystemC.methodC();
        }
    }

// 客户端代码

Facade facade = new Facade();
            facade.method();

输出：

SubSystemA.methodA() SubSystemB.methodB() SubSystemC.methodC()

### 12. 享元（Flyweight）模式 ###

享元模式是一种结构型设计模式，它通过使用共享对象来减少内存的使用和提高性能。

享元模式的核心思想是，将一些独立的对象共享在多个对象之间，而不是在每个对象中创建一个对象。这样可以减少内存的使用，同时提高性能。

实现享元模式需要以下组件：

*  抽象享元：享元对象的抽象接口或类
 *  具体享元：实现抽象享元接口或继承抽象享元类的类
 *  享元工厂：维护享元对象的池，用于创建和存储对象

示例代码：

// 抽象享元

public interface Flyweight {
        
      public void operation();
    }

// 具体享元

public class ConcreteFlyweight implements Flyweight {
        
      private String intrinsicState;
    
      public ConcreteFlyweight(String intrinsicState) {
        
        this.intrinsicState = intrinsicState;
      }
    
      public void operation() {
        
        System.out.println("ConcreteFlyweight.operation(): " + intrinsicState);
      }
    }

// 享元工厂

public class FlyweightFactory {
        
        private Map<String, Flyweight> flyweights = new HashMap<>();
    
        public Flyweight getFlyweight(String key) {
        
            if (flyweights.containsKey(key)) {
        
                return flyweights.get(key);
            } else {
        
                Flyweight flyweight = new ConcreteFlyweight(key);
                flyweights.put(key, flyweight);
                return flyweight;
            }
        }
    }

// 客户端代码

FlyweightFactory flyweightFactory = new FlyweightFactory();
            Flyweight flyweight1 = flyweightFactory.getFlyweight("key1");
            flyweight1.operation();
            Flyweight flyweight2 = flyweightFactory.getFlyweight("key2");
            flyweight2.operation();
            Flyweight flyweight3 = flyweightFactory.getFlyweight("key1");
            flyweight3.operation();

输出：

ConcreteFlyweight.operation(): key1 ConcreteFlyweight.operation(): key2 ConcreteFlyweight.operation(): key1

### 13. 代理（Proxy）模式 ###

代理模式是一种结构型设计模式，它可以为其他对象提供一种代理以控制对这个对象的访问。在代理模式中，我们创建具有原始对象相同接口的对象，以便代替原始对象的使用。

在代理模式中，客户端不直接访问实际对象，而是使用代理对象。代理对象充当客户端和实际对象之间的中介，它负责向真实对象转发客户端请求，并在此之前或之后执行某些操作（如验证、日志记录等）。

示例代码：

//代理

public interface Image {
        
        void display();
    }

//被代理对象A

public class RealImage implements Image {
        
        private String fileName;
    
        public RealImage(String fileName) {
        
            this.fileName = fileName;
            loadFromDisk(fileName);
        }
    
        @Override
        public void display() {
        
            System.out.println("Displaying " + fileName);
        }
    
        private void loadFromDisk(String fileName) {
        
            System.out.println("Loading " + fileName);
        }
    }

//被代理对象B

public class ProxyImage implements Image {
        
        private RealImage realImage;
        private String fileName;
    
        public ProxyImage(String fileName) {
        
            this.fileName = fileName;
        }
    
        @Override
        public void display() {
        
            if(realImage == null) {
        
                realImage = new RealImage(fileName);
            }
            realImage.display();
        }
    }

//客户端代码

public class ProxyPatternDemo {
        
        public static void main(String[] args) {
        
            Image image = new ProxyImage("test.jpg");
    
            image.display();
            System.out.println("");
    
            image.display();
        }
    }

### 14. 责任链（Chain of Responsibility）模式 ###

责任链模式是一种行为型设计模式，它建立了一个对象链，每个对象都持有对下一个对象的引用，这样就可以顺序地将请求依次传递下去，直到有一个对象可以处理这个请求。

在责任链模式中，每个节点都有一个处理的方法，当请求到达当前节点时，如果当前节点能够处理这个请求，那么就直接处理；如果不能处理，则将请求传递给下一个节点，直到请求得到处理或者最后一个节点都不能处理为止。

示例代码：

public abstract class AbstractLogger {
        
        public static int INFO = 1;
        public static int DEBUG = 2;
        public static int ERROR = 3;
    
        protected int level;
    
        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);
    }
    
    public class ConsoleLogger extends AbstractLogger {
        
    
        public ConsoleLogger(int level){
        
            this.level = level;
        }
    
        @Override
        protected void write(String message) {
        
            System.out.println("Standard Console::Logger: " + message);
        }
    }
    
    public class ErrorLogger extends AbstractLogger {
        
    
        public ErrorLogger(int level){
        
            this.level = level;
        }
    
        @Override
        protected void write(String message) {
        
            System.out.println("Error Console::Logger: " + message);
        }
    }
    
    public class FileLogger extends AbstractLogger {
        
    
        public FileLogger(int level){
        
            this.level = level;
        }
    
        @Override
        protected void write(String message) {
        
            System.out.println("File::Logger: " + message);
        }
    }
    
    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 a debug level information.");
    
            loggerChain.logMessage(AbstractLogger.ERROR,
                    "This is an error information.");
        }
    }

### 15. 命令（Command）模式 ###

命令模式是一种行为型设计模式，它允许你将操作转化为一个对象，这个对象可以将其它对象依次执行一些操作。命令模式的重点在于将请求者和执行者解耦。

在命令模式中，每个操作带有一个命令对象，这个命令对象包含了如何执行这个操作的细节。之后，命令对象就可以被序列化或存储，以便之后执行或者撤销这个操作。

示例代码：

public interface Order {
        
        void execute();
    }
    
    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");
        }
    }
    
    public class BuyStock implements Order {
        
        private Stock abcStock;
    
        public BuyStock(Stock abcStock){
        
            this.abcStock = abcStock;
        }
    
        public void execute() {
        
            abcStock.buy();
        }
    }
    
    public class SellStock implements Order {
        
        private Stock abcStock;
    
        public SellStock(Stock abcStock){
        
            this.abcStock = abcStock;
        }
    
        public void execute() {
        
            abcStock.sell();
        }
    }
    
    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();
        }
    }
    
    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();
        }
    }

### 16. 解释器（Interpreter）模式 ###

解释器模式是一种行为设计模式，它给定一个语言并定义它的语法表示，然后使用该语法表示解释语言中的语句。

实现方式：定义表达式类，并实现抽象表达式接口，每个表达式可以是终端表达式（Terminal Expression）或非终端表达式（Nonterminal Expression），然后定义上下文环境(Context)来存储数据。

示例代码：

// 抽象表达式接口

public interface Expression {
        
        int interpret(Context context);
    }

// 具体终端表达式类

public class TerminalExpression implements Expression {
        
    
        @Override
        public int interpret(Context context) {
        
            return context.getValue();
        }
    }

// 具体非终端表达式类

public class AddExpression implements Expression {
        
        private Expression left;
        private Expression right;
    
        public AddExpression(Expression left, Expression right) {
        
            this.left = left;
            this.right = right;
        }
    
        @Override
        public int interpret(Context context) {
        
            return left.interpret(context) + right.interpret(context);
        }
    }

// 上下文环境类

public class Context {
        
        private int value;
    
        public Context(int value) {
        
            this.value = value;
        }
    
        public int getValue() {
        
            return value;
        }
    
        public void setValue(int value) {
        
            this.value = value;
        }
    }

// 测试类

public class InterpreterTest {
        
        public static void main(String[] args) {
        
            Context context = new Context(10);
            TerminalExpression terminal = new TerminalExpression();
            int result = terminal.interpret(context);
            System.out.println("终端表达式计算结果：" + result);
    
            Expression add = new AddExpression(new TerminalExpression(), new TerminalExpression());
            result = add.interpret(context);
            System.out.println("非终端表达式计算结果：" + result);
        }
    }

### 17. 迭代器（Iterator）模式 ###

迭代器模式是一种行为设计模式，它提供一种访问集合对象元素的方法，而不暴露集合对象的内部表示。

实现方式：定义抽象迭代器接口，提供访问集合元素的方法，然后定义集合类，并实现创建迭代器的方法。在客户端中通过获取迭代器对象，来对集合进行操作。

示例代码：

// 抽象迭代器接口

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

// 具体迭代器类

public class ConcreteIterator implements Iterator {
        
        private List<Object> list = new ArrayList<>();
        private int index = 0;
    
        public ConcreteIterator(List<Object> list) {
        
            this.list = list;
        }
    
        @Override
        public boolean hasNext() {
        
            if (index < list.size()) {
        
                return true;
            }
            return false;
        }
    
        @Override
        public Object next() {
        
            if (hasNext()) {
        
                return list.get(index++);
            }
            return null;
        }
    }

// 集合类

public class Aggregate {
        
        private List<Object> list = new ArrayList<>();
    
        public Iterator createIterator() {
        
            return new ConcreteIterator(list);
        }
    
        public void addObject(Object obj) {
        
            list.add(obj);
        }
    
        public void removeObject(Object obj) {
        
            list.remove(obj);
        }
    }

// 测试类
    public class IteratorTest {
        
        public static void main(String[] args) {
        
            Aggregate aggregate = new Aggregate();
            aggregate.addObject("obj1");
            aggregate.addObject(2);
            aggregate.addObject(true);
    
            Iterator iterator = aggregate.createIterator();
            while (iterator.hasNext()) {
        
                System.out.println(iterator.next());
            }
        }
    }

### 18. 中介者（Mediator）模式 ###

中介者模式是一种行为设计模式，它用于降低类之间的耦合性，把多个对象间的交互行为封装到一个中介者对象中，从而使各个对象间的交互关系变为一对多的关系。

实现方式：定义抽象中介者接口，每个具体中介者类可以管理同事类的信息，在同事类间传递消息和调用方法。具体同事类实现收发消息的方法，并实现抽象同事类接口，把自己注册到中介者对象中。

示例代码：

// 抽象同事类接口

public interface Colleague {
        
        void register(Mediator mediator);
        void receive(String message);
        void send(String message);
    }

// 抽象中介者接口

public interface Mediator {
        
        void register(Colleague colleague);
        void relay(Colleague colleague, String message);
    }

// 具体同事类

public class ConcreteColleague implements Colleague {
        
        private Mediator mediator;
        private String name;
    
        public ConcreteColleague(String name) {
        
            this.name = name;
        }
    
        @Override
        public void register(Mediator mediator) {
        
            this.mediator = mediator;
            mediator.register(this);
        }
    
        @Override
        public void receive(String message) {
        
            System.out.println(name + "收到消息：" + message);
        }
    
        @Override
        public void send(String message) {
        
            mediator.relay(this, message);
        }
    }

// 具体中介者类

public class ConcreteMediator implements Mediator {
        
        private List<Colleague> colleagues = new ArrayList<>();
    
        @Override
        public void register(Colleague colleague) {
        
            if (!colleagues.contains(colleague)) {
        
                colleagues.add(colleague);
            }
        }
    
        @Override
        public void relay(Colleague colleague, String message) {
        
            for (Colleague c : colleagues) {
        
                if (!c.equals(colleague)) {
        
                    c.receive(message);
                }
            }
        }
    }

// 测试类
    public class MediatorTest {
        
        public static void main(String[] args) {
        
            Mediator mediator = new ConcreteMediator();
    
            Colleague colleague1 = new ConcreteColleague("同事1");
            Colleague colleague2 = new ConcreteColleague("同事2");
            Colleague colleague3 = new ConcreteColleague("同事3");
    
            // 同事类注册到中介者对象
            colleague1.register(mediator);
            colleague2.register(mediator);
            colleague3.register(mediator);
    
            colleague1.send("大家好");
            colleague2.send("我是同事2");
        }
    }

### 19. 备忘录（Memento）模式 ###

备忘录模式是一种行为型设计模式，它允许在不暴露对象实现细节的情况下捕获和恢复其内部状态。可以将对象状态保存在历史记录中，以便在需要时可以轻松地撤消操作或还原状态。

示例代码：

//备忘录类

public class Memento {
        
        private String state;
    
        public Memento(String state) {
        
            this.state = state;
        }
    
        public String getState() {
        
            return state;
        }
    }

//原始类

public class Originator {
        
        private String state;
    
        public void setState(String state) {
        
            this.state = state;
        }
    
        public String getState() {
        
            return state;
        }
    
        //保存状态到备忘录
        public Memento saveStateToMemento() {
        
            return new Memento(state);
        }
    
        //从备忘录中恢复状态
        public void getStateFromMemento(Memento memento) {
        
            state = memento.getState();
        }
    }

//负责备忘录的对象类

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

//测试代码

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

### 20. 观察者（Observer）模式 ###

观察者模式是一种行为型设计模式，其中一个对象（主题）维护其依赖项（观察者）列表，并在状态发生改变时自动通知它们。观察者模式可以轻松地实现松散耦合，因为主题仅知道其观察者列表，而不需要了解其观察者的具体实现。

下面是观察者模式的实现代码：

//主题接口

public interface Subject {
        
        public void registerObserver(Observer o);
        public void removeObserver(Observer o);
        public void notifyObservers();
    }

//观察者接口

public interface Observer {
        
        public void update(float temp, float humidity, float pressure);
    }

//主题类

public class WeatherData implements Subject {
        
        private ArrayList<Observer> observers;
        private float temperature;
        private float humidity;
        private float pressure;
    
        public WeatherData() {
        
            observers = new ArrayList<Observer>();
        }
    
        public void registerObserver(Observer o) {
        
            observers.add(o);
        }
    
        public void removeObserver(Observer o) {
        
            int i = observers.indexOf(o);
            if (i >= 0) {
        
                observers.remove(i);
            }
        }
    
        public void notifyObservers() {
        
            for (int i = 0; i < observers.size(); i++) {
        
                Observer observer = (Observer) observers.get(i);
                observer.update(temperature, humidity, pressure);
            }
        }
    
        public void measurementsChanged() {
        
            notifyObservers();
        }
    
        public void setMeasurements(float temperature, float humidity, float pressure) {
        
            this.temperature = temperature;
            this.humidity = humidity;
            this.pressure = pressure;
            measurementsChanged();
        }
    }

//目前状况布告板

public class CurrentConditionsDisplay implements Observer {
        
        private float temperature;
        private float humidity;
        private Subject weatherData;
    
        public CurrentConditionsDisplay(Subject weatherData) {
        
            this.weatherData = weatherData;
            weatherData.registerObserver(this);
        }
    
        public void update(float temperature, float humidity, float pressure) {
        
            this.temperature = temperature;
            this.humidity = humidity;
            display();
        }
    
        public void display() {
        
            System.out.println("Current conditions: " + temperature + "F degrees and " + humidity + "% humidity");
        }
    }

//测试代码

public class WeatherStation {
        
        public static void main(String[] args) {
        
            WeatherData weatherData = new WeatherData();
    
            CurrentConditionsDisplay currentDisplay = new CurrentConditionsDisplay(weatherData);
    
            weatherData.setMeasurements(80, 65, 30.4f);
            weatherData.setMeasurements(82, 70, 29.2f);
            weatherData.setMeasurements(78, 90, 29.2f);
        }
    }

### 21. 访问者（Visitor）模式 ###

访问者模式是一种行为型设计模式，它允许在无需改变对象结构的情况下定义对象新操作的方式。通过访问者模式，可以将新操作添加到现有类层次结构中的对象，而不必修改这些类的源代码。

示例代码：

//元素接口

public interface Element {
        
        public void accept(Visitor visitor);
    }

//具体元素类

public class ConcreteElementA implements Element {
        
        public void accept(Visitor visitor) {
        
            visitor.visit(this);
        }
    
        public String operationA() {
        
            return "ConcreteElementA operation A";
        }
    }
    
    public class ConcreteElementB implements Element {
        
        public void accept(Visitor visitor) {
        
            visitor.visit(this);
        }
    
        public String operationB() {
        
            return "ConcreteElementB operation B";
        }
    }

//访问者接口

public interface Visitor {
        
        public void visit(ConcreteElementA elementA);
        public void visit(ConcreteElementB elementB);
    }

//具体访问者类

public class ConcreteVisitor implements Visitor {
        
        public void visit(ConcreteElementA elementA) {
        
            System.out.println(elementA.operationA());
        }
    
        public void visit(ConcreteElementB elementB) {
        
            System.out.println(elementB.operationB());
        }
    }

//测试代码

public class VisitorPatternDemo {
        
        public static void main(String[] args) {
        
            Element[] elements = {
        new ConcreteElementA(), new ConcreteElementB()};
    
            Visitor visitor = new ConcreteVisitor();
    
            for (Element element : elements) {
        
                element.accept(visitor);
            }
        }
    }

### 22. 策略（Strategy）模式 ###

策略模式是一种行为模式，主要目的是定义一系列算法，将它们封装起来并使它们可以相互替换，从而使算法的变化不会影响使用算法的客户端。策略模式将算法的定义和使用分开，使得代码更易维护和扩展。

在策略模式中，应用程序通过使用不同的策略来完成不同的任务。这些策略在接口上相互替换，并且它们的属性和方法可以灵活地进行修改和扩展。可以把不同的策略在不同的场景下使用，从而实现更好的性能和效果。

示例代码：

//策略接口

interface PaymentStrategy {
        
        void pay(double amount);
    }

//支付宝支付策略

class AliPayStrategy implements PaymentStrategy {
        
        @Override
        public void pay(double amount) {
        
            System.out.println("使用支付宝支付 " + amount + " 元");
        }
    }

//微信支付策略

class WeChatPayStrategy implements PaymentStrategy {
        
        @Override
        public void pay(double amount) {
        
            System.out.println("使用微信支付 " + amount + " 元");
        }
    }

//支付器

class Payment {
        
        private PaymentStrategy paymentStrategy;
    
        public Payment(PaymentStrategy paymentStrategy) {
        
            this.paymentStrategy = paymentStrategy;
        }
    
        public void pay(double amount) {
        
            paymentStrategy.pay(amount);
        }
    }

//测试类

public class App {
        
        public static void main(String[] args) {
        
            Payment payment1 = new Payment(new AliPayStrategy());
            payment1.pay(100);
    
            Payment payment2 = new Payment(new WeChatPayStrategy());
            payment2.pay(200);
        }
    }

在上面的示例中，我们首先定义一个策略接口 PaymentStrategy，它包含一个 pay 方法。然后我们定义了 AliPayStrategy 和 WeChatPayStrategy 两个具体的策略类，实现了 PaymentStrategy 接口。最后，我们定义了 Payment 类，它封装了一个 PaymentStrategy 对象，并且有一个 pay 方法，该方法会调用 PaymentStrategy 对象的 pay 方法。在测试类中，我们创建了两个 Payment 对象，分别使用两个不同的策略对象进行支付。

### 23. 模板方法（Template Method）模式 ###

模板方法模式是一种行为模式，它定义了一个算法的骨架，将一些步骤延迟到子类中实现。模板方法使得子类可以在不改变算法结构的情况下重新定义算法的某些步骤。它允许您将通用代码提取到超类中，从而避免重复代码，并使实现更容易理解和维护。

模板方法模式包含两部分：抽象类和具体实现类。其中，抽象类包含模板方法和一些允许子类重写的抽象方法，具体实现类继承抽象类并实现抽象方法。

示例代码：

//抽象类

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

//具体实现类

class Football extends Game {
        
        @Override
        void initialize() {
        
            System.out.println("Football Game Initialized! Start playing.");
        }
    
        @Override
        void startPlay() {
        
            System.out.println("Football Game Started. Enjoy the game!");
        }
    
        @Override
        void endPlay() {
        
            System.out.println("Football Game Finished!");
        }
    }

//测试类

public class App {
        
        public static void main(String[] args) {
        
            Game game = new Football();
            game.play();
        }
    }

在上面的示例中，我们定义了一个抽象类 Game，它包含三个抽象方法：initialize、startPlay 和 endPlay，以及一个模板方法 play。具体实现类 Football 继承了 Game 抽象类，并实现了三个抽象方法。在测试类中，我们创建了一个 Football 对象，并调用了它的 play 方法。

在上面的示例中，我们可以看到，抽象类 Game 定义了一个模板方法 play，该方法调用了三个私有方法：initialize、startPlay 和 endPlay。具体实现类 Football 实现了这三个私有方法。由于 play 方法是 final 的，因此不能在具体实现类中修改它。这就是模板方法模式的核心：定义一个算法的骨架，将一些步骤延迟到子类中实现。