设计模式学习总结

最新推荐文章于 2024-09-15 22:03:14 发布

lulululuzz

最新推荐文章于 2024-09-15 22:03:14 发布

阅读量762

点赞数 19

文章标签：设计模式学习 java

本文链接：https://blog.csdn.net/lulucoding/article/details/135577844

版权

本文详细介绍了设计模式的三大类别——创建型、结构型和行为型，分别列举了各类别的核心模式如工厂模式、抽象工厂、模板方法等，并以Java为例展示了它们在实际编程中的应用。

摘要由CSDN通过智能技术生成

设计模式有三个分类。

创建型模式关注于对象的创建过程，强调将对象的创建与使用分离。有单例、原型、工厂方法、抽象工厂、建造者等5种创建型模式。

结构型模式则关注于如何将类或对象按照一定布局组成更大的结构。有代理、适配器、桥接、装饰、外观、享元、组合等7种结构型模式。

而行为型模式描述了类或对象之间如何协作，共同完成单个对象无法单独完成的任务，并分配职责。有模板方法、策略、命令、职责链、状态、观察者、中介者、迭代器、访问者、备忘录、解释器等11种行为型模式。

工厂模式

在Java中，当我们需要创建对象时，直接在代码中使用new关键字进行实例化会导致代码的高耦合性。工厂模式可以解决这个问题。通过使用工厂来生产对象，不必关心具体对象的创建过程。如果需要更换对象，只需在工厂中进行修改即可，而无需修改代码中所有创建对象的地方。

抽象工厂（ Abstract Factory ）：提供了创建产品的接口，它包含多个创建产品的方法，可以

创建多个不同等级的产品。

具体工厂（ Concrete Factory ）：主要是实现抽象工厂中的多个抽象方法，完成具体产品的创

建。

抽象产品（ Product ）：定义了产品的规范，描述了产品的主要特性和功能，抽象工厂模式有多

个抽象产品。

具体产品（ ConcreteProduct ）：实现了抽象产品角色所定义的接口，由具体工厂来创建，它

同具体工厂之间是多对一的关系。

模版模式

模板模式是一种行为型设计模式，它定义了算法的骨架，但将一些步骤的具体实现延迟到子类。这使得子类可以在不改变算法结构的情况下重新定义算法中的某些步骤。

抽象类（AbstractClass）：定义了算法的骨架，其中包含一个模板方法，该方法定义了算法的结构，而具体步骤则由一系列抽象的操作（或称为钩子方法）组成。抽象类中可能还包含一些具体的操作，但它们通常被声明为protected，以便子类可以选择性地覆盖它们。

具体类（ConcreteClass）：继承抽象类并实现抽象操作，完成算法中特定步骤的具体实现。

代理模式

代理模式是一种结构型设计模式，其目的是通过代理对象控制对其他对象的访问。

在代理模式中，一般会有以下几个角色：

抽象主题（Subject）：
- 定义了真实对象和代理对象的共同接口，使得代理对象能够在任何时刻代替真实对象。
真实主题（Real Subject）：
- 实现了抽象主题接口，是代理模式中的真实对象。它执行实际的业务逻辑。
代理（Proxy）：
- 实现了抽象主题接口，并持有对真实对象的引用。代理对象负责在调用真实对象之前或之后执行额外的逻辑，控制对真实对象的访问。

在Java中，JDK提供了一套动态代理的机制，通过java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现。以下是一个使用JDK动态代理的简单示例：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义一个接口
interface RealObjectInterface {
    void doSomething();
}

// 实际的实现类
class RealObject implements RealObjectInterface {
    public void doSomething() {
        System.out.println("RealObject is doing something.");
    }
}

// InvocationHandler 实现
class DynamicProxyHandler implements InvocationHandler {
    private Object realObject;

    public DynamicProxyHandler(Object realObject) {
        this.realObject = realObject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 在真实对象方法调用前可以添加额外逻辑
        System.out.println("Before method invocation.");

        // 调用真实对象的方法
        Object result = method.invoke(realObject, args);

        // 在真实对象方法调用后可以添加额外逻辑
        System.out.println("After method invocation.");

        return result;
    }
}

public class DynamicProxyExample {
    public static void main(String[] args) {
        // 创建真实对象
        RealObject realObject = new RealObject();

        // 创建动态代理实例
        RealObjectInterface proxyObject = (RealObjectInterface) Proxy.newProxyInstance(
                RealObjectInterface.class.getClassLoader(),
                new Class[]{RealObjectInterface.class},
                new DynamicProxyHandler(realObject)
        );

        // 通过代理对象调用方法
        proxyObject.doSomething();
    }
}

在这个例子中，Proxy.newProxyInstance方法会创建一个代理对象，该对象实现了指定接口（RealObjectInterface），并使用传入的 DynamicProxyHandler 来处理方法调用。当通过代理对象调用 doSomething 方法时，实际上是调用了 DynamicProxyHandler 中的 invoke 方法，从而可以在方法调用前后添加额外逻辑。