精华内容
下载资源
问答
  • 概述 如果去欧洲国家去旅游的话,他们的插座如下图最左边,是欧洲标准。 而我们使用的插头如下图最右边的。因此我们的笔记本电脑,手机在当地不能直接充电。 所以就需要一个插座转换器...适配器模式分为类适配器模式

    概述

    如果去欧洲国家去旅游的话,他们的插座如下图最左边,是欧洲标准。

    而我们使用的插头如下图最右边的。因此我们的笔记本电脑,手机在当地不能直接充电。

    所以就需要一个插座转换器,转换器第1面插入当地的插座,第2面供我们充电,这样使得我们的插头在当地能使用

    生活中这样的例子很多,手机充电器(将220v转换为5v的电压),读卡器等,其实就是使用到了适配器模式。

    定义:

    将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。

    适配器模式分为类适配器模式和对象适配器模式,

    前者类之间的耦合度比后者高,且要求程序员了解现有组件库中的相关组件的内部结构,所以应用相对较少些。

    5.2.2 结构

    适配器模式(Adapter)包含以下主要角色:

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

    5.2.3 类适配器模式

    实现方式:定义一个适配器类来实现当前系统的业务接口,同时又继承现有组件库中已经存在的组件。

    【例】读卡器

    现有一台电脑只能读取SD卡,而要读取TF卡中的内容的话就需要使用到适配器模式。创建一个读卡器,将TF卡中的内容读取出来。

    类图如下:



    SDCard.java

    package com.itheima.pattern.adapter.class_adapter;
    
    /**
     * @version v1.0
     * @ClassName: SDCard
     * @Description: 目标接口
     * @Author: dym
     */
    public interface SDCard {
    
        //从SD卡中读取数据
        String readSD();
        //往SD卡中写数据
        void writeSD(String msg);
    }
    

    SDCardImpl.java

    package com.itheima.pattern.adapter.class_adapter;
    
    /**
     * @version v1.0
     * @ClassName: SDCardImpl
     * @Description: 具体的SD卡
     * @Author: dym
     */
    public class SDCardImpl implements SDCard {
    
        public String readSD() {
            String msg = "SDCard read msg : hello word SD";
            return msg;
        }
    
        public void writeSD(String msg) {
            System.out.println("SDCard write msg :" + msg);
        }
    }
    

    TFCard.java

    package com.itheima.pattern.adapter.class_adapter;
    
    /**
     * @version v1.0
     * @ClassName: TFCard
     * @Description: 适配者类的接口
     * @Author: dym
     */
    public interface TFCard {
    
        //从TF卡中读取数据
        String readTF();
        //往TF卡中写数据
        void writeTF(String msg);
    }
    

    TFCardImpl.java

    package com.itheima.pattern.adapter.class_adapter;
    
    /**
     * @version v1.0
     * @ClassName: TFCardImpl
     * @Description: 适配者类
     * @Author: dym
     */
    public class TFCardImpl implements TFCard {
    
        public String readTF() {
            String msg = "TFCard read msg : hello word TFcard";
            return msg;
        }
    
        public void writeTF(String msg) {
            System.out.println("TFCard write msg :" + msg);
        }
    }
    

    SDAdapterTF.java

    package com.itheima.pattern.adapter.class_adapter;
    
    /**
     * @version v1.0
     * @ClassName: SDAdapterTF
     * @Description: 适配器类
     * @Author: dym
     */
    public class SDAdapterTF extends TFCardImpl implements SDCard {
    
        public String readSD() {
            System.out.println("adapter read tf card");
            return readTF();
        }
    
        public void writeSD(String msg) {
            System.out.println("adapter write tf card");
            writeTF(msg);
        }
    }
    

    Computer.java

    package com.itheima.pattern.adapter.class_adapter;
    
    /**
     * @version v1.0
     * @ClassName: Computer
     * @Description: 计算机类
     * @Author: dym
     */
    public class Computer {
    
        //从SD卡中读取数据
        public String readSD(SDCard sdCard) {
            if(sdCard == null) {
                throw  new NullPointerException("sd card is not null");
            }
            return sdCard.readSD();
        }
    }
    

    Client.java

    package com.itheima.pattern.adapter.class_adapter;
    
    /**
     * @version v1.0
     * @ClassName: Client
     * @Description: TODO(一句话描述该类的功能)
     * @Author: dym
     */
    public class Client {
        public static void main(String[] args) {
            //创建计算机对象
            Computer computer = new Computer();
            //读取SD卡中的数据
            String msg = computer.readSD(new SDCardImpl());
            System.out.println(msg);
    
            System.out.println("===============");
            //使用该电脑读取TF卡中的数据
            //定义适配器类
            String msg1 = computer.readSD(new SDAdapterTF());
            System.out.println(msg1);
        }
    }
    



    类适配器模式违背了合成复用原则。

    类适配器是客户类有一个接口规范的情况下可用,反之不可用。



    对象适配器模式

    实现方式:对象适配器模式可釆用将现有组件库中已经实现的组件引入适配器类中,该类同时实现当前系统的业务接口。

    【例】读卡器

    我们使用对象适配器模式将读卡器的案例进行改写。类图如下:

    代码如下:

    类适配器模式的代码,我们只需要修改适配器类(SDAdapterTF)和测试类。

     

    SDCard.java

    package com.itheima.pattern.adapter.object_adapter;
    
    /**
     * @version v1.0
     * @ClassName: SDCard
     * @Description: 目标接口
     * @Author: dym
     */
    public interface SDCard {
    
        //从SD卡中读取数据
        String readSD();
        //往SD卡中写数据
        void writeSD(String msg);
    }
    

    SDCardImpl.java

    package com.itheima.pattern.adapter.object_adapter;
    
    /**
     * @version v1.0
     * @ClassName: SDCardImpl
     * @Description: 具体的SD卡
     * @Author: dym
     */
    public class SDCardImpl implements SDCard {
    
        public String readSD() {
            String msg = "SDCard read msg : hello word SD";
            return msg;
        }
    
        public void writeSD(String msg) {
            System.out.println("SDCard write msg :" + msg);
        }
    }
    

    TFCard.java

    package com.itheima.pattern.adapter.object_adapter;
    
    /**
     * @version v1.0
     * @ClassName: TFCard
     * @Description: 适配者类的接口
     * @Author: dym
     */
    public interface TFCard {
    
        //从TF卡中读取数据
        String readTF();
        //往TF卡中写数据
        void writeTF(String msg);
    }
    

    TFCardImpl.java

    package com.itheima.pattern.adapter.object_adapter;
    
    /**
     * @version v1.0
     * @ClassName: TFCardImpl
     * @Description: 适配者类
     * @Author: dym
     */
    public class TFCardImpl implements TFCard {
    
        public String readTF() {
            String msg = "TFCard read msg : hello word TFcard";
            return msg;
        }
    
        public void writeTF(String msg) {
            System.out.println("TFCard write msg :" + msg);
        }
    }
    

    SDAdapterTF.java

    package com.itheima.pattern.adapter.object_adapter;
    
    /**
     * @version v1.0
     * @ClassName: SDAdapterTF
     * @Description: 适配器类
     * @Author: dym
     */
    public class SDAdapterTF implements SDCard {
    
        //声明适配者类
        private TFCard tfCard;
    
        public SDAdapterTF(TFCard tfCard) {
            this.tfCard = tfCard;
        }
    
        public String readSD() {
            System.out.println("adapter read tf card");
            return tfCard.readTF();
        }
    
        public void writeSD(String msg) {
            System.out.println("adapter write tf card");
            tfCard.writeTF(msg);
        }
    }
    

    Computer.java

    package com.itheima.pattern.adapter.object_adapter;
    
    /**
     * @version v1.0
     * @ClassName: Computer
     * @Description: 计算机类
     * @Author: dym
     */
    public class Computer {
    
        //从SD卡中读取数据
        public String readSD(SDCard sdCard) {
            if(sdCard == null) {
                throw  new NullPointerException("sd card is not null");
            }
            return sdCard.readSD();
        }
    }
    

    Client.java

    package com.itheima.pattern.adapter.object_adapter;
    
    
    /**
     * @version v1.0
     * @ClassName: Client
     * @Description: TODO(一句话描述该类的功能)
     * @Author: dym
     */
    public class Client {
        public static void main(String[] args) {
            //创建计算机对象
            Computer computer = new Computer();
            //读取SD卡中的数据
            String msg = computer.readSD(new SDCardImpl());
            System.out.println(msg);
    
            System.out.println("===============");
            //使用该电脑读取TF卡中的数据
            //创建适配器类对象
            SDAdapterTF sdAdapterTF = new SDAdapterTF(new TFCardImpl());
            String msg1 = computer.readSD(sdAdapterTF);
            System.out.println(msg1);
        }
    }
    



    注意:还有一个适配器模式是接口适配器模式。

               当不希望实现一个接口中所有的方法时,可以创建一个抽象类Adapter ,实现所有方法。

               而此时我们只需要继承该抽象类即可。

    应用场景

    • 以前开发的系统存在满足新系统功能需求的类,但其接口同新系统的接口不一致。
    • 使用第三方提供的组件,但组件接口定义和自己要求的接口定义不同。
    展开全文
  • 对象适配器模式与类适配器模式相同,知识将Adapter类修改了,不再是继承src类,而是持有src类的实例,以解决兼容性问题。即持有src类,实现dst接口,完成src——>dst的适配 根据“合成复用原则”,在系统中尽量...

    对象适配器模式与类适配器模式相同,知识将Adapter类修改了,不再是继承src类,而是持有src类的实例,以解决兼容性问题。即持有src类,实现dst接口,完成src——>dst的适配

    根据“合成复用原则”,在系统中尽量使用关联关系来替代继承关系。
    以生活充电器例子来讲解适配器,充电器本身相当于Adapter。220V相当于src(被适配者),我们的目标是dst(目标)是5v直流电,使用对象适配器模式完成

    类图:
    在这里插入图片描述

    package objectAdapter;
    //被适配的类
    public class Voltag220V {
    	public int output220V() {
    		//输出220V的电压,不变
    		int src=220;
    		System.out.println("电压="+src+"伏特");
    		return src;
    		
    	}
    
    }
    
    
    package objectAdapter;
    //适配接口
    public interface IVoltag5V {
    	public int output5V();
    }
    
    
    package objectAdapter;
    //适配器类
    public class VoltagAdapter  implements IVoltag5V{
    
    	private Voltag220V voltag220V;//关联关系——聚合关系
    	
    	/**
    	 * 通过构造器传入一个Voltag220V实例
    	 */
    	public VoltagAdapter(Voltag220V voltag220v) {
    		
    		this.voltag220V = voltag220v;
    	}
    
    	@Override
    	public int output5V() {
    		int dst=0;
    		if(null!=voltag220V) {
    			int src=voltag220V.output220V();//获取220V电压
    			System.out.println("使用对象适配器,进行适配~~");
    			dst=src/44;
    			System.out.println("适配完成,输出的电压="+dst);
    		}
    		return dst;
    	}
    	
    
    }
    
    
    package objectAdapter;
    
    public class Phone {
    //充电的方法
    	public void charging(IVoltag5V iVoltag5V) {
    		if(iVoltag5V.output5V()==5) {
    			System.out.println("电压为5V,可以充电~~");
    		}else if(iVoltag5V.output5V()>5) {
    			System.out.println("电压大于5V,不可以充电~~");
    		}
    	}
    }
    
    
    package objectAdapter;
    
    public class Client {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println("==类适配器模式===");
    		Phone phone=new Phone();
    		phone.charging(new VoltagAdapter(new Voltag220V()));
    
    	}
    
    }
    
    

    对象适配器模式:和类适配器模式同一种思想,只不过实现方式不同。根据合成复用原则,使用组合代替了继承,所以它解决了类适配器必须继承src的局限性问题,也不再要求dst必须是接口

    展开全文
  • 现实生活中的适配器例子 ...主要分为三类:类适配器模式、对象适配器模式、接口适配器模式 工作原理 适配器模式:将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容 从用户的角度看不到

    现实生活中的适配器例子

    泰国插座用的是两孔的(欧标),可以买个多功能转换插头(适配器) ,这样就可以使用了。
    在这里插入图片描述

    基本介绍

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

    工作原理

    1. 适配器模式:将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼容
    2. 从用户的角度看不到被适配者,是解耦的
    3. 用户调用适配器转化出来的目标接口方法,适配器再调用被适配者的相关接口方法
    4. 用户收到反馈结果,感觉只是和目标接口交互,如图
      在这里插入图片描述

    类适配器模式

    类适配器模式介绍

    基本介绍:Adapter 类,通过继承src 类,实现dst 类接口,完成src->dst 的适配。

    类适配器模式应用实例

    1. 应用实例说明
      以生活中充电器的例子来讲解适配器,充电器本身相当于Adapter,220V 交流电相当于src (即被适配者),我们的目dst(即目标)是5V 直流电
    2. 思路分析(类图)
      在这里插入图片描述
    3. 代码实现

    IVoltage5V.java:适配接口(需要的)

    //适配接口
    public interface IVoltage5V {
    	public int output5V();
    }
    

    Voltage220V.java:被适配的类(要转换的)

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

    VoltageAdapter.java:适配器类(转换器)

    //适配器类
    public class VoltageAdapter extends Voltage220V implements IVoltage5V {
    
    	@Override
    	public int output5V() {
    		// TODO Auto-generated method stub
    		//获取到220V电压
    		int srcV = output220V();
    		int dstV = srcV / 44 ; //转成 5v
    		return dstV;
    	}
    
    }
    

    Phone.java

    public class Phone {
    
    	//充电
    	public void charging(IVoltage5V iVoltage5V) {
    		if(iVoltage5V.output5V() == 5) {
    			System.out.println("电压为5V, 可以充电~~");
    		} else if (iVoltage5V.output5V() > 5) {
    			System.out.println("电压大于5V, 不能充电~~");
    		}
    	}
    }
    

    Client.java

    public class Client {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println(" === 类适配器模式 ====");
    		Phone phone = new Phone();
    		phone.charging(new VoltageAdapter());
    	}
    
    }
    

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

    1. Java 是单继承机制,所以类适配器需要继承src 类这一点算是一个缺点, 因为这要求dst 必须是接口,有一定局限性;
    2. src 类的方法在Adapter 中都会暴露出来,也增加了使用的成本。
    3. 由于其继承了src 类,所以它可以根据需求重写src 类的方法,使得Adapter 的灵活性增强了。

    对象适配器模式

    对象适配器模式介绍

    1. 基本思路和类的适配器模式相同,只是将Adapter 类作修改,不是继承src 类,而是持有src 类的实例,以解决兼容性的问题。即:持有src 类,实现dst 类接口,完成src->dst 的适配
    2. 根据“合成复用原则”,在系统中尽量使用关联关系(聚合)来替代继承关系
    3. 对象适配器模式是适配器模式常用的一种

    对象适配器模式应用实例

    1. 应用实例说明
      以生活中充电器的例子来讲解适配器,充电器本身相当于Adapter,220V 交流电相当于src (即被适配者),我们的目dst(即目标)是5V 直流电,使用对象适配器模式完成。
    2. 思路分析(类图):只需修改适配器即可, 如下:
      在这里插入图片描述
    3. 代码实现(只改了客户端和适配器类:适配器类改为聚合关系

    VoltageAdapter.java

    //适配器类
    public class VoltageAdapter  implements IVoltage5V {
    
    	private Voltage220V voltage220V; // 关联关系-聚合
    	
    	
    	//通过构造器,传入一个 Voltage220V 实例
    	public VoltageAdapter(Voltage220V voltage220v) {
    		
    		this.voltage220V = voltage220v;
    	}
    
    
    	@Override
    	public int output5V() {
    		
    		int dst = 0;
    		if(null != voltage220V) {
    			int src = voltage220V.output220V();//获取220V 电压
    			System.out.println("使用对象适配器,进行适配~~");
    			dst = src / 44;
    			System.out.println("适配完成,输出的电压为=" + dst);
    		}
    		
    		return dst;
    		
    	}
    
    }
    

    Client.java

    public class Client {
    
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		System.out.println(" === 对象适配器模式 ====");
    		Phone phone = new Phone();
    		phone.charging(new VoltageAdapter(new Voltage220V()));
    	}
    
    }
    

    对象适配器模式注意事项和细节

    1. 对象适配器和类适配器其实算是同一种思想,只不过实现方式不同。根据合成复用原则,使用组合替代继承, 所以它解决了类适配器必须继承src 的局限性问题,也不再要求dst必须是接口。
    2. 使用成本更低,更灵活。

    接口适配器模式

    接口适配器模式介绍

    1. 一些书籍称为:适配器模式(Default Adapter Pattern)或缺省适配器模式
    2. 核心思路:当不需要全部实现接口提供的方法时,可先设计一个抽象类实现接口,并为该接口中每个方法提供一个默认实现(空方法),那么该抽象类的子类可有选择地覆盖父类的某些方法来实现需求
    3. 适用于一个接口不想使用其所有的方法的情况。

    最简单的实例

    1. 类图:
      在这里插入图片描述
      2)代码实现:

    Interface4.java

    public interface Interface4 {
    	public void m1();
    	public void m2();
    	public void m3();
    	public void m4();
    }
    

    AbsAdapter.java

    //在AbsAdapter 我们将 Interface4 的方法进行默认实现
    public abstract class AbsAdapter implements Interface4 {
    
    	//默认实现
    	public void m1() {
    	}
    
    	public void m2() {
    	}
    
    	public void m3() {
    	}
    
    	public void m4() {
    	}
    }
    

    Client.java

    public class Client {
    	public static void main(String[] args) {
    		
    		AbsAdapter absAdapter = new AbsAdapter() {
    			//只需要去覆盖我们 有需要地使用 接口方法
    			@Override
    			public void m1() {
    				// TODO Auto-generated method stub
    				System.out.println("使用了m1的方法");
    			}
    		};
    		
    		absAdapter.m1();
    	}
    }
    

    接口适配器模式应用实例

    1)Android中的属性动画ValueAnimator类(略)

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

    1. SpringMvc 中的HandlerAdapter, 就使用了适配器模式
    2. SpringMVC 处理请求的流程回顾
    3. 使用HandlerAdapter 的原因分析:
      可以看到处理器的类型不同,有多重实现方式,那么调用方式就不是确定的,如果需要直接调用Controller 方法,需要调用的时候就得不断是使用if else 来进行判断是哪一种子类然后执行。那么如果后面要扩展Controller,就得修改原来的代码,这样违背了OCP 原则。
    4. 代码分析+Debug 源码
      在这里插入图片描述
    5. 动手写SpringMVC通过适配器设计模式获取到对应的Controller的源码
      1)类图:
      在这里插入图片描述
      2)代码实现

    说明
    • Spring定义了一个适配接口,使得每一种Controller有一种对应的适配器实现类
    • 适配器代替controller执行相应的方法
    • 扩展Controller 时,只需要增加一个适配器类就完成了SpringMVC的扩展了,
    • 这就是设计模式的力量

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

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

    总结

    类适配器,继承src
    对象适配器,聚合src
    接口适配器,实现接口src,(可以抽象适配器类实现src,再默认实现,再根据需要在子类实现相应的方法

    展开全文
  • 适配器模式概述: 如果去欧洲国家去旅游的话,他们的插座如下图最左边,是欧洲标准。而我们使用的插头如下图最右边的。因此我们的笔记本电脑,手机在当地不能直接充电。所以就需要一个插座转换器,转换器第1面插入...

    适配器模式概述:

    如果去欧洲国家去旅游的话,他们的插座如下图最左边,是欧洲标准。而我们使用的插头如下图最右边的。因此我们的笔记本电脑,手机在当地不能直接充电。所以就需要一个插座转换器,转换器第1面插入当地的插座,第2面供我们充电,这样使得我们的插头在当地能使用。生活中这样的例子很多,手机充电器(将220v转换为5v的电压),读卡器等,其实就是使用到了适配器模式。
    在这里插入图片描述

    • 定义: 将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
    • 适配器模式的结构:
      适配器模式(Adapter)包含以下主要角色:

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

    对照上图理解:在这里插入图片描述

    • 适配器模式的分类
      (1)、类适配器(通过继承,耦合高)
      (2)、对象适配器(通过组合,聚合)
      前者类之间的耦合度比后者高,且要求程序员了解现有组件库中的相关组件的内部结构,所以应用相对较少些。

    类适配器模式:

    【例】读卡器

    现有一台电脑只能读取SD卡,而要读取TF卡中的内容的话就需要使用到适配器模式。创建一个读卡器,将TF卡中的内容读取出来。
    类图如下:UML类图

    • 电脑只能读取写入SDcard类型的数据,不能读取和写入TFCard类型里面的数据,要想电脑能对TFCard里面的数据进行读取,就要用到适配器模式。
    //SD卡的接口
    public interface SDCard {
        //读取SD卡方法
        String readSD();
        //写入SD卡功能
        void writeSD(String msg);
    }
    
    //SD卡实现类
    public class SDCardImpl implements SDCard {
        public String readSD() {
            String msg = "sd card read a msg :hello word SD";
            return msg;
        }
    
        public void writeSD(String msg) {
            System.out.println("sd card write msg : " + msg);
        }
    }
    
    //电脑类
    public class Computer {
    
        public String readSD(SDCard sdCard) {
            if(sdCard == null) {
                throw new NullPointerException("sd card null");
            }
            return sdCard.readSD();
        }
    }
    
    //TF卡接口
    public interface TFCard {
        //读取TF卡方法
        String readTF();
        //写入TF卡功能
        void writeTF(String msg);
    }
    
    //TF卡实现类
    public class TFCardImpl implements TFCard {
    
        public String readTF() {
            String msg ="tf card read msg : hello word tf card";
            return msg;
        }
    
        public void writeTF(String msg) {
            System.out.println("tf card write a msg : " + msg);
        }
    }
    
    //定义适配器类(SD兼容TF)
    public class SDAdapterTF extends TFCardImpl implements SDCard {
    
        public String readSD() {
            System.out.println("adapter read tf card ");
            return readTF();
        }
    
        public void writeSD(String msg) {
            System.out.println("adapter write tf card");
            writeTF(msg);
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            Computer computer = new Computer();
            SDCard sdCard = new SDCardImpl();
            System.out.println(computer.readSD(sdCard));
    
            System.out.println("------------");
    
            SDAdapterTF adapter = new SDAdapterTF();
            System.out.println(computer.readSD(adapter));
        }
    }
    
    • 缺点
      类适配器模式违背了合成复用原则。类适配器是客户类有一个接口规范的情况下可用,反之不可用。

    对象适配器模式

    实现方式:对象适配器模式可釆用将现有组件库中已经实现的组件引入适配器类中,该类同时实现当前系统的业务接口。
    上面的案例:使用对象适配器模式的类图
    在这里插入图片描述
    可以发现,其他地方没有改动,改动的只是适配器适配者之间的联系方式,原来通过适配器继承适配者实现类,现在通过适配器聚合适配者接口

    • 优点:
      (1)目标接口,没有标准接口的时候还是可用的,直接继承目标接口的实现就行了。
      (2)对象适配器模式遵守了合成复用原则
    //创建适配器对象(SD兼容TF)
    public class SDAdapterTF  implements SDCard {
    
        private TFCard tfCard;
    
        public SDAdapterTF(TFCard tfCard) {
            this.tfCard = tfCard;
        }
    
        public String readSD() {
            System.out.println("adapter read tf card ");
            return tfCard.readTF();
        }
    
        public void writeSD(String msg) {
            System.out.println("adapter write tf card");
            tfCard.writeTF(msg);
        }
    }
    
    //测试类
    public class Client {
        public static void main(String[] args) {
            Computer computer = new Computer();
            SDCard sdCard = new SDCardImpl();
            System.out.println(computer.readSD(sdCard));
    
            System.out.println("------------");
    
            TFCard tfCard = new TFCardImpl();
            SDAdapterTF adapter = new SDAdapterTF(tfCard);
            System.out.println(computer.readSD(adapter));
        }
    }
    

    使用场景

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

    展开全文
  • 一、对象适配器模式介绍 基本思路和类的适配器模式相同,只是将Adapter类作修改,不是继承src类,而是持有src类的实例,以解决兼容性的问题。 即:持有 src类,实现 dst 类接口,完成src->dst的适配。 根据...
  • 在设计模式中,也存在一种类似的模式,存在两个接口不同的类,可以使用一个适配器类来将一个接口转换为客户希望的另一个接口,称为适配器模式。 1、适配器模式适配器模式中引入了一个被称为适
  • } } 三、对象适配器模式 以上所讲的是类适配器模式,接下来介绍一下对象适配器模式对象适配器模式介绍: 基本思路和类的适配器模式相同,只是将Adapter类作修改,不是继承Adaptee类,而是持有Adaptee的实例,以...
  • 适配器模式的定义: 将一个类的接口变成客户端所期待的另一种接口,从而使原本因接口不匹配而无法工作的两个类能够在一起工作;...对象适配器:通过关联关系完成适配:[从在多个被适配者] 通过依赖注入,注入多...
  • 适配器模式一、适配器模式的概念和角色(一)、适配器的概念(二)、适配器的角色二、适配器的应用模式三、类适配器的代码示例四、对象适配器的代码示例五、接口适配器的代码示例六、适配器和装饰器模式的对比七、...
  • 适配器模式 ...根据适配器类与适配者类的关系不同,适配器模式可分为对象适配器和类适配器两种,在对象适配器模式中,适配器与适配者之间是关联关系;在类适配器模式中,适配器与适配者之间是继承(或实
  • 结构三、类适配器模式四、对象适配器模式五、接口适配器模式六、适用场景 一、概述 如果去欧洲国家去旅游的话,他们的插座如下图最左边,是欧洲标准。而我们使用的插头如下图最右边所示,因此我们的笔记本电脑、...
  • 对象适配器设计模式

    2020-06-02 07:54:43
    对象适配器设计模式——我的理解 当我们要访问的接口A中没有我们想要的方法 ,却在另一个接口B中发现了合适的方法,我们又不能改变访问接口A,在这种情况下,我们可以定义一个适配器p来进行中转,这个适配器p要实现...
  • 通常我们通过修改该类的接口来解决这种接口不兼容的情形,但是如果我们不愿意为了一个应用而修改各原接口,或者我们压根儿就没有对象的源代码的时候,适配器模式就会派上用场了。 适配器的优点: 1、将目标类和...
  • I . 适配器模式概念 II . 适配器模式 适用场景 III . 适配器模式 优缺点 IV . 适配器模式 与 外观模式对比 V . 适配器模式 相关角色 ( 重点 ) ... 适配器模式 ( 对象适配器 ) 代码实现流程 ( 重点 )
  • 设计模式-适配器模式:将一个类的接口转换成客户希望的另外一个接口,使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
  • 适配器模式适配器模式的应用场景类适配器对象适配器接口适配器适配器模式在源码中的体现适配器模式和装饰器模式对比适配器模式的优缺点 适配器模式 ( Adapter Pattern )又叫做变压器模式,它的功能是将一个类的接口...
  • 下面来说一下适配器模式, 说起适配器模式不妨举个例子 手机充电器, 我们手机充电的时候会把220V的电压转为5V(现在手机基本上都是5V), 这就和我们要说的适配器模式很像, 下面围绕着这个例子来写一下代码 类适配器 ...
  • 适配器模式,既是类结构模式又是对象结构模式。 (2)适配器模式:将一个类的接口转换成客户希望的另一个接口,让那些接口不兼容的类可以一起工作。 二、结构与实现 结构 (1)Target(目标抽象类):目标抽象...
  • 说到适配器模式最多的最经典的案例就是插座,其实...3)主要分为三类:类适配器模式,对象适配器模式,接口适配器模式 方式一:类适配器模式 //被适配器的类 public class Voltage220V { //输出电压220V public int
  • >什么是适配器模式?...本文着重介绍最常用的对象适配器模式。 >适配器模式样例 观察下面的样例代码:(对象适配器模式,最常用的适配器模式) 注意!本篇讲的是Plugin式的对象适配器,用于在系统中...
  • 适配器模式动机 能够使类和对象结合到一起形成更大的结构。 能够使原来不兼容的事物可以一起工作,这个新的设备称为适配器。 就像我们买的有些平板没有耳机插孔,就需要一个充钱器插口转接耳机插口的一个适配器。...
  • 最近在看《Think In JAVA》,其中在讲解继承,组合,抽象类和接口的时候,提到了题中的几个设计模式。这几个设计模式也确实让我更好的理解了JAVA中各个数据结构的含义。今天就结合书本还有自己的理解,稍微整理一下...
  • 适配器模式(Adapter模式)详解 在现实生活中,经常出现两个对象因接口不兼容而不能在一起工作的实例,这时需要第三者进行适配。例如,讲中文的人同讲英文的人对话时需要一个翻译,用直流电的笔记本电脑接交流电源时...
  • 适配器模式+源码分析

    2021-06-20 15:15:54
    概念:适配器模式(Adapter Pattern)是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式,它结合了两个独立接口的功能,主要的目的是兼容性,让原本因接口不匹配不能一起工作
  • 对象适配器介绍: 1、基本思路与类适配器...3、对象适配器适配器模式中最常使用的适配器模式 需求描述:依然是充电器的案例,不知道的请看上一节《设计模式之适配器模式(类适配器)》 类图: 运行结果: ...
  • java适配器模式实例解析

    千次阅读 2018-06-02 11:43:15
    适配器模式作为一种结构型设计模式,在软件系统设计开发中使用到的频率非常之高,深受开发人员的青睐。本文会讲解适配器模式的知识要点,以及在实际项目中所使用的真实案例。 1、适配器模式概述: 适配器模式...
  • 文章目录一、简介1.1 引入1.2 定义1.3 模式组成二、适配器模式分类2.1 类适配器2.2 对象适配器2.3 接口适配器三、实例3.1 实例3.2 步骤3.3 UML类图3.4 对象适配器解题的UML类图四、优缺点4.1 优点4.2 缺点五、应用...
  • 一、引言 富兰克林揭秘了雷电的真实面目,那我们是否设想过将雷电储存下来呢?生活中如果买了国外的电器(美国、日本)使用电压为110...电源适配器实现能使用220V电压方法,但实质调用的是使电器能使用110V电压这一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,283
精华内容 13,313
关键字:

原则对象适配器模式