为什么java开发多年依然没有熟练掌握23种设计模式

一、前言

为什么很多大佬java开发多年依然没能熟练掌握23种设计模式，我想大概有以下几方面原因：

第一个原因是23种设计模式内容较多，

第二是很多人学设计模式都是从工厂模式开始学，学完前面7,8个后面的就没学下去了。所以越往后的设计模式也不清楚。

第三，平时或实战中运用的少，缺少理解。

第四，有有很多参考资料对设计模式的命名不统一，搞得同一个设计模式有几个名字，延伸出来就5,60个设计模式，不便记忆

二、学好设计模式

对设计模式进行分类：

1、创建型设计模式

2、结构型设计模型

3、行为型设计模式

首先就记住这三点。

然后23种设计模式再在里面套。

创造模型：工厂模型、抽像工厂模型、单例模型、建造者模型和原型模型。
结构模型：适配器模型、桥接模型、过滤器模型、组合模型、装饰器模型、外观模型、享受元模型和代理模型。
行为模型：责任链模型、命令模型、解释器模型、迭代器模式、中介绍者模型、备忘录模型、观察者模型、状态模型、策略模型和模板方法模型。

 

三、由终而始

既然以前都是从工厂模型学起，我们这一次就不从工厂模式学起了。直接从行为模式学起。

1、责任链模式

顾名思义，就是将一个大的任务进行分割解耦，分配到个单独模块处理，每一个独立模块有自己单独的职责。比如mq中，生产者和消费者单独模块中实现

2、命令模式

命令模式（Command Pattern）是对命令的封装，每一个命令都是一个操作：请求的一方发出请求要求执行一个操作；接收的一方收到请求，并执行操作。命令模式解耦了请求方和接收方，请求方只需请求执行命令，不用关心命令是怎样被接受，怎样被操作以及是否被执行等。 

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

// 具体命令类
class ConcreteCommand implements Command {
    private Receiver receiver;

    public ConcreteCommand(Receiver receiver) {
        this.receiver = receiver;
    }

    public void execute() {
        receiver.action();
    }
}

// 接收者类
class Receiver {
    public void action() {
        System.out.println("Receiver executes the command.");
    }
}

// 调用者类
class Invoker {
    private Command command;

    public void setCommand(Command command) {
        this.command = command;
    }

    public void executeCommand() {
        command.execute();
    }
}

// 客户端代码
public class CommandPatternExample {
    public static void main(String[] args) {
        Receiver receiver = new Receiver();
        Command command = new ConcreteCommand(receiver);

        Invoker invoker = new Invoker();
        invoker.setCommand(command);
        invoker.executeCommand();
    }
}

 3、解释器模式

解析器模式（Interpreter Pattern）是一种行为型设计模式，它用于定义一种语言的文法，以及解释该语言中的表达式。这个模式允许你通过创建一个解释器来解释语言中的表达式，从而实现对特定语言的解析和操作。在本文中，我们将探讨解析器模式的概念、用途以及如何使用Java代码来实现它。

在解释器模式中，通常会涉及以下几个角色：

抽象表达式（AbstractExpression）：声明一个抽象的解释操作接口，所有具体表达式类都必须实现该接口。
终结符表达式（TerminalExpression）：实现抽象表达式接口，表示语法中的终结符。终结符表达式通常是语法中的基本单位，无法再分解。
非终结符表达式（NonterminalExpression）：实现抽象表达式接口，表示语法中的非终结符。非终结符表达式通常由多个终结符表达式组合而成。
上下文（Context）：包含解释器所需的全局信息或状态。
 

// 抽象表达式
interface Expression {
    int interpret(Context context);
}

// 终结符表达式
class NumberExpression implements Expression {
    private int number;

    public NumberExpression(int number) {
        this.number = number;
    }

    public int interpret(Context context) {
        return number;
    }
}

// 非终结符表达式
class AddExpression implements Expression {
    private Expression left;
    private Expression right;

    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    public int interpret(Context context) {
        return left.interpret(context) + right.interpret(context);
    }
}

// 上下文
class Context {
    // 全局信息或状态
}

// 客户端代码
public class InterpreterPatternExample {
    public static void main(String[] args) {
        // 构建解释器的语法树
        Expression expression = new AddExpression(
            new NumberExpression(10),
            new AddExpression(
                new NumberExpression(5),
                new NumberExpression(2)
            )
        );

        Context context = new Context();
        int result = expression.interpret(context);
        System.out.println("Result: " + result);
    }
}

4、迭代器模式

迭代器模式是一种行为型设计模式，它提供了一种统一的方式来访问集合对象中的元素，而不是暴露集合内部的表示方式。简单地说，就是将遍历集合的责任封装到一个单独的对象中，我们可以按照特定的方式访问集合中的元素。

// 迭代器接口
interface Iterator {
    boolean hasNext();
    Object next();
}

// 集合接口
interface Collection {
    Iterator createIterator();
}

// 具体迭代器
class ConcreteIterator implements Iterator {
    private String[] elements;
    private int position = 0;

    public ConcreteIterator(String[] elements) {
        this.elements = elements;
    }

    public boolean hasNext() {
        return position < elements.length;
    }

    public Object next() {
        if (hasNext()) {
            String element = elements[position];
            position++;
            return element;
        }
        return null;
    }
}

// 具体集合
class ConcreteCollection implements Collection {
    private String[] elements;

    public ConcreteCollection(String[] elements) {
        this.elements = elements;
    }

    public Iterator createIterator() {
        return new ConcreteIterator(elements);
    }
}

// 客户端代码
public class IteratorPatternExample {
    public static void main(String[] args) {
        String[] elements = {"A", "B", "C", "D", "E"};

        Collection collection = new ConcreteCollection(elements);
        Iterator iterator = collection.createIterator();

        while (iterator.hasNext()) {
            Object element = iterator.next();
            System.out.println(element);
        }
    }
}

5、中介者模式

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。

中介者模式4种角色：

• 抽象中介者（Mediator）角色：抽象中介者角色定义统一的接口，以及一个或者多个事件方法，用于各同事角色之间的通信。
• 具体中介者（ConcreteMediator）角色：实现了抽象中介者所声明的事件方法，协调各同事类之间的行为，持有所有同事类对象的引用。
• 抽象同事（Colleague）角色：定义了抽象同事类，持有抽象中介者对象的引用。
• 具体同事（ConcreteColleague）角色：继承抽象同事类，实现自己业务，通过中介者跟其他同事类进行通信。

6、备忘录模型

定义

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，之后就可以将该对象恢复到原先保存的状态。

备忘录模式（Memento Pattern）是一种弥补缺陷的模式，能够在失败的操作后读档

应用场景

1. 需要保存和恢复数据的场景
2. 需要提供一个可回滚（rollback）的操作
3. 需要监控的副本场景
4. 数据库连接的事务管理就是使用备忘录模式

备忘录模式的角色

1. Originator发起人。记录当前时刻的内部状态，负责定义哪些属于备份范围的状态，负责创建和恢复备忘录数据
2. Memento备忘录角色。负责Originator当前状态的快照，之后需要时提供数据回滚
3. Caretaker备忘录管理员。管理Memento角色，将发起人对备忘录角色的使用权交给管理员。

7、观察者模式

观察者模式又称为 发布-订阅模式，定义了对象之间一对多依赖关系，当目标对象(被观察者)的状态发生改变时，它的所有依赖者(观察者)都会收到通知。一个观察目标可以对应多个观察者，而这些观察者之间没有相互联系，所以能够根据需要增加和删除观察者，使得系统更易于扩展，符合开闭原则；并且观察者模式让目标对象和观察者松耦合，虽然彼此不清楚对方的细节，但依然可以交互，目标对象只知道一个具体的观察者列表，但并不认识任何一个具体的观察者，它只知道他们都有一个共同的接口。

但观察者模式的缺点在于如果存在很多个被观察者的话，那么将需要花费一定时间通知所有的观察者，如果观察者与被观察者之间存在循环依赖的话，那么可能导致系统崩溃，并且观察者模式没有相应的机制让观察者知道被观察对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。
 

确实是难学，后面这几种设计模式也用的少，不过我们发现大多数的行为设计模式都是解耦行为，将一个大的行为进行解耦。或许我们可以将这些模式叫做解耦模式。这让我想起了一个软件设计原则： 高内聚，低耦合。 其实所有的行为模式，都遵从高内聚，低耦合设计。是不是有点豁然开朗。 所以的设计都是从软件设计的7个原则进行权衡设计的。