设计模式java描述

August 7, 2022

java

注意：设计模式适用于面向对象设计

下面演示的代码仅作为一种思路，实际代码不应是死板的，而应根据需要进行编写

参考：
https://refactoringguru.cn/
https://design-patterns.readthedocs.io/zh_CN/latest/

创建型模式

在创建型模式中，我们向调用者隐藏了构建产品的实现过程。

工厂方法 Virtual Constructor、Factory Method

工厂方法模式建议使用特殊的工厂方法代替对构造函数的直接调用（即使用 new 运算符）。工厂方法返回的对象通常被称作 “产品”。

对于产品，我们（在产品有多种实现时）（在函数签名上）提供的是抽象类，而非具体实现类。
也就是说，产品对应唯一的抽象类（有时也可以是接口）。调用者获取的也是这个抽象类。（调用者面向抽象而非面向实现）

往往使用静态工厂方法：

java

Integer n = Integer.valueOf(100);
List<String> list = List.of("A", "B", "C");
MessageDigest md5 = MessageDigest.getInstance("MD5");

上面，抽象类本身提供了静态方法，用于获取一个抽象类实例。

此外，工厂方法还隐藏了对象的构造过程。（其中可能包括缓存等操作，提高性能）

抽象工厂 Abstract Factory

在抽象工厂中，我们有多个工厂，这些工厂都可以生产我们需要的产品。
因此，我们将这些工厂抽象化，只需了解抽象工厂就可以生产产品。（因此，调用者无需了解工厂的具体实现）

生成器 Builder

生成器允许我们分步骤地创建产品。

java

import java.net.http.*;
import java.net.*;
import java.time.Duration;

public class Main {
    public static void main(String[] args) {
        HttpRequest request = HttpRequest.newBuilder() // 获取一个生成器，类型为 HttpRequest.Builder
                .GET()
                .uri(URI.create("https://example.net/"))
                .timeout(Duration.ofSeconds(10))
                .build(); // 获取产品，类型为 HttpRequest

        // 下方代码可以忽略
        HttpClient client = HttpClient.newHttpClient();
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())
                .thenApply(HttpResponse::body)
                .thenAccept(System.out::println)
                .join();
    }
}

注意，在 builder() 之后、build() 之前的链式调用中，返回的都是生成器。因此，一般来说构建方法不分顺序。

在 java 中，StringBuilder 也是一个常见的 Builder API

原型 Clone、Prototype

原型允许我们复制（克隆）一个原有的对象，并且新旧对象相互独立，互不影响。

java

String[] proto = {"One", "Two", "Tree"};
String[] cloned = Arrays.copyOf(proto, proto.length);
System.out.println(Arrays.equals(proto, cloned)); // => true

在 java 中，Cloneable 是一个空接口（标记接口），表示实现者可以使用 Object.clone() 方法。

java

class Example implements Cloneable {
    private int data;

    public Object clone() {
        var cloned = new Example();
        cloned.data = this.data; // 复制原型的数据
        return cloned;
    }
}

原型模式只适用于原型实例的数据可以被无副作用地复制的情况，否则不符合原型的定义。

单例 Singleton

单例保证这个类只有一个实例，并提供一个访问该实例的全局节点。

java

class Singleton {
    // 私有构造函数
    private Singleton() {
    }

    private static final Singleton INSTANCE = new Singleton();

    // 对外公开getInstance方法获取单例
    public static Singleton getInstance() {
        return INSTANCE;
    }
}

结构型模式

结构型模式涉及不同对象之间形成的一种结构

适配器 Adapter

适配器将我们已有的对象（包装起来），转换为我们希望的对象类型。
因为现有的对象不对接口兼容，因此适配器实际上作为兼容层，提供了我们需要的接口。

例如：

java

InputStream input = otherSource(); // 已有一个InputStream类型
// 但我们更希望以 Reader 的方式使用
Reader reader = new InputStreamReader(input, StandardCharsets.UTF_8);
// 这里 InputStreamReader 就作为一个适配器，提供 InputStream 到 Reader 的转换

java

// 旧的接口
interface OldInterface {
    public void oldFunc();
}

// 新的接口
interface NewInterface {
    public void newFunc();
}

// 旧的实现类
class OldClass implements OldInterface {
    public void oldFunc() {
    }
}

// 适配器（相当于新的实现类）
class Adapter implements NewInterface {
    private OldInterface old;

    // 需要持有（包装）需要适配的对象
    public Adapter(OldInterface old) {
        this.old = old;
    }

    public void newFunc() {
        old.oldFunc(); // 包装旧接口，转换为新接口
    }
}

最终，适配器就符合我们需要的形状（提供需要的接口）

桥接 Bridge

桥接模式可将一个大类或一系列紧密相关的类拆分为抽象和实现两个独立的层次结构，从而能在开发时分别使用。

举个例子，我们想编写一个应用程序，这个程序需要在 Windows、Linux、MacOS 平台上都能运行。
我们可以针对每一个平台都编写相应代码，从而支持多种平台。
桥接模式类似于我们选用一种跨平台框架，这个框架已经适配了多个平台。
因此，我们只需针对这个框架编写代码就能实现跨平台。

java

// 当然，除了interface也可以是class
interface Color {}
class Red implements Color {}
class Blue implements Color {}

abstract class Shape {
    public Color color;
    public abstract void paint();
}
class Square extends Shape {
    public Square(Color color) {this.color = color;}
    public void paint() {}
}
class Circle extends Shape {
    public Circle(Color color) {this.color = color;}
    public void paint() {}
}

// 使用桥接模式避免了编写如下代码：
abstract class Shape {
    public abstract void paint();
}
class RedSquare extends Shape{}

组合 Composite

你可以使用组合模式，将对象组合成树状结构，并能像使用独立对象一样使用它们。

例如，一颗 DOM 树是由多个子结点“组合”而成的，而子结点又是由它的子节点“组合”而成的。

装饰器 Decorator

装饰器允许你通过将对象放入包含行为的特殊封装对象中来为原对象绑定新的行为。

java

InputStream input =
        new GZIPInputStream(
                new BufferedInputStream(
                        new FileInputStream("test.gz")
                )
        );

外观 Facade

外观类为包含许多活动部件的复杂子系统提供一个简单的接口。与直接调用子系统相比，外观提供的功能可能比较有限，但它却包含了客户端真正关心的功能。

享元 Flyweight

享元模式让我们无需在每个对象中都保存所有数据。而是共享多个对象所共有的相同状态（复用公共状态），让你能在有限的内存容量中载入更多对象。

代理 Proxy

代理模式允许我们代理原对象的行为，（允许我们在原本的行为前后增加新行为）从而增加（或者控制）已有的功能

注意，适配器是 X -> Y，代理则是 X -> X

行为型模式

行为型模式描述了一组对象应当表现的行为，从而协同完成整体任务。

责任链 Chain of Responsibility

责任链模式允许我们将请求沿着处理者链进行传递。收到请求后，每个处理者均可对请求进行处理，或将其传递给链上的下个处理者。

命令 Action、Transaction、Command

命令模式在发送者和请求者之间建立单向连接。允许我们将请求转换为一个包含与请求相关的所有信息的独立对象。
该转换根据不同的请求将方法参数化、延迟请求执行或将其放入队列中，且能实现可撤销操作。

例如，我们有多种请求。在命令模式中，我们将不同的请求都封装成同一类型的对象，然后将这个对象发送给实现者。

发送者完成了告知命令的要求，而实现者则可以构造一个任务队列进行处理。

解释器 Interpreter

解释器模式允许我们通过规定一种文法（定义一个解释器）来解释符合规定的输入。

数据交换格式（JSON XML）、正则表达式、解释型语言（Python）以及某些 DSL （SQL）都通过解释器模式工作。

迭代器 Iterator

迭代器模式让我们能在不暴露集合底层表现形式（列表、栈和树等）的情况下遍历集合中所有的元素。

在 java 中，能够迭代的对象实现 Iterable<T> 接口，接口方法 iterator() 返回 Iterator<E> 迭代器
迭代器方法主要通过 hasNext() next() 实现迭代

https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/Iterable.html
https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html

中介者 Intermediary、Controller、Mediator

中介者模式能让我们减少对象之间混乱无序的依赖关系（阻止对象的直接依赖）。
该模式会限制对象之间的直接交互，迫使它们通过一个中介者对象进行合作（统一依赖一个中介对象实现间接操作）。

备忘录 Snapshot、Memento

备忘录模式允许在不暴露对象实现细节的情况下保存和恢复对象之前的状态。

典型的例子就是文本编辑器，实现了保存、重做、撤销功能。

观察者 Event-Subscriber、Listener、Observer

观察者模式允许我们定义一种订阅机制，可在对象事件发生时通知多个 “观察” 该对象的观察者对象。

需要（被）观察的对象应维护一个观察者列表，触发事件时，通知列表中的所有观察者。

状态 State

状态模式是让我们能在一个对象的内部状态变化时改变其行为，使其看上去就像改变了自身所属的类一样。

状态模式建议为对象的所有可能状态新建一个类（而不是将行为写死在 if else switch 里），然后将所有状态的对应行为抽取到这些类中。

原始对象被称为上下文（context），它并不会自行实现所有行为，
而是保存一个指向表示当前状态的状态对象的引用，且将所有与状态相关的工作委派给该对象。
（所有状态都实现同一接口）

策略 Strategy

为了实现同一个目标，我们可以有多种策略。策略模式让我们在实现同一个目标时使用唯一接口，但允许我们用额外的选项来切换真正实施的策略。

模板方法 Template Method

在模板方法模式中，超类中定义了一个算法的框架，允许子类在不修改结构的情况下重写算法的特定步骤。

假设我们有一组对象，它们的具有相同的方法，大部分方法的行为相同，但又有一小部分不同。
我们将这些不同的对象都抽象为一个超类，超类的所有方法（可以有默认实现）就是模板（或者说超类本身是模板）。
每个需要与之有不同行为的子类都按需要覆写特定的方法。

访问者 Visitor

访问者模式将算法与其所作用的对象隔离开来。

需要执行操作的原始对象将作为参数被传递给访问者中。

泛型机制可以看作是一种访问者模式。
某些语言的“鸭子类型”也与之类似，因为我们不关心具体的类型，而是这些类型公共的方法。

java

interface Element {
    void accept(Visitor v);
}

class One implements Element {
    public void accept(Visitor v) {}
}

class Two implements Element {
    public void accept(Visitor v) {}
}

interface Visitor {
    void visitOne(One one);
    void visitTwo(Two two);
}

class SpecialVisitor implements Visitor {
    public void visitOne(One one) {}
    public void visitTwo(Two two) {}
}


public class Main {
    public static void main(String[] args) {
        // 元素接收（任意）访问者
        new One().accept(new SpecialVisitor());
        // 访问者访问（特定）元素
        new SpecialVisitor().visitTwo(new Two());
    }
}

←Back to home