设计模式-适配器模式（类适配器、对象适配器、接口适配器详解）

冷不防 2022-10-29 07:47 288阅读 0赞

### 文章目录 ###

*  适配器模式
 *  类适配器
 *  对象适配器
 *  接口适配器
 *  总结

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][20210315204319128.png_pic_center]

# 适配器模式 #

--------------------

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

工作原理  
将一个类的接口转换成另一种接口，让原本接口不兼容的类可以兼容。从用户的角度看不到被适配者，是解耦的/。用户调用适配器转化出来的目标接口方法，适配器再调用被适配者的相关接口方法，用户收到反馈结果，感觉只是和目标接口交互。

简单来说，适配器模式就像个插头转换器，让不同标准的插头和插座可以一起使用，而插座就是原来的接口，插头是用户期望的接口。或者类比电源适配器，把原来的220V电压转换成5V电压等。

# 类适配器 #

--------------------

顾名思义，通过适配器通过类来实现，以类来继承和实现接口的方式，来获取被适配类的信息并转换输出重写到适配接口。即`Adapter`类，通过继承`src`类，实现`dst`类接口，完成`src`\->`dst`的适配。  
![在这里插入图片描述][20210315214804353.png]

//被适配的类
    public class Voltage220V { 
    	public int output220V() { 
    		int src = 220;
    		System.out.println("电压=" + src);
    		return src;
    	}
    }
    
    //适配接口
    public interface IVoltage5V { 
    	public int output5V();
    }
    
    //适配器类
    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;
    	}
    }
    
    //调用
    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，不可充电");
    		}
    	}
    }
    
    //测试
    public class Client { 
    	public static void main(String[] args) { 
    		System.out.println("===类适配器测试===");
    		Phone phone = new Phone();
    		phone.charging(new VoltageAdapter());
    	}
    }

![在这里插入图片描述][20210315220229232.png]

优缺点：

1.  有一定局限性。因为类适配器需要继承`src类`，而Java是单继承机制，所以要求`dst`必须是接口。
2.  `src`类的方法在`Adapter`中都会暴露出来，耦合性高。
3.  可以根据需求重写`src`类的方法，使得`Adapter`的灵活性增强了。

# 对象适配器 #

--------------------

顾名思义，通过实例对象（构造器传递）来实现适配器，而不是再用继承，其余基本同类适配器。即：持有`src`类，实现`dst`类接口，完成`src`\->`dst`的适配。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 1]

> （插播反爬信息 ）博主CSDN地址：[https://wzlodq.blog.csdn.net/][https_wzlodq.blog.csdn.net]

//被适配的类（不变）
    public class Voltage220V { 
    	public int output220V() { 
    		int src = 220;
    		System.out.println("电压=" + src);
    		return src;
    	}
    }
    
    //适配接口（不变）
    public interface IVoltage5V { 
    	public int output5V();
    }
    
    //适配器类
    public class VoltageAdapter  implements IVoltage5V { 
    	private Voltage220V voltage220V;
    	//构造器
    	public VoltageAdapter(Voltage220V voltage220v) { 
    		this.voltage220V = voltage220v;
    	}
    
    	@Override
    	public int output5V() { 
    		int dst = 0;
    		if(null != voltage220V) { 
    			int src = voltage220V.output220V();//获取220v电压
    			dst = src / 44;
    		}
    		return dst;
    	}
    }
    
    //调用（不变）
    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，不可充电");
    		}
    	}
    }
    
    //测试
    public class Client { 
    	public static void main(String[] args) { 
    		System.out.println("===对象适配器===");
    		Phone phone = new Phone();
    		VoltageAdapter VoltageAdapter = new VoltageAdapter(new Voltage220V())；
    		phone.charging(VoltageAdapter);
    	}
    }

![在这里插入图片描述][20210315224302213.png]

优缺点：

1.  把继承解耦，解决了类适配器必须继承src的局限性问题，也不再要求dst必须是接口。
2.  成本低更灵活。

# 接口适配器 #

--------------------

继承那边可以解耦了，那能不能从接口这边解耦？

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 2]

//被适配的类（不变）
    public class Voltage220V { 
    	public int output220V() { 
    		int src = 220;
    		System.out.println("电压=" + src);
    		return src;
    	}
    }
    
    //适配接口
    public interface IVoltage5V { 
    	public int output5V();
    	public void m2(); //接口里冗余不重要的方法
    	public String m3();
    }
    //抽象适配器
    public abstract class AbsAdapter extends Voltage220V implements IVoltage5V{ 
        @Override //以空方法实现接口所有方法
        public int output5V() { 
            return 0;
        }
        @Override
        public void m2() { 
        }
        @Override
        public String m3() { 
            return null;
        }
    }
    
    //调用（不变）
    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，不可充电");
    		}
    	}
    }
    
    //测试
    public class Client { 
    	public static void main(String[] args) { 
    		System.out.println("===接口适配器===");
    		AbsAdapter absAdapter = new AbsAdapter() {  //匿名内部类的形式
    			@Override //按需要重写接口方法
    			public int output5V() { 
    				System.out.println("使用了output5V的方法");
    				int srcV = output220V();
    				int dstV = srcV / 44 ; //转成5v
    				return dstV;
    			}
    		};
    		Phone phone = new Phone();
    		phone.charging(absAdapter);
    	}
    }

![在这里插入图片描述][20210315225824430.png]  
优缺点：

1.  可以灵活方便的选择性重写接口方法。
2.  由于是匿名内部类的形式，所以不利于代码复用。

# 总结 #

--------------------

以上三种形式是根据`src`是以怎样的形式给到`Adapter`来命名的：

1.  类适配器：以类给到，在`Adapter`里，就是将`src`当做类，继承
2.  对象适配器：以对象给到，在`Adapter`里，将`src`作为一个对象，持有
3.  接口适配器：以接口给到，在`Adapter`里，将`src`作为一个接口，实现

`Adapter`模式最大的作用还是将原本不兼容的接口融合在一起工作，在实际开发中，实现起来不拘泥于我们讲解的三种经典形式。

> **原创不易，请勿转载**（本不富裕的访问量雪上加霜 ）  
> 博主首页：[https://wzlodq.blog.csdn.net/][https_wzlodq.blog.csdn.net]  
> 微信公众号：[`吾仄lo咚锵`][lo]  
> *如果文章对你有帮助，记得一键三连❤*

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70]: /images/20221024/31c95a301d7c47fba9ad2a959ac0bef9.png
[20210315204319128.png_pic_center]: /images/20221024/b115f8a913cb4cc891c934ba5ddf8bd7.png
[20210315214804353.png]: /images/20221024/33a0136e8f46427fb75c57f4aa9a25b9.png
[20210315220229232.png]: /images/20221024/0fb7b7ba3d8541fb87aec4adcbeb0a8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 1]: /images/20221024/5ef947fd48ec4767a19881c27fbcebbf.png
[https_wzlodq.blog.csdn.net]: https://wzlodq.blog.csdn.net/
[20210315224302213.png]: /images/20221024/235ea2e2c59c4a18b08b55b5d3d1c6b3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ1MDM0NzA4_size_16_color_FFFFFF_t_70 2]: /images/20221024/56e03bd205ae431893fdd30d308520e0.png
[20210315225824430.png]: /images/20221024/9700a6968048465da8b36d7235c51bb3.png
[lo]: https://mp.weixin.qq.com/mp/profile_ext?action=home&__biz=MzkwMzE2Nzg4MQ==#wechat_redirect