尚硅谷设计模式学习 --- [类适配器模式对象适配器模式接口适配器模式]

Posted 2021-10-14 小智RE0

🚀🚀🚀尚硅谷传送门==>B站尚硅谷Java设计模式

❤❤❤感谢尚硅谷❤❤❤

🕐🕐🕐最近开始计划学习一下设计模式了,加油!!!

---

目录

• • 🕐类适配器模式
  • 🕑对象适配器模式
  • 🕒接口适配器模式

---

适配器模式(Adapter Pattern);又称为包装器(Wrapper)

是将某个类的接口转换为 客户端需要的接口; 以达到兼容的效果;让类与类之间可以达到协同操作.
比如说生活中的多功能转换器;

从用户的角度看不到被适配者，是解耦的

🕐类适配器模式

基本原型 适配器 继承 被适配者 ; 实现 目标类的依赖接口;

由于Java的单继承;适配器直接去继承被适配者,使得出现局限性;且被适配的方法可由适配器去调用,安全度不高;但是继承带来的重写方法机制也是比较方便的.

案例 ;通过充电线给手机充电.
被适配者是电源220V电压 ; 目标是 5V电压; 适配器为充电中转线.

电源类Voltage220V

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

适配接口Voltage22V

//交换电压接口; (适配接口)
public interface Voltage22V {
    //输出22V的电压;
    public int out22V();
}

适配器类AdapterVoltage

//      (适配器)

public class AdapterVoltage extends Voltage220V implements Voltage22V{
    //输出22V的电;
    @Override
    public int out22V() {
        int srcV =out220V();
        int dstV =srcV/10;
        return dstV;
    }
}

电话类TelePhone

//电话  依赖于适配接口;
public class TelePhone {

    //充电;
    public void charging(Voltage22V voltage22V){
        if(voltage22V.out22V()==22){
            System.out.println("22伏特,可以充电");
        }else {
            System.out.println("注意安全");
        }
    }
}

模拟客户端Client

//模拟客户端;
public class Client {
    public static void main(String[] args) {
        System.out.println("类适配器模式使用");

        TelePhone tp=new TelePhone();
        tp.charging(new AdapterVoltage());
    }
}

测试

类适配器模式使用
电源输出=>220伏特电压
22伏特,可以充电

---

🕑对象适配器模式

根据合成复用原则,尽量不使用继承;
即对象适配器模式的原理就是

让 适配器 持有(聚合) 被适配者 ; 实现 目标类的依赖接口;

电源类Voltage220V

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

适配接口Voltage22V

//交换电压接口; (适配接口)
public interface Voltage22V {
    //输出22V的电压;
    public int out22V();
}

适配器类AdapterVoltage ;注意不再是继承关系,而是聚合关系.

//      (适配器)

public class AdapterVoltage  implements Voltage22V{
    //聚合关系;
    private Voltage220V voltage220V;
    //初始化;
    public AdapterVoltage(Voltage220V voltage220V) {
        this.voltage220V = voltage220V;
    }

    //输出22V的电;
    @Override
    public int out22V() {
       int dstV=0;
       if(null!=voltage220V){
           //获取电源电压;
           int srcV= voltage220V.out220V();
           System.out.println("用了对象适配器模式");
           dstV=srcV/10;
       }
       return dstV;
    }
}

电话类TelePhone

//电话  依赖于适配接口;
public class TelePhone {

    //充电;
    public void charging(Voltage22V voltage22V){
        if(voltage22V.out22V()==22){
            System.out.println("22伏特,可以充电");
        }else {
            System.out.println("注意安全");
        }
    }
}

模拟客户端;
注意这里还要依赖(使用)电源;

//模拟客户端;
public class Client {
    public static void main(String[] args) {
        System.out.println("对象适配器模式使用");

        TelePhone tp=new TelePhone();
        tp.charging(new AdapterVoltage(new Voltage220V()));
    }
}

测试

对象适配器模式使用
电源输出=>220伏特电压
用了对象适配器模式
22伏特,可以充电

---

🕒接口适配器模式

例如,一个类可能只需要某个接口中的其中几个方法,这时,可以让一个抽象类作为适配器,去实现接口;实现的方法内具体可以写成空的;即空方法;
然后让其他类去 使用 抽象类; 可以使用自己需要的方法.

案例

被适配的接口SrcInterface

//被适配者
public interface SrcInterface {
    public abstract void methodA();
    public abstract void methodB();
    public abstract void methodC();
    public abstract void methodD();
}

适配器;

//适配器;
public abstract class AdapterClass implements SrcInterface{
    @Override
    public void methodA() {

    }

    @Override
    public void methodB() {

    }

    @Override
    public void methodC() {

    }

    @Override
    public void methodD() {

    }
}

调用时仅适用需要的方法

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

        //只调用自己需要的方法;
        AdapterClass adapterClass=new AdapterClass(){
            @Override
            public void methodC() {
                System.out.println("使用了方法C");
            }
        };
        adapterClass.methodC();//使用了方法C
    }
}

---

在springmvc中就用到了适配器模式;
比如说DispatcherServlet类;

当请求出现时,调用到 doDispatch 方法;
内部处理时,getHandler返回控制器;

getHandlerAdapter(mappedHandler.getHandler());返回适配器

通过适配器调用controller的方法;返回ModelAndView

可以注意到HandlerAdapter适配器实际上是个接口.

这个适配器有许多实现类;

模拟SpringMVC流程

适配器代替controller执行相应的方法

Controller控制层;

//Controller顶部接口;
public interface Controller {

}

class HttpController implements Controller {
	public void doHttpHandler() {
		System.out.println("HttpController");
	}
}

class SimpleController implements Controller {
	public void doSimplerHandler() {
		System.out.println("SimpleController");
	}
}

class AnnotationController implements Controller {
	public void doAnnotationHandler() {
		System.out.println("AnnotationController");
	}
}

DispatchServlet 处理

public class DispatchServlet {
	public static List<HandlerAdapter> handlerAdapters = new ArrayList<HandlerAdapter>();

	public DispatchServlet() {
		handlerAdapters.add(new AnnotationHandlerAdapter());
		handlerAdapters.add(new HttpHandlerAdapter());
		handlerAdapters.add(new SimpleHandlerAdapter());
	}

	public void doDispatch() {

		// 此处模拟SpringMVC从request取handler的对象，
		// 适配器可获取需要的Controller
		 HttpController controller = new HttpController();
		// AnnotationController controller = new AnnotationController();
		//SimpleController controller = new SimpleController();
		// 获取对应适配器
		HandlerAdapter adapter = getHandler(controller);
		// 通过适配器执行对应的controller对应方法
		adapter.handle(controller);
	}

	public HandlerAdapter getHandler(Controller controller) {
		//遍历：根据得到的controller(handler), 返回对应适配器
		for (HandlerAdapter adapter : this.handlerAdapters) {
			if (adapter.supports(controller)) {
				return adapter;
			}
		}
		return null;
	}

	public static void main(String[] args) {
		new DispatchServlet().doDispatch();
	}
}

适配器层

//定义Adapter顶部接口 
public interface HandlerAdapter {
	public boolean supports(Object handler);

	public void handle(Object handler);
}

//适配器类
class SimpleHandlerAdapter implements HandlerAdapter {

	public void handle(Object handler) {
		((SimpleController) handler).doSimplerHandler();
	}

	public boolean supports(Object handler) {
		return (handler instanceof SimpleController);
	}

}

class HttpHandlerAdapter implements HandlerAdapter {

	public void handle(Object handler) {
		((HttpController) handler).doHttpHandler();
	}

	public boolean supports(Object handler) {
		return (handler instanceof HttpController);
	}

}

class AnnotationHandlerAdapter implements HandlerAdapter {

	public void handle(Object handler) {
		((AnnotationController) handler).doAnnotationHandler();
	}

	public boolean supports(Object handler) {

		return (handler instanceof AnnotationController);
	}

}

---