设计模式之适配器模式、桥接模式、代理模式、装饰者模式

最新推荐文章于 2024-04-28 14:26:27 发布
最新推荐文章于 2024-04-28 14:26:27 发布
阅读量1.5k 收藏 11
点赞数 4
分类专栏： 设计思想 文章标签： 设计模式 适配器模式 桥接模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36386908/article/details/123443167
版权

文章目录

一、适配器模式

在现实生活中，经常出现两个对象因接口不兼容而不能在一起工作的实例，这时需要第三者进行适配。例如，讲中文的人同讲英文的人对话时需要一个翻译，用直流电的笔记本电脑接交流电源时需要一个电源适配器，用计算机访问照相机的 SD 内存卡时需要一个读卡器等。

在软件设计中也可能出现：需要开发的具有某种业务功能的组件在现有的组件库中已经存在，但它们与当前系统的接口规范不兼容，如果重新开发这些组件成本又很高，这时用适配器模式能很好地解决这些问题。

适配器模式（Adapter）：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的类可以一起工作。适配器模式分为类结构型模式和对象结构型模式两种，前者类之间的耦合度比后者高，且要求程序员了解现有组件库中的相关组件的内部结构，所以应用相对较少些。

1.1、实现方式

1.1.1、需求

通过内存卡案例实现，现在有两种内存卡，一种是SD卡，一种是FT卡，电脑只能读取SD卡，所以需要将FT卡适配为SD卡

1.1.2、适配器模式角色

  • 目标（Target）接口：当前系统业务所期待的接口，它可以是抽象类或接口。
  • 适配者（Adaptee）类：它是被访问和适配的现存组件库中的组件接口。
  • 适配器（Adapter）类：它是一个转换器，通过继承或引用适配者的对象，把适配者接口转换成目标接口，让客户按目标接口的格式访问适配者

1.1.3、类适配

  • 适配器必须继承适配者类，因为要使用适配着中的方法进行转换
  • 适配器实现目标类接口
// SD卡接口
public interface ISDCard {
	// 读数据
    String readSD();
    // 写数据
    void writeSD(String msg);
}

// SD卡实现类
public class SDCard implements ISDCard{
    @Override
    public String readSD() {
        String msg = "read sd hello world";

        return msg;
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("write sd " + msg);
    }
}

// FT卡接口
public interface IFTCard {
    String readFT();
    void writeFT(String msg);
}

// FT卡实现类
public class FTCard implements IFTCard{
    @Override
    public String readFT() {
        String msg = "read ft hello world";
        return msg;
    }

    @Override
    public void writeFT(String msg) {
        System.out.println("write ft " + msg);
    }
}

// 电脑类，只支持读写SD卡中内容
public class Compter {

    public String readSD(ISDCard sdCard){
        if(sdCard == null) {
            throw new NullPointerException("sd card is not null");
        }
        return sdCard.readSD();
    }

    public void writeSD(ISDCard sdCard) {
        sdCard.writeSD("hello world");
    }
}

// 适配器类，继承FT卡实现类，实现SD卡接口，重写SD卡方法
public class FTAdapterSD extends FTCard implements ISDCard{
    @Override
    public String readSD() {
        System.out.println("适配FT卡读数据");
        return readFT();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("适配FT卡写数据");
        writeFT(msg);
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Compter compter = new Compter();
        SDCard sdCard = new SDCard();
        System.out.println("插入SD卡");
        System.out.println(compter.readSD(sdCard));
        compter.writeSD(sdCard);

        System.out.println("插入FT卡转换器");
        FTAdapterSD ftAdapterSD = new FTAdapterSD();

        System.out.println(compter.readSD(ftAdapterSD));
        compter.writeSD(ftAdapterSD);
    }
}

违反了合成复用原则，如果目标对象不是接口，而是一个抽象类就无法实现，因为Java不支持多继承，所以多数情况下还是使用对象适配。

1.1.4、对象适配

// 适配器类，
// 将适配者当做对象引用进来即可。不再继承FT卡实现类，而是当做对象依赖进来
public class FTAdapterSD implements ISDCard {
    private FTCard ftCard;

    public FTAdapterSD(FTCard ftCard) {
        this.ftCard = ftCard;
    }

    @Override
    public String readSD() {
        System.out.println("适配FT卡读数据");
        return ftCard.readFT();
    }

    @Override
    public void writeSD(String msg) {
        System.out.println("适配FT卡写数据");
        ftCard.writeFT(msg);
    }
}

还有一种适配器模式是接口适配。当不希望实现一个接口中所有方法时，可以创建一个抽象类Adapter，实现所有方法，而此时我们只需要继承该抽象类即可

1.2、适配器模式优缺点

优点

  • 客户端通过适配器可以透明的访问目标接口
  • 复用现存的类，程序员不需要修改原有代码而重用现有的适配者类
  • 将目标类和适配者类解耦，解决了目标类和适配者类接口不一致问题
  • 在很多业务场景中符合开闭原则

缺点

  • 适配器编写过程需要结合业务场景全面考虑，可能会增加系统的复杂性。
  • 增加代码阅读难度，降低代码可读性，过多使用适配器会使系统代码变得凌乱

1.3、适配器模式应用场景

  • 以前开发系统存在满足新系统功能需求的类，但其接口和新系统不一致
  • 使用第三方提供的组件，但组件接口定义和自己要求的接口定义不一样。

二、桥接模式

现实生活中，某些类具有两个或多个维度的变化，如图形既可按形状分，又可按颜色分。如何设计类似于 Photoshop 这样的软件，能画不同形状和不同颜色的图形呢？如果用继承方式，m 种形状和 n 种颜色的图形就有 m×n 种，不但对应的子类很多，而且扩展困难。

当然，这样的例子还有很多，如不同颜色和字体的文字、不同品牌和功率的汽车、不同性别和职业的男女、支持不同平台和不同文件格式的媒体播放器等。如果用桥接模式就能很好地解决这些问题。

桥接模式的定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

2.1、实现方式

2.1.1、案例需求

开发一个跨平台的播放器，可以在不同的操作系统（Windows,Mac,Linux）上播放不同格式的视频（RMVB、AVI、WMV等）该播放器包含两个维度，适合使用桥接模式

2.1.2、桥接模式角色

桥接模式将抽象化部分与实现化部分分开，取消二者的继承关系，改用组合关系。

  • 抽象化（Abstraction）角色：定义抽象类，并包含一个对实现化对象的引用。
  • 扩展抽象化（Refined Abstraction）角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。
  • 实现化（Implementor）角色：定义实现化角色的接口，供扩展抽象化角色调用。
  • 具体实现化（Concrete Implementor）角色：给出实现化角色接口的具体实现。

2.1.3、代码实现

// 实现化角色,解码视频进行播放
public interface IVedioFile {
    // 解码功能
    void decode(String fileName);
}

// 具体实现化角色，可以对avi格式视频进行解码
public class AviVedioFile implements IVedioFile{
    @Override
    public void decode(String fileName) {
        System.out.println("avi视频文件：" + fileName);
    }
}
// 可以对Rmvb格式视频进行解码
public class RmvbVedioFile implements IVedioFile{
    @Override
    public void decode(String fileName) {
        System.out.println("Rmvb格式播放：" + fileName);
    }
}

// 抽象化角色
public abstract class AbstractOpratingSystem {

    protected IVedioFile vedioFile;

    public AbstractOpratingSystem(IVedioFile vedioFile) {
        this.vedioFile = vedioFile;
    }

    abstract void play(String fileName);
}

// 抽象化扩展类，window上的视频播放
public class WindowOpratingSystem extends AbstractOpratingSystem{

    public WindowOpratingSystem(IVedioFile vedioFile) {
        super(vedioFile);
    }

    @Override
    void play(String fileName) {
        vedioFile.decode(fileName);
    }
}
// Linux上的视频播放
public class LinuxOpratingSystem extends AbstractOpratingSystem{

    public LinuxOpratingSystem(IVedioFile vedioFile) {
        super(vedioFile);
    }

    @Override
    void play(String fileName) {
        vedioFile.decode(fileName);
    }
}


public class Client {
    public static void main(String[] args) {
        WindowOpratingSystem windowOpratingSystem = new WindowOpratingSystem(new AviVedioFile());
        windowOpratingSystem.play("流浪地球");
    }
}

2.2、桥接模式优缺点

通过上面的讲解，我们能很好的感觉到桥接模式遵循了里氏替换原则和依赖倒置原则，最终实现了开闭原则，对修改关闭，对扩展开放。

优点

  • 抽象与实现分离，扩展能力强
  • 符合开闭原则
  • 符合合成复用原则
  • 实现细节对客户透明

缺点

由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，能正确地识别出系统中两个独立变化的维度，这增加了系统的理解与设计难度。

2.3、桥接模式应用场景

  • 当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时。
  • 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。
  • 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。

三、代理模式

在有些情况下，一个客户不能或者不想直接访问另一个对象，这时需要找一个中介帮忙完成某项任务，这个中介就是代理对象。例如，购买火车票不一定要去火车站买，可以通过 12306 网站或者去火车票代售点买。又如找女朋友、找保姆、找工作等都可以通过找中介完成。

在软件设计中，使用代理模式的例子也很多，例如，要访问的远程对象比较大（如视频或大图像等），其下载要花很多时间。还有因为安全原因需要屏蔽客户端直接访问真实对象，如某单位的内部数据库等。代理模式分为静态代理 和 动态代理

3.1、静态代理

我们以卖火车票案例进行介绍

// 抽象主题，也就是售卖火车票的方法
public interface SellTickets {
    void sell();
}

// 真实主题类，真正的火车票是火车站售出的
public class TrainStation implements SellTickets{
    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}

// 代理类（代售点）
public class ProxyPoint implements SellTickets{

    protected TrainStation trainStation = new TrainStation();
    @Override
    public void sell() {
        System.out.println("代理点收取一些费用");
        trainStation.sell();
    }
}

public class Client {
    public static void main(String[] args) {
    	// 创建代理对象 
        ProxyPoint proxyPoint = new ProxyPoint();
        // 调用代理对象售票方法
        proxyPoint.sell();
    }
}

3.2、JDK动态代理

JDK提供了一个动态代理类Proxy，Proxy并不是代理对象的类，而是提供了一个创建代理对象的静态方法（newProxyInstance）来获取代理对象

// 定义售票接口
public interface SellTickets {

    void sell();
}
// 火车站实现售票接口，获取售票方法
public class TrainStation implements SellTickets{
    @Override
    public void sell() {
        System.out.println("火车站卖票");
    }
}
// 代理工厂类，生产代理对象
public class ProxyFactory {
    // 引用目标对象，也就是火车站对象
    private TrainStation trainStation = new TrainStation();
	// 创建代理对象
    public SellTickets getProxy() {
        // 返回代理对象

        /**
         * ClassLoader loader,
*          Class<?>[] interfaces,
*          InvocationHandler h
         */
        SellTickets proxyObject = (SellTickets)Proxy.newProxyInstance(
                trainStation.getClass().getClassLoader(),
                trainStation.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     *
                     * @param proxy：代理对象，和 proxyObject 是同一个
                     * @param method：对接口中的方法封装的Method函数
                     * @param args：被调用的方法的实际参数
                     * @return
                     * @throws Throwable
                     */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        System.out.println("代售点出售火车票，收取一些服务费用");
                        // 执行目标方法
                        Object obj = method.invoke(trainStation, args);
                        return obj;
                    }
                }
        );
        return proxyObject;
    }
}

public class Client {
    public static void main(String[] args) {
    	// 创建代理工厂对象
        ProxyFactory proxyFactory = new ProxyFactory();
        // 获取代理对象
        SellTickets proxy = proxyFactory.getProxy();
        proxy.sell();
    }
}

3.2.1、JDK动态地理细节

ProxyFactory并不是代理对象，JDK动态代理的代理对象是在运行中创建在内存中，类名为$Proxy0

  • 代理类 $Proxy0实现了 SellTickets，真实类和代理类都要实现相同的接口
  • 代理类将我们提供了匿名内部类对象传递给了父类

执行流程：

  • 在测试类中通过代理对象调用sell方法
  • 根据多态特征，执行的是代理类中的sell方法
  • 代理类中sell方法中又调用了 InvocationHandler 接口的自实现类对象的invoke方法
  • invoke方法通过反射执行了真实对象所属类中的sell方法

3.3、CGLIB动态代理

如果没有定义SellTickets接口，之定义了火车站类，那么JDK动态代理就无法使用了，因为JDK动态代理要求必须定义接口，对接口进行代理。

CGLIB是一个功能强大，高性能的代码生成包，它为没有实现接口的类提供代理，为JDK的动态代理提供很好的补充

3.3.1、引入maven依赖

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.9</version>
</dependency>

3.3.2、代码实现

public class TrainStation {

    public void sell() {
        System.out.println("火车站卖票");
    }

}

// 代理
public class ProxyFactory implements MethodInterceptor {

    private TrainStation trainStation = new TrainStation();

    public TrainStation getProxyObject() {
        // 创建Enhancer对象，类似于JDK代理中的Proxy
        Enhancer enhancer = new Enhancer();
        // 设置父类字节码对象
        enhancer.setSuperclass(TrainStation.class);

        // 设置回调函数
        enhancer.setCallback(this);
        // 创建代理对象
        TrainStation proxyObject = (TrainStation) enhancer.create();

        return proxyObject;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("CGLIB代替售票");
        // 调用方法，并接收返回值
        Object obj = method.invoke(trainStation, objects);
        return obj;
    }
}

public class Client {
    public static void main(String[] args) {
        ProxyFactory proxyFactory = new ProxyFactory();
        TrainStation proxyObject = proxyFactory.getProxyObject();
        proxyObject.sell();
    }
}

3.4、三种代理方式对比

3.4.1、CGLIB和JDK代理区别

CGLIB底层使用ASM字节码生成框架，使用字节码技术生成代理类，在JDK1.6之前比使用Java反射效率要高。唯一要注意的是，CGLIB不能对声明为final的类或方法进行代理，因为CGLIB原理是动态生成被代理类的子类。JDK1.8之后JDK代理比CGLIB代理效率要高。所以如果有接口使用JDK代理，没有接口使用CGLIB代理

3.4.2、静态代理和动态代理区别

动态代理与静态代理相比较，最大的好处在于接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理一样每一个方法都要重写。

如果接口新增一个方法，如果是静态代理，代理类和实现类都要改动。而动态代理就不会有这种问题。

3.5、代理模式优缺点

由于某些原因需要给某对象提供一个代理以控制对该对象的访问。这时，访问对象不适合或者不能直接引用目标对象，代理对象作为访问对象和目标对象之间的中介。

优点

  • 代理模式在客户端和目标对象之间起到一定中介作用和保护目标的作用
  • 代理对象可以扩展目标对象的功能
  • 代理模式能将客户端与目标对象分离，在一定程度上降低系统的耦合度，增强程序的可扩展性

缺点

  • 代理模式会造成系统设计中类的数量增加
  • 在客户端和目标对象之间增加一个代理对象，会造成请求处理速度变慢
  • 增加系统复杂度

3.6、应用场景

当无法或不想直接引用某个对象或访问某个对象存在困难时，可以通过代理对象来间接访问。使用代理模式主要有两个目的：一是保护目标对象，二是增强目标对象。
比如Spring中的AOP就是使用的动态代理，可以实现事务、日志、性能检测等功能

四、装饰者模式

上班族大多都有睡懒觉的习惯，每天早上上班时间都很紧张，于是很多人为了多睡一会，就会用方便的方式解决早餐问题。有些人早餐可能会吃煎饼，煎饼中可以加鸡蛋，也可以加香肠，但是不管怎么“加码”，都还是一个煎饼。在现实生活中，常常需要对现有产品增加新的功能或美化其外观，如房子装修、相片加相框等，都是装饰器模式。

在软件开发过程中，有时想用一些现存的组件。这些组件可能只是完成了一些核心功能。但在不改变其结构的情况下，可以动态地扩展其功能。所有这些都可以釆用装饰器模式来实现。

装饰器（Decorator）模式的定义：指在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式，它属于对象结构型模式。

4.1、实现方式

4.1.1、装饰者模式角色

通常情况下，扩展一个类的功能会使用继承方式来实现。但继承具有静态特征，耦合度高，并且随着扩展功能的增多，子类会很膨胀。如果使用组合关系来创建一个包装对象（即装饰对象）来包裹真实对象，并在保持真实对象的类结构不变的前提下，为其提供额外的功能，这就是装饰器模式的目标。

  • 抽象构件（Component）角色：定义一个抽象接口以规范准备接收附加责任的对象。
  • 具体构件（ConcreteComponent）角色：实现抽象构件，通过装饰角色为其添加一些职责。
  • 抽象装饰（Decorator）角色：继承抽象构件，并包含具体构件的实例，可以通过其子类扩展具体构件的功能。
  • 具体装饰（ConcreteDecorator）角色：实现抽象装饰的相关方法，并给具体构件对象添加附加的责任。

4.1.2、代码实现

我们通过给饮料添加各种佐料，比如添加牛奶，加冰等来对元饮品进行装饰

// 抽象的饮料类
public abstract class Drick {

    // 描述
    public String desc;

    // 价格
    private float price;

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        this.price = price;
    }
    
    // 抽象的价格计算方式
    abstract float cost();
}

// 咖啡类 抽象构件
public class Coffee extends Drick{

    // 单品咖啡成本计算
    @Override
    float cost() {
        return super.getPrice();
    }
}

// 装饰者类，聚合被装饰者，抽象装饰角色
public class Decorator extends Drick{

    // 组合饮品
    private Drick drick;

    public Decorator(Drick drick) {
        this.drick = drick;
    }

    public void setDrick(Drick drick) {
        this.drick = drick;
    }

    @Override
    float cost() {
        // 组合进行价格计算
        return super.getPrice() + drick.cost();
    }

    @Override
    public String getDesc() {
        return desc + "  " + getPrice() + "  " + drick.getDesc();
    }
}

// 具体饮品，具体构件角色
public class EspreeCoffee extends Coffee{

    public EspreeCoffee() {
        setDesc(" 意大利咖啡 ");
        setPrice(6.0f);
    }
}


public class LongBlack extends Coffee{
    public LongBlack() {
        setDesc(" longblack ");
        setPrice(5.0f);
    }
}

public class ShortBlack extends Coffee{

    public ShortBlack() {
        setDesc(" shortBlack ");
        setPrice(4.0f);
    }
}

// 具体装饰类 具体装饰角色
public class Chocolate extends Decorator{

    public Chocolate(Drick drick) {
        super(drick);
        setDesc(" 巧克力 ");
        setPrice(3.0f);
    }
}

public class Milk extends Decorator{

    public Milk(Drick drick) {
        super(drick);
        setDesc(" 牛奶 ");
        setPrice(2.0f);
    }

}

public class Soy extends Decorator{
    public Soy(Drick drick) {
        super(drick);
        setDesc(" 豆浆 ");
        setPrice(1.5f);
    }
}

// 使用
public class Client {
    public static void main(String[] args) {

        // 2分巧克力 + 1份牛奶 + 一个LongBlack咖啡
        Drick order = new LongBlack();
        System.out.println("一杯LongBlack咖啡费用是：" + order.cost());
        // 加一份牛奶
        order = new Milk(order);
        System.out.println("一杯LongBlack咖啡 + 一份牛奶的费用是：" + order.cost());

        // 加一分巧克力
        order = new Chocolate(order);
        System.out.println("一杯LongBlack咖啡 + 一份牛奶 + 1份巧克力的费用是：" + order.cost());

        // 在加一分巧克力
        order = new Chocolate(order);
        System.out.println("一杯LongBlack咖啡 + 一份牛奶 + 2份巧克力的费用是：" + order.cost());
    }
}

4.2、优缺点

优点

  • 装饰器是继承的有力补充，比继承灵活，在不改变原有对象的情况下，动态的给一个对象扩展功能，即插即用
  • 通过使用不用装饰类及这些装饰类的排列组合，可以实现不同效果
  • 装饰器模式完全遵守开闭原则

缺点

  • 装饰器模式会增加许多子类，过度使用会增加程序得复杂性。

4.3、应用场景

  • 需要给一个现有类添加附加职责，而又不能采用生成子类的方法进行扩充时。例如，该类被隐藏或者该类是终极类或者采用继承方式会产生大量的子类。
  • 当需要通过对现有的一组基本功能进行排列组合而产生非常多的功能时，采用继承关系很难实现，而采用装饰器模式却很好实现。
  • 当对象的功能要求可以动态地添加，也可以再动态地撤销时。

总结

本章介绍了结构型设计模式中的适配器模式、桥接模式、代理模式、装饰者模式，下一章介绍组合模式、外观模式、享元模式。

码字不易，还请看过之后给个三连啦！

石添的编程哲学
关注
  • 4
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
漫谈设计模式（一）：代理(Proxy)模式与适配器(Adapter)模式对比
小伍的程序之路
07-25 1465
1.前言 为什么要将代理模式与适配器模式放在一起来说呢？因为它们有许多的共同点，当然也有一些不同的地方。首先两者都是属于结构型模式。结构型模型是这样定义的： 结构型模式涉及到如何组合类和类以获得更大的结构，结构型类模式采用继承机制来组合接口或实现。 1）代理模式与适配器模式都分别有继承、接口方式实现的子分类模式。基于接口实现的代理模式称为静态代理模式、JDK（...
代理模式、装饰模式、桥接模式区别
guangdeshishe的博客
08-26 1400
定义： 代理模式：为其他对象提供一种代理，以控制该对象的访问 装饰模式：动态的给对象添加额外职责，就增加功能来说，装饰模式比生成子类更灵活 桥接模式：将抽象部分和实现部分分离，使得他们可以都可以独立的变化 区别 从实现目的来看： 代理模式主要是为了控制对象的访问（比如权限校验）或者为了更方便的访问对象（比如Binder中的代理使得跨进程调用方法就像调用本地方法一样） 装饰模式是为了增加新的功...
装饰器模式、代理模式、适配器模式对比
最新发布
云原生Java Web领域技术博客
04-28 1678
装饰器模式、代理模式和适配器模式都是结构型设计模式，它们的主要目标都是将，使得程序结构更加清晰。这里将装饰器模式、代理模式和适配器模式进行比较，主要是因为三个设计模式的类图结构相似度较高、且功能上存在一定的相似度。
设计模式之结构型模式（适配器、外观、组合、桥接、装饰、代理、享元模式）
5ingwings(SiHao)的博客
01-07 6774
设计模式之结构型模式 结构型模式： 如何将类与类或者对象与对象或者类与对象结合在一起形成更大的结构 因此可以分为： 类结构型模式：由多个类可以组合成一个更大的系统，在类结构型模式中一般只存在继承关系和实现关系 对象结构型模式： 关心类与对象的组合，通过关联关系使得在一个类中定义另一个类的实例对象，然后通过该对象调用其方法 并且符合合成复用原则，减少继承关系的使用 因此大部分结构...
设计模式之【适配器模式】，两个人之间确实需要月老的搭线~
秃了也弱了
05-09 792
适配器模式（Adapter Design Pattern）又叫变压器模式，这个模式就是用来做适配的，它将不兼容的接口转换为可兼容的接口，让原本由于接口不兼容而不能一起工作的类可以一起工作。属于结构型设计模式。也就是说，当前系统存在两种接口A和B，客户只支持访问A接口，但是当前系统没有A接口对象，但是有B接口对象，但客户无法识别B接口，因此需要通过一个适配器C，将B接口内容转换成A接口，从而使客户能够从A接口获取得到B接口内容。在软件开发中，基本上任何问题都可以通过增加一个中间层进行解决。
设计模式：适配器，桥接，代理模式的区别
weixin_38108266的博客
11-03 2524
适配器模式： 将一个类的接口转换成客户希望的另一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 比如：手机的usb数据线可以被看做适配器，不同的手机通过不同的usb数据线连接到电脑相同的usb接口上。还有，栈和队列被称为容器适配器，他们本身都是基于线性表来实现的，但是对外提供了特定的操作接口。 参考：https://www.cnblogs.com/-crazysnail/...
适配器模式：代理、适配器、桥接、装饰，这四个模式有何区别？
abc123mma的博客
07-08 567
适配器模式的应用场景是“接口不兼容”。那在实际的开发中，什么情况下才会出现接口不兼容呢？我建议你先自己思考一下这个问题，然后再来看我下面的总结。
装饰者模式和适配器模式
qq_41803278的博客
03-24 373
1. 装饰者模式 装饰者模式是比较常用的模式，比如Spring session、Mybatis缓存中以及JDK的java.io包中都有着广泛的应用。 1.定义 动态的将责任附加到对象身上。若要扩展功能，装饰者提供比继承更弹性的替代方案。 2.优缺点 优点：在不影响其他类的前提下增加功能，当不能使用继承的时候可以使用装饰者模式 缺点：使用装饰者模式使得小的类变多，甚至出现类爆...
代理模式、桥接模式、中介者模式区别和联系
tiancityycf的专栏
07-30 3319
参考：https://www.phpmianshi.com/?id=134 联系 在现实生活中，如房屋中介、买房人、卖房人，房屋中介是一个中介，因为它担任买房人和卖房人之间的相同； 房屋中介也是一个代理，它在卖房人眼前是买房人的代理，在卖房人眼前是买房人的代理； 最后房屋中介也是一个桥接，用于连接买房人和卖房人。那这字面意思相似的三者到底有什么不同的应用场景。 代理模式 场景 1. 最常见的就是数据库中间件，他们代理了数据库的访问，访问一个集群跟访问一个单机数据...
代理模式，适配器模式，装饰者模式，别再傻傻分不清楚了
hyhlmy的博客
08-09 943
代理模式，适配器模式，装饰者模式的区别 适配器模式主要解决接口转换的问题，代理模式主要解决对象无法直接访问的问题，装饰者模式主要用来增强功能。 怎么理解呢？首先看下适配器模式和代理模式的类图，细心观察会发现对于代理模式RealSubject实现了Subject的接口，而适配器模式的Adaptee并没有实现Target接口，这说明对于代理模式客户端最终访问的是同一个接口，而对于适配器模式，客户端最终访问的是不同的接口。所以适配器解决的是接口转换的问题，可以将A接口的请求转成B接口，而对于代理模式来说客户端调用
【设计模式】装饰者模式与适配器模式
xu_jieni
09-18 985
装饰模式（添加行为） 一、 定义：通过组合，装饰者模式动态的将责任添加到对象上，从而扩展对象的行为功能。 二、 概述： a) 装饰者和被装饰对象都有相同的超类型，所以在需要被装饰者对象的场合都可以使用装饰者对象代替 b) 装饰者可以在所委托被装饰者的行为之前或之后，加上自己的行为，从而达到特定的目的（实现行为的添加） c) 对象可以在任何时候被修饰，可以在运行时动态的，不限量的被
设计模式之适配器模式
学习不止境的博客
07-05 274
本文再来学习一个结构型设计模式：适配器模式，本文主要介绍它的两种实现方式，类适配器和对象适配器，以及 5 种常见的应用场景 针对这两种实现方式，在实际的开发中，到底该如何选择使用哪一种呢？判断的标准主要有两个，一个是 Adaptee 接口的个数，另一个是Adaptee 和 ITarget 的契合程度。 如果 Adaptee 接口并不多，那两种实现方式都可以。 如果 Adaptee 接口很多，而且 Adaptee 和 ITarget 接口定义大部分都相同，那我们推荐使用类适配器，因为 Adaptor 复用
代理模式-装饰器模式-适配器模式
weixin_57128596的博客
02-24 452
目录 适配器模式 装饰器模式 代理模式： 适配器模式 什么是是适配器模式呢？他的作用是什么呢？ 适配器模式，就是当老的接口已经不支持新的业务逻辑时，需要定义一个新的接口，实现新的业务，关键：老接口的实现类也能实现新接口的方法； 所以说我们要有新的业务接口，以及他的实现类； 问题来了，我们为啥要专门实现一个新接口的业务类呢？ 因为，我们的老接口实现的类需要增加新的业务方法，所以需要实例化一个新的业务对象，以便于调用新的业务方法； 总得来说，适配器模式就是增加新的业务方法，并
设计模式 - 代理模式、桥接模式、中介者模式、命令模式
等等... 大雄，有啦！
05-16 4986
相似点 开始的时候，这四个模式在名字上的意思有相似的地方，在实际生活中，如房屋中介、买房人、卖房人，房屋中介当然是一个中介，因为它负责买房人和卖房人之间的沟通；房屋中介也是一个代理，它在卖房人面前是买房人的代理，在卖房人面前时买房人的代理；房屋中介也是一个桥接，用于连接买房人和卖房人；房屋中介也可以是命令的传达者，买房人将买房的命令发送给中介，中介根据命令找到相应的卖房人。那这字面意思相似的四者
代理模式、适配器模式、装饰者模式的区别
走走停停的小码农的博客
05-17 1695
适配器 代理和装饰都是通过组合一个现存对象，通过调用该对象的方法 来实现自己的功能的，它们之间很相像，其实结构型模式都是以继承和组合的方式来实现新的 功能，如果单看实现过程，它们的确很相像，但如果从意图上分析，它们的区别就大了。 代理模式着重将复杂部分抽到中间层，通过这个中间层（代理层〉来控制对目标对象的访 问，它要求代理层和目标对象的接口相同。而适配器模式解决的恰恰是接口发生了变化导致现 有对象...
适配器模式、装饰器模式和代理模式的联系和区别
zjyzz13的博客
01-05 544
联系： 三者的限制条件层层递进，递进关系如下： 代理模式 装饰器模式 适配器模式 区别： 适配器模式是将一个类A装换成另一个类B。类A和类B的接口不同 装饰着模式是为一个类A增添新的功能，从而变成类B。类A和类B的接口相同，在构造器中传递对象参数可以动态的添加和撤销新的功能 代理模式是为一个类A转换操作类B。类A和类B的接
桥接模式和适配器模式异同
08-16
### 回答1： 桥接模式和适配器模式都是结构型设计模式，它们的目的都是解决两个不兼容的接口之间的问题，但它们的解决方式有所不同。 相同点： 1. 都是为了解决两个不兼容的接口之间的问题。 2. 都采用了对象组合的方式。 不同点： 1. 桥接模式是在不同的抽象层次上进行解耦，而适配器模式是在相同的抽象层次上进行解耦。 2. 桥接模式将抽象化和实现化解耦，使得它们可以独立变化，而适配器模式则是将原本不兼容的接口转换成兼容的接口，让它们可以一起工作。 3. 桥接模式中，抽象化和实现化可以分别扩展而互不影响，而适配器模式中，适配器是在实现原有接口的基础上添加了新的接口，两者存在一定的耦合性。 总之，桥接模式和适配器模式都是用来解决接口不兼容的问题，但是它们的实现方式和应用场景略有不同，需要根据具体情况选择使用哪种模式。 ### 回答2： 桥接模式和适配器模式是两种软件设计模式，它们具有一些相似之处，也存在一些不同之处。 1. 相同点： - 目的相似：桥接模式和适配器模式都是用于解决不同接口之间的兼容性问题，使得不同的类或对象能够协同工作。 - 都通过组合关系实现：桥接模式和适配器模式都是通过将一个接口与另一个接口进行组合，以实现兼容性和协同工作。 2. 不同点： - 使用场景不同：桥接模式主要用于解耦抽象部分和实现部分，使它们可以独立变化；而适配器模式则用于将一个类的接口转换成客户端所期望的接口，使得原本不兼容的接口能够协同工作。 - 目标对象不同：桥接模式的目标是将抽象和实现解耦，让它们可以独立变化；而适配器模式的目标是使得原本不兼容的接口能够协同工作，提供一种中间转换层。 - 引起变化的原因不同：桥接模式的变化主要来自于抽象和实现之间的变化，两者可以独立地进行扩展；而适配器模式的变化主要来自于客户端对接口的期望变化，需要进行接口的适配转换。 总结来说，桥接模式和适配器模式都是用于解决接口的兼容性问题，但应用场景和目标对象有所不同。桥接模式主要用于解决抽象和实现的耦合问题，适配器模式主要用于对接口进行转换，使得原本不兼容的接口能够协同工作。 ### 回答3： 桥接模式和适配器模式都是常用的软件设计模式，用于处理不兼容的程序组件之间的交互。它们的异同如下： 相同点： 1. 目标：两种模式都用于实现不同组件之间的通信，并且不改变这些组件的源码。 2. 解决方案：两种模式都通过创建一个中间层来解决组件之间的不兼容性问题。 3. 实现方式：两种模式都使用了对象间的关联关系来实现。 不同点： 1. 目的不同：桥接模式的目的是将抽象与实现相分离，使得它们可以独立地变化。适配器模式的目的是将一个类的接口转换为客户端所期望的另一个接口。 2. 设计原则：桥接模式遵循了开闭原则，通过将抽象部分和具体部分分离，使得它们可以独立地扩展。适配器模式尊重单一职责原则，通过适配器类将不相关的类进行适配，保持职责的单一性。 3. 使用场景：桥接模式主要用于系统可扩展性的设计，能够方便地增加新的抽象和实现。适配器模式主要用于现有系统间的兼容性问题，能够使得不兼容的类可以协同工作。 4. 结构不同：桥接模式将抽象部分与具体实现分离，抽象部分持有一个实现部分的引用，并委托给实现部分完成实际工作。适配器模式通过适配器类将被适配者包装起来，提供客户端期望的接口。 综上所述，桥接模式和适配器模式有相似之处，例如解决不兼容的组件之间的交互问题，但也有明显的区别，例如目的不同、设计原则不同、使用场景不同和结构不同等。在实际应用中，根据具体的需求，选择适合的模式能够更好地解决问题。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

石添的编程哲学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值