设计模式：04-适配器模式 / 桥接模式 / 装饰者模式

最新推荐文章于 2023-03-18 06:00:00 发布
最新推荐文章于 2023-03-18 06:00:00 发布
阅读量336 收藏 3
点赞数
分类专栏： 设计模式 文章标签： 适配器模式 桥接模式 装饰者模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JinglongSource/article/details/103328532
版权

文章目录

本篇博客主要是学习 韩顺平_Java设计模式 做一个学习笔记使用

7. 适配器模式

基本介绍

  1. 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主的目的是兼容性，让原本 因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapper)
  2. 适配器模式属于结构型模式
  3. 主要分为三类：类适配器模式、对象适配器模式、接口适配器模式

7.1 类适配器模式

主要是通过泛化( 继承 )的关系发生的适配

7.1.1 类适配器模式应用实例

以生活中手机充电器的例子来讲解适配器，充电器本身相当于 Adapter，220V 交流电相当于 origin (即被适配者)，我们的目 target(即 目标)是 5V 直流电

代码演示:

/**
 * 适配器模式-类适配器(通过继承的形式适配)
 *
 * @author houyu
 * @createTime 2019/11/8 9:40
 */
public class Demo1 {

    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.charging(new PhoneAdapter());
        /*
         * 输出电压220V
         * 手机适配器适配之后电压:5
         * 正在给手机充电, 电压是:5V
         */
    }

}

/**
 * 电压220V (角色: 被适配的类)
 */
class Voltage220V {
    public int output220V() {
        int origin = 220;
        System.out.println("输出电压" + origin + "V");
        return origin;
    }
}

/**
 * 适配接口
 */
interface Voltage5V {
    int output5V();
}

/**
 * 手机适配器 (角色: 可用目标)
 */
class PhoneAdapter extends Voltage220V implements Voltage5V {
    @Override
    public int output5V() {
        /**
         * 由于继承了Voltage220V, 所以output220V就会获得220V
         */
        int origin = output220V();
        int target = origin / 44;
        System.out.println("手机适配器适配之后电压:" + target);
        return target;
    }
}

/**
 * 手机
 */
class Phone {
    public void charging(Voltage5V voltage5V) {
        int output5V = voltage5V.output5V();
        System.out.println("正在给手机充电, 电压是:" + output5V + "V");
    }
}

7.2 对象适配器模式

主要是通过依赖的关系发生的适配
根据“合成复用原则”，在系统中尽量使用关联关系（聚合）来替代继承关系。( 比较常用的一种方式 )

7.2.1 类适配器模式应用实例

以生活中手机充电器的例子来讲解适配器，充电器本身相当于 Adapter，220V 交流电相当于 origin (即被适配者)，我们的目 target(即 目标)是 5V 直流电

代码演示:

/**
 * 适配器模式-对象适配器(通过依赖的形式适配)
 *
 * @author houyu
 * @createTime 2019/11/8 9:40
 */
public class Demo1 {

    public static void main(String[] args) {
        Phone phone = new Phone();
        phone.charging(new PhoneAdapter());
        /*
         * 输出电压220V
         * 手机适配器适配之后电压:5
         * 正在给手机充电, 电压是:5V
         */
    }

}

/**
 * 电压220V (角色: 被适配的类)
 */
class Voltage220V {
    public int output220V() {
        int origin = 220;
        System.out.println("输出电压" + origin + "V");
        return origin;
    }
}

/**
 * 适配接口
 */
interface Voltage5V {
    int output5V();
}

/**
 * 手机适配器 (角色: 可用目标)
 */
class PhoneAdapter implements Voltage5V {
    private Voltage220V voltage220V = new Voltage220V();
    @Override
    public int output5V() {
        /**
         * 持有Voltage220V的实例, 所以output220V就会获得220V
         */
        int origin = voltage220V.output220V();
        int target = origin / 44;
        System.out.println("手机适配器适配之后电压:" + target);
        return target;
    }
}

/**
 * 手机
 */
class Phone {
    public void charging(Voltage5V voltage5V) {
        int output5V = voltage5V.output5V();
        System.out.println("正在给手机充电, 电压是:" + output5V + "V");
    }
}

7.3 接口适配器模式(方法级别, 又叫缺省适配器模式)

核心思路：
当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接口中每个方法提供 一个默认实现（空方法），那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
…
适用于一个接口不想使用其所有的方法的情况。

7.3.1 接口适配器模式应用实例

/**
 * @author houyu
 * @createTime 2019/11/30 21:38
 */
public class Demo1 {

    public static void main(String[] args) {
        /**
         * 由于只需要使用到method2(), 所以内部类中只需要重写method2(), 而不必重写所有实现方法
         */
        MyInterface myInterface = new BaseMyInterface(){
            @Override
            public void method2() {
                System.out.println("重写method2()");
            }
        };
        myInterface.method2();
        /*
         * 重写method2()
         */
    }
}

/**
 * 很多方法的抽象接口
 */
interface MyInterface {
    void method1();
    void method2();
    void method3();
    void method4();
}

/**
 * 抽象接口的空实现(缺省实现)
 */
abstract class BaseMyInterface implements MyInterface {
    @Override
    public void method1() {
    }

    @Override
    public void method2() {
    }

    @Override
    public void method3() {
    }

    @Override
    public void method4() {
    }
}

7.4 适配器模式在 SpringMVC 框架应用的源码剖析

  • org.springframework.web.servlet.DispatcherServlet.doDispatch()
protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
	// ...
	// 确定当前请求的处理程序。
	mappedHandler = getHandler(processedRequest);
	// ...
	// 确定当前请求的处理程序适配器。
	HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
}
  • org.springframework.web.servlet.DispatcherServlet.getHandlerAdapter()
protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
			for (HandlerAdapter adapter : this.handlerAdapters) {
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
		throw new ServletException("No adapter for handler [" + handler +
				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
	}
  • HandlerAdapter 的实现类

在这里插入图片描述

  • 简要类图
    在这里插入图片描述

7.5 适配器模式的注意事项和细节

  1. 三种命名方式，是根据 src 是以怎样的形式给到 Adapter（在 Adapter 里的形式）来命名的。
  2. 类适配器：以类给到，在 Adapter 里，就是将 src 当做类，继承 对象适配器：以对象给到，在 Adapter 里，将 src 作为一个对象，持有 接口适配器：以接口给到，在 Adapter 里，将 src 作为一个接口，实现
  3. Adapter 模式最大的作用还是将原本不兼容的接口融合在一起工作。
  4. 实际开发中，实现起来不拘泥于我们讲解的三种经典形式

8. 桥接模式

基本介绍

  1. 桥接模式(Bridge 模式)是指：将实现与抽象放在两个不同的类层次中，使两个层次可以独立改变。
  2. 是一种结构型设计模式
  3. Bridge 模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同的类承担不同的职责。它的主要 特点是把抽象(Abstraction)与行为实现(Implementation)分离开来，从而可以保持各部分的独立性以及应对他们的 功能扩展

8.1 应用实例(手机操作问题)

现在对不同手机类型的不同品牌实现操作编程(比如:开机、关机、上网，打电话等)，如图:
在这里插入图片描述

传统方案解决手机操作问题分析

  1. 扩展性问题(类爆炸)，如果我们再增加手机的样式(旋转式)，就需要增加各个品牌手机的类，同样如果我们增加 一个手机品牌，也要在各个手机样式类下增加。
  2. 违反了单一职责原则，当我们增加手机样式时，要同时增加所有品牌的手机，这样增加了代码维护成本.
  3. 解决方案-使用桥接模式

8.2 桥接模式解决手机操作问题

在这里插入图片描述

正确识别出系统中两个独立变化的维度(抽象[brand 品牌]、和实现[phone 手机])
通过依赖的关系, 形成多样化的不同组合, 从而解决了类爆炸的问题以及满足开闭原则, 可以动态扩张不同的品牌等…

/**
 * @author houyu
 * @createTime 2019/12/1 10:29
 */
public class Demo {

    public static void main(String[] args) {
        // 想要一台直立样式 + 小米品牌的手机
        Phone phone = new UpRightPhone(new XiaoMi());
        phone.open();
        phone.call();
        phone.close();
        // 想要一台直立样式 + Vivo品牌的手机
        phone = new UpRightPhone(new Vivo());
        phone.open();
        phone.call();
        phone.close();
        /*
         * XiaoMi手机开机
         * 直立样式手机
         * XiaoMi手机打电话
         * 直立样式手机
         * XiaoMi手机关机
         * 直立样式手机
         * Vivo手机开机
         * 直立样式手机
         * Vivo手机打电话
         * 直立样式手机
         * Vivo手机关机
         * 直立样式手机
         */
        /**
         * 思考:
         * 下面如果手机中新增了一个新的样式手机也很简单, 新增一个新的平台也很简单, 还可以随时搭配出想要的样式 + 品牌的手机的组合
         * 满足开闭原则
         * 解决了类爆炸问题...
         * 
         * 桥接模式的注意事项和细节 
         * 1) 实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象部分和实现部分独立开来，这有助于 系统进行分层设计，从而产生更好的结构化系统。 
         * 2) 对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其它的部分由具体业务来完成。 
         * 3) 桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本。
         * 4) 桥接模式的引入增加了系统的理解和设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设 计和编程 
         * 5) 桥接模式要求正确识别出系统中两个独立变化的维度(抽象、和实现)，因此其使用范围有一定的局限性，即需 要有这样的应用场景。 
         * 
         * 桥接模式其它应用场景 对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用.
         * 常见的应用场景: 
         * 1) -JDBC 驱动程序 
         * 2) -银行转账系统 转账分类: 网上转账，柜台转账，AMT 转账 转账用户类型：普通用户，银卡用户，金卡用户.. 
         * 3) -消息管理 消息类型：即时消息，延时消息 消息分类：手机短信，邮件消息，QQ 消息...
         */
    }
}

/**
 * 品牌接口
 */
interface Brand {
    void open();
    void close();
    void call();
}

/**
 * Vivo品牌
 */
class Vivo implements Brand {

    @Override
    public void open() {
        System.out.println("Vivo手机开机");
    }

    @Override
    public void close() {
        System.out.println("Vivo手机关机");
    }

    @Override
    public void call() {
        System.out.println("Vivo手机打电话");
    }
}

/**
 * XiaoMi品牌
 */
class XiaoMi implements Brand {

    @Override
    public void open() {
        System.out.println("XiaoMi手机开机");
    }

    @Override
    public void close() {
        System.out.println("XiaoMi手机关机");
    }

    @Override
    public void call() {
        System.out.println("XiaoMi手机打电话");
    }
}
/**
 * 手机 (充当角色: 桥)
 * Phone的实现(子类)是 桥 的具体实现
 */
abstract class Phone {
    /** 组合品牌*/
    private Brand brand;

    public Phone(Brand brand) {
        this.brand = brand;
    }
    void open() {
        brand.open();
    }
    void close() {
        brand.close();
    }
    void call() {
        brand.call();
    }
}

/**
 * 直立手机
 */
class UpRightPhone extends Phone {
    public UpRightPhone(Brand brand) {
        super(brand);
    }

    @Override
    void open() {
        super.open();
        System.out.println("直立样式手机");
    }

    @Override
    void close() {
        super.close();
        System.out.println("直立样式手机");
    }

    @Override
    void call() {
        super.call();
        System.out.println("直立样式手机");
    }
}

8.3 桥接模式在 JDBC 的源码剖析

在这里插入图片描述

  • jdbc 入口
public static void main(String[] args) throws Exception {
	// 注册驱动 (初始化com.mysql.jdbc.Driver类, 然后调用static进行注册驱动)
    Class.forName("com.mysql.jdbc.Driver");
    // 获取连接
    Connection connection = DriverManager.getConnection("url", "username", "password");
}
  • com.mysql.cj.jdbc.Driver (静态注入驱动)
public class Driver extends NonRegisteringDriver implements java.sql.Driver {
    //
    // Register ourselves with the DriverManager
    //
    static {
        try {
        	// 往 DriverManager 注册具体实现的驱动信息
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    public Driver() throws SQLException {
        // Required for Class.forName().newInstance()
    }
}
  • java.sql.DriverManager (存储驱动)
public class DriverManager {
	// 存储所有驱动信息
	private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
	// 注册驱动方法
	public static synchronized void registerDriver(java.sql.Driver driver, DriverAction da) throws SQLException {
        /* Register the driver if it has not already been added to our list */
        if(driver != null) {
            registeredDrivers.addIfAbsent(new DriverInfo(driver, da));
        } else {
            // This is for compatibility with the original DriverManager
            throw new NullPointerException();
        }
        println("registerDriver: " + driver);
    }
}
  • java.sql.DriverManager (获取驱动 [ 具体实现的驱动(mysql… ) ] )
public static Connection getConnection(String url,
    String user, String password) throws SQLException {
    java.util.Properties info = new java.util.Properties();
    if (user != null) {
        info.put("user", user);
    }
    if (password != null) {
        info.put("password", password);
    }
    return (getConnection(url, info, Reflection.getCallerClass()));
}


private static Connection getConnection(
    Stringurl, java.util.Properties info, Class<?> caller) throws SQLException {
    ClassLoader callerCL = caller != null ? caller.getClassLoader() : null;
    synchronized(DriverManager.class) {
        if (callerCL == null) {
            callerCL = Thread.currentThread().getContextClassLoader();
        }
    }
    if(url == null) {
        throw new SQLException("The url cannot be null", "08001");
    }
    println("DriverManager.getConnection(\"" + url + "\")");
    SQLException reason = null;

    for(DriverInfo aDriver : registeredDrivers) {
        if(isDriverAllowed(aDriver.driver, callerCL)) {
            try {
                println("    trying " + aDriver.driver.getClass().getName());
                Connection con = aDriver.driver.connect(url, info);
                if (con != null) {
                    println("getConnection returning " + aDriver.driver.getClass().getName());
                    return (con);
                }
            } catch (SQLException ex) {
                if (reason == null) {
                    reason = ex;
                }
            }
        } else {
            println("    skipping: " + aDriver.getClass().getName());
        }
    }
    if (reason != null)    {
        println("getConnection failed: " + reason);
        throw reason;
    }
    println("getConnection: no suitable driver found for "+ url);
    throw new SQLException("No suitable driver found for "+ url, "08001");
}

分析:

  1. Jdbc 的 Driver 接口，如果从桥接模式来看，Driver 就是一个接口(抽象层)，下面可以有 MySQL 的 Driver，Oracle 的 Driver，这些就可以当做实现接口类
  2. DriverManager 充当桥角色, ( 内部 registeredDrivers 存储所有注册驱动信息, 也就是抽象的具体实现)
  3. DriverManager 会通过你注册了什么驱动, 然后 通过getConnection() 返回注册的驱动, 从而满足了开闭原则, 以及满足动态扩展java.sql.Driver 的具体实现

8.4 桥接模式的注意事项和细节

  1. 实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象部分和实现部分独立开来，这有助于 系统进行分层设计，从而产生更好的结构化系统。
  2. 对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其它的部分由具体业务来完成。
  3. 桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本。
  4. 桥接模式的引入增加了系统的理解和设计难度，由于聚合关联关系建立在抽象层，要求开发者针对抽象进行设 计和编程
  5. 桥接模式要求正确识别出系统中两个独立变化的维度(抽象、和实现)，因此其使用范围有一定的局限性，即需 要有这样的应用场景。

桥接模式其它应用场景

对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥接模式尤为适用常见的应用场景:

  1. -JDBC 驱动程序
  2. -银行转账系统 转账分类: 网上转账，柜台转账，AMT 转账 转账用户类型：普通用户，银卡用户，金卡用户…
  3. -消息管理 消息类型：即时消息，延时消息 消息分类：手机短信，邮件消息，QQ 消息…

9 装饰者模式

基本介绍

  1. 装饰者模式：动态的将新功能附加到对象上。在对象功能扩展方面，它比继承更有弹性，装饰者模式也体现了 开闭原则(ocp)
  2. 这里提到的动态的将新功能附加到对象和 ocp 原则，在后面的应用实例上会以代码的形式体现

9.1 装饰者模式应用实例

星巴克咖啡订单项目（咖啡馆）：

  1. 咖啡种类/单品咖啡：BeiJingCoffee(北京咖啡)、ShangHaiCoffee(上海咖啡)
  2. 调料：Chocolate(巧克力) Milk(牛奶)
  3. 要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便
  4. 使用 OO 的来计算不同种类咖啡的费用: 客户可以点单品咖啡，也可以单品咖啡+调料组合。
/**
 * @author houyu
 * @createTime 2019/12/1 13:14
 */
public class Demo {

    public static void main(String[] args) {
        // 星巴克咖啡订单项目（咖啡馆）：
        // 1) 咖啡种类/单品咖啡：BeiJingCoffee(北京咖啡)、ShangHaiCoffee(上海咖啡)
        // 2) 调料：Chocolate(巧克力) Milk(牛奶)
        // 3) 要求在扩展新的咖啡种类时，具有良好的扩展性、改动方便、维护方便
        // 4) 使用 OO 的来计算不同种类咖啡的费用: 客户可以点单品咖啡，也可以单品咖啡+调料组合。
        //
        // 北京咖啡 + 牛奶 + 巧克力
        Drink order = new BeiJingCoffee();
        order = new Milk(order);
        order = new Chocolate(order);
        System.out.println("order.getDes() = " + order.getDes());
        System.out.println("order.getPrice() = " + order.getPrice());
        //
        order = new ShangHaiCoffee();
        order = new Milk(order);
        order = new Milk(order);
        System.out.println("order.getDes() = " + order.getDes());
        System.out.println("order.getPrice() = " + order.getPrice());
        /*
         * order.getDes() = 北京咖啡 + 牛奶 + 巧克力
         * order.getPrice() = 11.5
         * order.getDes() = 上海咖啡 + 牛奶 + 牛奶
         * order.getPrice() = 12.0
         */
    }

}

/**
 * 饮料
 */
abstract class Drink {
    /**
     * 描述
     */
    private String des;
    /**
     * 价格
     */
    private float price = 0.0F;

    public String getDes() {
        return des;
    }

    public Drink setDes(String des) {
        this.des = des;
        return this;
    }

    public float getPrice() {
        return price;
    }

    public Drink setPrice(float price) {
        this.price = price;
        return this;
    }
}

/**
 * 咖啡
 */
class Coffee extends Drink {
}

/**
 * 北京咖啡
 */
class BeiJingCoffee extends Coffee {
    public BeiJingCoffee() {
        setDes("北京咖啡");
        setPrice(6.0F);
    }
}

/**
 * 上海咖啡
 */
class ShangHaiCoffee extends Coffee {
    public ShangHaiCoffee() {
        setDes("上海咖啡");
        setPrice(5.0F);
    }
}

/**
 * 装饰者(包裹着装饰品 { Drink })
 */
class Decorator extends Drink {
    /** 聚合 Drink */
    Drink drink;

    public Decorator(Drink drink) {
        this.drink = drink;
    }

    @Override
    public String getDes() {
        return drink.getDes() + " + " + super.getDes();
    }

    @Override
    public float getPrice() {
        return drink.getPrice() + super.getPrice();
    }
}

/**
 * 巧克力调味品 (巧克力装饰器)
 */
class Chocolate extends Decorator {
    public Chocolate(Drink drink) {
        super(drink);
        setDes("巧克力");
        setPrice(2.0F);
    }
}

/**
 * 牛奶调味品 (牛奶装饰器)
 */
class Milk extends Decorator {
    public Milk(Drink drink) {
        super(drink);
        setDes("牛奶");
        setPrice(3.5F);
    }
}

9.2 装饰者模式在 JDK 应用的源码分析

// JDK中使用装饰者模式
DataInputStream reader = new DataInputStream(new FileInputStream(""));
// 说明 
// 1. InputStream 是抽象类, 类似我们前面讲的 Drink 
// 2. FileInputStream 是 InputStream 子类，类似我们前面的 DeCaf, LongBlack 
// 3. FilterInputStream 是 InputStream 子类：类似我们前面 的 Decorator 修饰者 
// 4. DataInputStream 是 FilterInputStream 子类，具体的修饰者，类似前面的 Milk, Soy 等 
// 5. FilterInputStream 类 有 protected volatile InputStream in; 即含被装饰者 
// 6. 分析得出在 jdk 的 io 体系中，就是使用装饰者模式
  • java.io.FilterInputStream
public class FilterInputStream extends InputStream {
    /**
     * The input stream to be filtered.
     */
    protected volatile InputStream in;

    /**
     * Creates a <code>FilterInputStream</code>
     * by assigning the  argument <code>in</code>
     * to the field <code>this.in</code> so as
     * to remember it for later use.
     *
     * @param   in   the underlying input stream, or <code>null</code> if
     *          this instance is to be created without an underlying stream.
     */
    protected FilterInputStream(InputStream in) {
        this.in = in;
    }
}

在这里插入图片描述

9.3 装饰者模式的注意事项和细节

实现步骤:

  1. 提取相同点部分形成一个抽象类(Drink)【被装饰者和装饰者 的 基类】
  2. 实现层实现抽象类Drink ( 被装饰者: BeiJingCoffee / ShangHaiCoffee )【被装饰者】
  3. 装饰者基类实现抽象类Drink, 并且组合一个Drink ( 包裹被装饰者, 那么自己就是装饰者了 )【装饰者基类】
  4. 装饰者基类需要在本类中实现组合抽象类(Drink)的一些业务逻辑
  5. 具体装饰者实现装饰者基类即可

装饰者模式 有一点递归的味道。。。

IT加载中
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
吉林大学软件设计模式SDP02-04例子代码
11-08
这个吉林大学的SDP02-04例子代码很可能是为了教学目的，帮助学生理解和应用设计模式。下面，我们将深入探讨设计模式的核心概念以及可能包含在这个压缩包中的具体模式。 设计模式不是具体的代码或库，而是一套通用的...
【Java面试题】设计模式之七种结构性模式——代理模式、适配器模式、桥接模式、装饰模式、外观模式、享元模式、组合模式
最新发布
m0_63372226的博客
04-03 612
概念:代理模式是为其他对象提供一种以代理控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。优点：(1)职责清晰真实的角色就是实现实际的业务逻，不用关心其他非本职责的事务，通过后期的代理完成一件完成事务，附带的结果就是编程简洁清晰。(2)代理对象可以在客户端和目标对象之间起到中介的作用，这样起到了中介的作用和保护了目标对象的作用。(3)高扩展性。
Java的23种设计模式
FreeRuner的博客
08-05 413
一、设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式
java的常用设计模式
weixin_47733858的博客
07-11 304
直接上代码 // 先定义一个最基本的接口 public interface BaseInterface { // 用于业务处理的方法 public void toDoService(); // 用于返回当前业务名字的方法 public String returnServiceName(); } // 在定义上面接口的子类 @Service public class ServiceOne implements BaseInterface{ @Override pub.
Java常用设计模式(三)
BASK2312的博客
02-25 204
在这个例子中，CPU、Memory、HardDrive 分别代表电脑开机过程中的 CPU、内存、硬盘子系统，Computer 则是外观类，它封装了所有子系统的初始化过程，提供了一个简单的 start 方法。具体实现中，我们可以定义一个中介者接口，其中包含一个发送消息的方法。在Java Servlet框架中，请求被 Servlet 容器传递给过滤器链，每个过滤器都可以对请求进行处理，如果需要将请求传递给下一个过滤器，则需要调用chain.doFilter()方法，直到最终到达Servlet为止。
Java责任链模式：优雅解耦系统处理流程，实现高效灵活的请求处理与分发
陈书予
03-18 5438
责任链模式是一种行为型设计模式，它用于将多个请求处理器对象连接成一条链，可以让请求沿着这条链不断地传递，直到有一个请求处理器处理完成为止。在责任链模式中，每个请求处理器都可以选择将请求进行处理，或将请求转发给下一个请求处理器。因此，责任链模式可以将系统中的请求处理逻辑进行解耦，使得请求的发送者和接收者之间的关系更加灵活。责任链模式是一种行为型设计模式，用于将多个请求处理器对象连接成一条链，可以让请求沿着这条链不断地传递，直到有一个请求处理器处理完成为止。
51丨适配器模式：代理、适配器、桥接、装饰，这四个模式有何区别？1
08-03
适配器模式是一种结构型设计模式，其主要目的是解决接口不兼容问题，使得原本由于接口差异无法协同工作的类能够一起工作。适配器模式通过创建一个新的类（适配器），将旧的接口转换成目标接口，从而实现了系统的解耦...
设计模式系列-桥接模式
03-04
一、我们讲述了比较常用的适配器模式，并且分析了适配器的一般使用场景： 1、我们在使用第三方的类库，或者说第三方的API的时候，我们通过适配器转换来满足现有系统的使用需求。 2、我们的旧系统与新系统进行集成...
Java结构型设计模式中的适配器模式与桥接模式解析
09-02
适配器模式和桥接模式都是Java结构型设计模式的重要组成部分，它们主要用于解决软件设计中的接口不兼容问题以及实现抽象与实现的解耦。 适配器模式的核心思想是将两个原本不兼容的接口通过适配器进行转换，使得原本...
设计模式-适配器模式
01-14
适配器模式是一种在软件设计中广泛使用的结构型设计模式，它的主要目的是解决不同接口或类之间不兼容的问题，使得原本无法协同工作的组件能够协同工作。在这个“设计模式-适配器模式”的资源中，我们可以深入理解...
七种常用的设计模式
热门推荐
a154555的博客
07-05 7万+
常用的七种设计模式：单例模式、工厂方法模式、抽象工厂模式、代理模式、装饰器模式、观察者模式和责任链模式。设计模式分类设计模式根据工作的目的，分为创建型模式、结构型模式和行为型模式三类。创建型模式：单例模式、工厂方法模式、抽象工厂模式、创建者模式、原型模式。结构型模式：适配器模式、代理模式、装饰器模式、外观模式、桥接模式、组合模式、享元模式。行为型模式：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。软件设计七大原则(OOP原则)
java 23 种设计模式-16-java 解释器模式(Interpreter Pattern)
05-21 3万+
目录 目录 解释器模式 实际案例 定义 测试 实现方式 UML &amp; Code UML Code 系列导航 解释器模式 解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，它属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。 实际案例 类信息概览： ...
java25种设计模式之适配器模式
java初识者
03-09 471
适配器模式在java中是一中结构型设计模式。 在实际的java来发中，有时候我们会遇到一些不能直接调用，或者不是客户需要的接口，但是却需要使用时，我们就可以使用适配器设计模式。 适配器设计模式就是将一个原本不兼容的接口通过转换或者适配成我们想要的接口，使原本两个不相关接口可以在一起工作。
Java Spring后处理器
涂涂写写的笔记
11-24 801
是Spring对外开放的重要扩展点，允许我们介入到Bean的整个实例化流程中来，以达到动态注册BeanDefinition，动态修改BeanDefinition，以及动态修改Bean的作用。BeanBeanDefintion到beanBeanDefintionMap中去，注册功能可以理解注解的实现，工厂后处理器去遍历带上注解的类，让后将其进行注册。的Map集合中去，那么除了直接将类信息配置的方式外，还有别的方式可以对想要交给Spring管理的类进行针对性处理封装，这里就可以使用到Spring的后处理器。
java设计模式之适配器模式(UML类图分析+代码详解)
m0_51750419的博客
10-09 2132
适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表示，主要目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同工作。其别名为包装器(Wrapper)。适配器模式属于结构型模式。适配器模式主要分为三类：类适配器模式、对象适配器模式、接口适配器模式。
ARM学习笔记(一)--处理器模式
liufei_learning--脚踏实地，戒骄戒躁！
08-21 1496
<br /> <br />处理器模式<br /> <br />CPSR寄存器<br />ARM V4的CPSR寄存器（和保存它的SPSR寄存器）中的位分配如下图所示。<br /> <br /> <br /><br /> <br />处理器模式<br />描述<br />用户模式（User,usr）<br />正常程序执行的模式<br />快速中断模式（FIQ,fiq）<br />用于高速数据传输和通道处理<br />外部中断模式（IRQ,irq）<br />用户通常的中断使用<br />特权模式（Super
Java注解处理器使用详解
kyfxing的博客
05-23 940
文章转自：http://www.race604.com/annotation-processing/在这篇文章中，我将阐述怎样写一个注解处理器(Annotation Processor)。在这篇教程中，首先，我将向您解释什么是注解器，你可以利用这个强大的工具做什么以及不能做什么；然后，我将一步一步实现一个简单的注解器。一些基本概念在开始之前，我们首先申明一个非常重要的问题：我们并不讨论那些在运行时...
GOF设计模式
weixin_34026484的博客
09-11 128
结构型模式是描述如何将类对象结合在一起，形成一个更大的结构，结构模式描述两种不同的东西：类与类的实例。故可以分为类结构模式和对象结构模式。在GoF设计模式中，结构型模式有：1.适配器模式 Adapter 适配器模式是将一个类的接口转换成客户希望的另外一个接口。适配器模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 两个成熟的类需要通信，但是接口不同，...
设计模式--策略模式
小达的博客
03-27 300
设计模式–策略模式 策略模式 在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。 在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。 策略对象改变 context 对象的执行算法。 优点 算法可以自由切换。 避免使用多重条件判断。 扩展性良好。 缺点 ...
Java设计模式：结构型探索-适配器、组合与代理
本章节主要探讨Java设计模式中的结构型模式，包括组合、代理、适配器、外观等模式。结构型设计模式关注的是类或对象如何组合以形成更大的系统结构，它们通过简单的组件组合实现复杂功能的增强。结构型模式大致可分为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值