23种设计模式----适配器模式----结构模式

文章目录

• 适配器模式
• 1.适配器模式介绍
• 2.适配器模式角色
• 3.适配器模式的实现
• 需求
• 现有
• 工具类
• 3.1继承方式实现适配器
• 3.2组合的方式
• 3.3适配器模式实现扩展
• 3.4文档结构及名称
• 3.5总结
• 4.适配器模式的使用
• 4.1使用适配器可以在不更改原有类的基础上增加新类，这样出现bug也是在新类中，比在原有类的基础上修改好的多。
• 4.2修改原有类需要对原有类进行测试，如果只是改动比较小，但是测试比较麻烦的类，使用适配器的代价小的多。
• 4.3版本升级，新版本兼容旧版本。

23种设计模式

适配器模式

1.适配器模式介绍

引入：显示生活中，有许许多多的的电器在被使用，但是我们普通家用电线的电压是220V（一般）。但是家里的电器却又很多种：
手机充电：5V
手电筒：12V、5V
电视机：220V
笔记本：12V
（电器电压不一定正确）
。。。。。。。。
那么，为什么只提供一种电压却满足了这么不同电压需求的电器。
原因就是每一种电器都有各自的电压转换器（变压器），笔记本是充电适配器（外）电视机（内）手机充电头（电源适配器）
所以，生活中处处可见各种各样的适配器。

在程序世界中，经常会存在有的程序无法直接使用，需要做适当的变换之后才能使用的情形（源自《图解设计模式》）。适配器模式就是连接“现有程序”和“目标程序”的中间程序。

2.适配器模式角色

通俗的理解：
需求-Target
适配器-Adapter
现有-Adaptee
使用-Client
专业的解释：
Target-对象
Client-请求者
Adaptee-被适配
Adapter-适配

3.适配器模式的实现

适配模式的实现主要分为2种：继承的方式和组合的方式。

需求

一个接口：玩和吃

public interface PeopleAction {

	void playNeed();
	
	void eatNeed();
	
}

现有

一个类：名字和年龄,玩和吃方法

import com.startime.adapter.utils.PeopleEatUtil;
import com.startime.adapter.utils.PeoplePlyUtil;


public class People{

	protected String name;
	
	protected int age;
	
	protected String string;
	
	public void setString(String string){
		this.string = string;
	}
	 
	public People(String name,int age){
		this.name = name;
		this.age = age;
	}

	public void playHave(){
		PeoplePlyUtil.p(string, name, age);
	}

	public void eatHave(){
		PeopleEatUtil.e(string, name, age);
	}
}

工具类

public class PeopleEatUtil {
	
	public static void showTime(){
		PeoplePlyUtil.showTime();
	}
	
	public static void eat(String string){
		System.out.println(string);
	}
	
	public static void eat(String name,int age){
		System.out.println("我叫"+name+",今年"+age+"岁!");
	}
	
	public static void e(String string,String name,int age){
		showTime();
		eat(name, age);
		eat(string);
	}
}

import java.text.SimpleDateFormat;
import java.util.Date;

public class PeoplePlyUtil {

	public static void play(String string){
		System.out.println(string);
	}
	public static void play(String name,int age){
		System.out.println("我叫"+name+",今年"+age+"岁!");
	}
	public static void showTime(){
		System.out.print(new SimpleDateFormat("HH:mm:ss").format(new Date())+"\t");
	}
	public static void p(String string,String name,int age){
		showTime();
		play(name, age);
		play(string);
	}
}

3.1继承方式实现适配器

定义适配器：

import com.startime.adapter.domain.PeopleAction;
import com.startime.adapter.domain.People;


public class ChildrenExtend extends People implements PeopleAction{
	
	public ChildrenExtend(String name, int age) {
		super(name, age);
	}

	@Override
	public void playNeed() {
		super.setString("我玩王者荣耀");
		super.playHave();
	}

	@Override
	public void eatNeed() {
		super.setString("我吃冰淇淋");
		super.eatHave();
	}

}

import com.startime.adapter.domain.PeopleAction;
import com.startime.adapter.domain.People;


public class TeenagerExtend extends People implements PeopleAction{

	public TeenagerExtend(String name, int age) {
		super(name, age);
	}

	@Override
	public void playNeed() {
		super.setString("我玩足球");
		super.playHave();
	}

	@Override
	public void eatNeed() {
		super.setString("我吃麻辣烫");
		super.eatHave();
	}

}

import com.startime.adapter.domain.PeopleAction;
import com.startime.adapter.domain.People;


public class WrinklyExtend extends People implements PeopleAction{
	
	public WrinklyExtend(String name, int age) {
		super(name, age);
	}

	@Override
	public void playNeed() {
		super.setString("我玩高尔夫球");
		super.playHave();
	}

	@Override
	public void eatNeed() {
		super.setString("我吃绿豆羹");
		super.eatHave();
	}
	
	
}

import com.startime.adapter.domain.PeopleAction;
import com.startime.adapter.domain.People;


public class OlderExtend extends People implements PeopleAction{
	
	public OlderExtend(String name, int age) {
		super(name, age);
	}

	@Override
	public void playNeed() {
		super.setString("我玩中国象棋");
		super.playHave();
	}

	@Override
	public void eatNeed() {
		super.setString("我吃流食");
		super.eatHave();
	}

}

使用：

public class MainExtend {

	public static void main(String[] args) {
		ChildrenExtend c = new ChildrenExtend("小胖", 9);
		c.playNeed();
		c.eatNeed();
		TeenagerExtend t = new TeenagerExtend("张峰", 19);
		t.playNeed();
		t.playNeed();
		WrinklyExtend w = new WrinklyExtend("中山", 35);
		w.playNeed();
		w.eatNeed();
		OlderExtend o = new OlderExtend("X老", 88);
		o.playNeed();
		o.eatNeed();
	}

}

3.2组合的方式

实现适配器：

import com.startime.adapter.domain.People;
import com.startime.adapter.domain.PeopleAction;

public class ChildrenGroup implements PeopleAction{
	
	private People children = null;
	
	public ChildrenGroup(String name,int age){
		children = new People(name, age);
	}

	@Override
	public void playNeed() {
		children.setString("我玩手机游戏");
		children.playHave();
	}

	@Override
	public void eatNeed() {
		children.setString("我吃冰淇淋");
		children.eatHave();
	}
	
}

import com.startime.adapter.domain.People;
import com.startime.adapter.domain.PeopleAction;

public class TeenagerGroup implements PeopleAction{

	private People teenager = null;
	
	public TeenagerGroup(String name,int age){
		teenager = new People(name, age);
	}
	
	@Override
	public void playNeed() {
		teenager.setString("我玩足球");
		teenager.playHave();
	}

	@Override
	public void eatNeed() {
		teenager.setString("我吃辣条");
		teenager.eatHave();
	}
	
}

import com.startime.adapter.domain.People;
import com.startime.adapter.domain.PeopleAction;

public class WrinklyGroup implements PeopleAction{
	
	private People wrinkly = null;
	
	public WrinklyGroup(String name,int age){
		wrinkly = new People(name, age);
	}

	@Override
	public void playNeed() {
		wrinkly.setString("我玩攀岩");
		wrinkly.playHave();
	}

	@Override
	public void eatNeed() {
		wrinkly.setString("我吃肉");
		wrinkly.eatHave();
	}

}

import com.startime.adapter.domain.People;
import com.startime.adapter.domain.PeopleAction;

public class OlderGroup implements PeopleAction{
	
	private People older = null;
	
	public OlderGroup(String name,int age){
		older = new People(name, age);
	}

	@Override
	public void playNeed() {
		older.setString("我玩象棋");
		older.playHave();
	}

	@Override
	public void eatNeed() {
		older.setString("我吃流食");
		older.eatHave();
	}

}

使用：

public class MainGroup {
	public static void main(String[] args) {
		ChildrenGroup c = new ChildrenGroup("小胖", 9);
		c.playNeed();
		c.eatNeed();
		TeenagerGroup t = new TeenagerGroup("张峰", 19);
		t.playNeed();
		t.playNeed();
		WrinklyGroup w = new WrinklyGroup("中山", 35);
		w.playNeed();
		w.eatNeed();
		OlderGroup o = new OlderGroup("X老", 88);
		o.playNeed();
		o.eatNeed();
	}
}

3.3适配器模式实现扩展

问题：需求中的接口如果比较多，在实现适配器中，适配器可能用到很少的接口，会造成许多接口无用的实现。
原理：使用一个中间类，中间类实现接口（空语句实现），然后适配器继承中间类，利用子类覆盖父类的方法实现需求的接口，其他接口不用实现。
缺陷：
现有类的属性与方法需要被孙子类访问到（可以是方法访问或者属性权限控制）。
比如使用protected修饰类的属性或者增加protected方法访问类的属性。
接口:

public interface PersonEatInterface {

	void eatIceCream();
		
	void eatHotpot();
	
	void eatMungBeanSoup();
	
	void eatFluids();
}
public interface PersonPlayInterface {

	void playGame();

	void playSoccer();

	void playGolf();

	void playChess();
}

中间类：

import com.startime.adapter.domain.People;


public class PeopleBasic extends People implements PersonEatInterface,PersonPlayInterface{

	public PeopleBasic(String name, int age) {
		super(name, age);
	}

	@Override
	public void playGame() {
		super.playHave();
	}

	@Override
	public void playSoccer() {
		super.playHave();
	}

	@Override
	public void playGolf() {
		super.playHave();
	}

	@Override
	public void playChess() {
		super.playHave();
	}

	@Override
	public void eatIceCream() {
		super.eatHave();
	}

	@Override
	public void eatHotpot() {
		super.eatHave();
	}

	@Override
	public void eatMungBeanSoup() {
		super.eatHave();
	}

	@Override
	public void eatFluids() {
		super.eatHave();
	}
	public void setString(String string){
		super.setString(string);
	}

}

适配器：

public class ChildrenExtendsAndInterface extends PeopleBasic{

	public ChildrenExtendsAndInterface(String name, int age) {
		super(name, age);
	}

	@Override
	public void playGame() {
		super.setString("我玩吃鸡");
		super.playGame();
	}

	@Override
	public void eatIceCream() {
		super.setString("我吃冰淇淋");
		super.eatIceCream();
	}
	
}

public class TeenagerExtendsAndInterface extends PeopleBasic{

	public TeenagerExtendsAndInterface(String name, int age) {
		super(name, age);
	}

	@Override
	public void playSoccer() {
		super.setString("我玩足球");
		super.playSoccer();
	}

	@Override
	public void eatHotpot() {
		super.setString("我吃麻辣烫");
		super.eatHotpot();
	}
	

}

public class WrinklyExtendsAndInterface extends PeopleBasic{

	public WrinklyExtendsAndInterface(String name, int age) {
		super(name, age);
	}

	@Override
	public void playGolf() {
		super.setString("我玩高尔夫球");
		super.playGolf();
	}

	@Override
	public void eatMungBeanSoup() {
		super.setString("我吃绿豆羹");
		super.eatMungBeanSoup();
	}

}

public class OlderExtendsAndInterface extends PeopleBasic{

	public OlderExtendsAndInterface(String name, int age) {
		super(name, age);
	}

	@Override
	public void playChess() {
		super.setString("我玩象棋");
		super.playChess();
	}

	@Override
	public void eatFluids() {
		super.setString("我吃流食");
		super.eatFluids();
	}

}

使用：

import java.util.ArrayList;
import java.util.List;

public class MainExtendsAndInterface {
	
	public static void main(String[] args) {
		List<PeopleBasic> list = new ArrayList<PeopleBasic>();
		list.add(new ChildrenExtendsAndInterface("小胖", 9));
		list.add(new TeenagerExtendsAndInterface("张峰", 19));
		list.add(new WrinklyExtendsAndInterface("中山", 35));
		list.add(new OlderExtendsAndInterface("X老", 88));
		for (PeopleBasic object : list) {
			object.playChess();
			object.playGame();
			object.playGolf();
			object.playSoccer();
			object.eatFluids();
			object.eatHotpot();
			object.eatIceCream();
			object.eatMungBeanSoup();
		}
	}
}

3.4文档结构及名称

3.5总结

适配器解决连接旧类与新类的问题，主要有继承和组合两种方式；继承方式就是适配器继承旧类实现新类需求的接口，在新类的需求接口中合理的调用旧类现有的方法，实现新类的需求；组合方式是在适配器中增加旧类的属性，在实现新类的接口中，合理的通过旧类对象来调用旧类的方法，实现新类的需求；当接口中的方法较多时，可以使用中间类空语句或者转发（不改变任何东西，只是转发请求）实现接口，在中间类的子类中具体实现需要实现的接口；使用中间类要求旧类的方法在新类中能够实现调用，要么是权限限定关键词限定作用域，或者提供专门的访问方法，才能实现中间类的转发，进而实现适配器；使用适配器需要旧类方法和新类方法有一定的联系，如果完全没有任何显示或者隐含的联系，强行使用适配器只会增加工作的难度和工作量。

4.适配器模式的使用

4.1使用适配器可以在不更改原有类的基础上增加新类，这样出现bug也是在新类中，比在原有类的基础上修改好的多。

4.2修改原有类需要对原有类进行测试，如果只是改动比较小，但是测试比较麻烦的类，使用适配器的代价小的多。

4.3版本升级，新版本兼容旧版本。

23种设计模式

来源：CSDN

作者：a18792721831

链接：https://blog.csdn.net/a18792721831/article/details/82702551