结构型--适配器

深碍√TFBOYSˉ_ 2021-09-23 01:00 211阅读 0赞

## 概念 ##

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

配器模式主要分为三类：类的适配器模式、对象的适配器模式、接口的适配器模式。

适配器模式是将某个类的接口转换成客户端期望的另一个接口表示，使原本由于接口不兼容而不能一起工作的那些类可以一起工作。或者使一个类兼容一个接口。

优点：

1.  可以让任何两个没有关联的类在同一个环境（接口）下工作。
2.  提高了类的复用(不用总写重复代码)。

缺点：

1.  过多地使用适配器，会让系统非常零乱，不易把握整体。造成对一些用户的不透明。比如，明明看到调用的是 A 接口方法，其实内部被适配成了 B 接口的实现，即实际内部是调用了B接口的方法。
2.  由于 JAVA 至多继承一个类，所以类的适配器模式至多只能适配一个适配者类，而且目标必须是接口或抽象类。

## 类的适配器模式 ##

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

###### 想在新环境中使用已有类–(多)继承实现。 ######

//被适配的接口
    interface Adaptee{
    	void SpecificRequest();
    }
    //实现被适配接口的类
    class SpecificAdaptee implements Adaptee{
    	@Override
    	public void SpecificRequest() {
    		System.out.println("SpecificAdaptee类的SpecificRequest()");	
    	}
    }
    //实际环境需要的接口
    interface Target {
        void Request();
    }
    //适配器
    class Adapter extends SpecificAdaptee implements Target{
    	@Override
    	public void Request() {
    		System.out.println("Target接口的Request()");	
    		SpecificRequest();
    	}
    }
    // 客户端
    public class Client {
    	public static void main(String[] args) {
    		Target target = new Adapter();
            target.Request();
    	}
    }
    
    Output:
    Target接口的Request()
    SpecificAdaptee类的SpecificRequest()

## 对象的适配器模式 ##

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

###### 想使用某个类的许多子类的方法–组合实现。 ######

//被适配的接口
    interface Adaptee{
    	void SpecificRequest();
    }
    //实现被适配接口的类
    class SpecificAdaptee implements Adaptee{
    	@Override
    	public void SpecificRequest() {
    		System.out.println("SpecificAdaptee类的SpecificRequest()");	
    	}
    }
    //实际环境需要的接口
    interface Target {
        void Request();
    }
    //适配器
    class Wrapper implements Target {
    	private Adaptee adaptee;
    	public Wrapper(Adaptee adaptee) {
    		this.adaptee = adaptee;
    	}
    	@Override
    	public void Request() {
    		System.out.println("Target接口的Request()");	
    		adaptee.SpecificRequest();
    	}
    }
    // 客户端
    public class Client {
    	public static void main(String[] args) {
    		Target target = new Wrapper(new SpecificAdaptee());
            target.Request();
    	}
    }
    
    Output:
    Target接口的Request()
    SpecificAdaptee类的SpecificRequest()

## 接口的适配器模式 ##

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

一个接口中有多个抽象方法，若想实现该接口则必须实现该接口的所有方法，这比较浪费，因为并不是接口中所有的方法都是我们需要的，有时只需要其中的一部分。

创建一个实现了该接口（所有方法）的抽象类。我们不和原始的接口打交道，只和该抽象类取得联系。当我们的类需要接口中的部分方法时，就写一个类，继承该抽象类，并重写我们需要的方法就行了。

要用的接口：

package adapter;
    
    public interface TargetInterface {
        void method1();
        void method2();
        void method3();   
    }

实现了该接口（所有方法）的抽象类：

package adapter;
    
    public abstract class AbstractAdapter implements TargetInterface{
    	public void method1() {
    		System.out.println("TargetInterface method1");
    	}
    	public void method2() {
    		System.out.println("TargetInterface method2");
    	}
    	public void method3() {
    		System.out.println("TargetInterface method3");
    	}
    }

只用到接口中部分方法的类：只需要重写我们用到的接口方法，无需每次重写所有接口方法

package adapter;
    
    public class ImplementClass extends AbstractAdapter{
    	public void method1() {
    		System.out.println("ImplementClass method1");
    	}
    	public void method3() {
    		System.out.println("ImplementClass method3");
    	}
    }

客户端：

package adapter;
    
    public class AdapterTest {
    	public static void main(String[] args) {
    		TargetInterface target = new ImplementClass();
    		target.method1();
    		target.method2();
    		target.method3();
    	}
    }
    
    Output:
    ImplementClass method1
    TargetInterface method2
    ImplementClass method3