类和对象适配器：
    1. 想要使用一个已经存在的类，但是它却不符合现有的接口规范，导致无法直接访问，这时创建一个适配器就能间接去访问这个类中的方法
    2. 我们有一个类，想将其设计为可重用的类（可被多处访问）我们可以创建适配器来将这个类来适配其他没有提供合适接口的类
    接口适配器：
    1. 想要使用接口中的某个或某些方法，但是接口中有太多方法，我们要使用时必须实现接口并实现器中的所有方法，可以使用抽象类来实现接口，并不对方法进行实现（仅置空），然后我们再继承这个抽象类来通过重写想用的方法的方式来实现

    1. /**
    2.  * Ps2插口
    3.  */
    4. public interface Ps2 {
    6.     void isPs2();
    7. }
    1. /**
    2.  * Usb插口
    3.  */
    4. public interface Usb {
    6.     void isUsb();
    7. }
    1. //类适配器
    2. public class Adapter extends Usber implements Ps2 {
    3.     @Override
    4.     public void isPs2() {
    5.         isUsb();
    6.     }
    7. }
    1. //对象适配器
    2. public class Adapter implements Ps2 {
    4.     private Usb usb;
    6.     public Adapter(Usb usb) {
    7.         this.usb = usb;
    8.     }
    10.     @Override
    11.     public void isPs2() {
    12.         usb.isUsb();
    13.     }
    14. }
    1. public class Clienter {
    3.     public static void main(String[] args) {
    4.         Ps2 p = new Adapter();
    5.         p.isPs2();
    6.     }
    8. }
    1. /**
    2.  * 接口
    3.  */
    4. public interface A {
    6.     void a();
    7.     void b();
    8.     void c();
    9.     void d();
    10.     void e();
    11.     void f();
    13. }
    1. public abstract class Adapter implements A {
    3.     @Override
    4.     public void a() {}
    5.     @Override
    6.     public void b() {}
    7.     @Override
    8.     public void c() {}
    9.     @Override
    10.     public void d() {}
    11.     @Override
    12.     public void e() {}
    13.     @Override
    14.     public void f() {}
    15. }
    1. public class AInstance extends Adapter {
    3.     @Override
    4.     public void a() {
    5.         System.out.println("实现A被调用");;
    6.     }
    8.     @Override
    9.     public void b() {
    10.         System.out.println("实现B被调用");;
    11.     }
    13. }
    1. public class Clienter {
    3.     public static void main(String[] args) {
    4.         A a = new AInstance();
    5.         a.a();
    6.         a.b();
    7.     }
    9. }