设计模式---适配器模式和外观模式

目录

1、适配器模式

2、外观模式

---

两种模式的比较：二者都会改变接口，适配器的意图是要转换接口，而外观的意图是要统一和简化接口。

1、当需要使用一个现有的类而其接口并不符合你的需求时，就使用适配器；
2、当需要简化并统一一个很大的接口或者一群复杂的接口时，使用外观；
3、适配器模式有两种形式：对象适配器（使用组合）和类适配器。类适配器需要用到多重继承（Java中不能实现）；

适配器模式和装饰者模式：适配器需要改变接口而装饰者不需要；

设计原则：
最少知道原则：只和你的密友交谈

对任何对象而言我们应该只调用属于以下范围的方法：
1、对象本身
2、被当做方法的参数而传递进来的对象
3、此方法所创建或者实例化的对象
4、对象的任何组件
5、不要调用其他方法返回的对象的方法。

1、适配器模式

定义：将一个类的接口，转化为客户期待的另一个接口。适配器让原本接口不兼容的类可以合作无间。

//目标接口
public interface Duck {

     public void quack();
     public void fly();
}
public class MallardDuck implements Duck {

     @Override
     public void quack() {
          System.out.println("quack");
     }

     @Override
     public void fly() {
          System.out.println("i am flying ....");
     }

}
//待适配的接口
public interface Turkey {

     public void gobble();
     public void fly();
}
public class WildTurkey implements Turkey {

     @Override
     public void gobble() {
          System.out.println("gobble gobble");
     }
     @Override
     public void fly() {
          System.out.println("i am flying a short distance");
     }

}

//适配器
public class TurkeyAdapter implements Duck {
     //持有被适配的对象，通过构造函数传入
     public Turkey turkey;
     public TurkeyAdapter(Turkey turkey) {
          this.turkey = turkey;
     }
     @Override
     public void quack() {
          turkey.gobble();
     }

     @Override
     public void fly() {
          for (int i = 0; i < 5; i++) {
              turkey.fly();
          }
     }
//测试
public static void main(String[] args) {
          MallardDuck duck = new MallardDuck();
          WildTurkey turkey = new WildTurkey();
          TurkeyAdapter turkeyAdapter = new TurkeyAdapter(turkey);
          System.out.println("turkey say...");
          turkey.gobble();
          turkey.fly();

          System.out.println("duck say...");
          testDuck(duck);


          System.out.println("turkeyAdapter say...");
          testDuck(turkeyAdapter);

     }
    static void testDuck(Duck duck) {
     duck.quack();
     duck.fly();
    }
}

TurkeyAdapter适配类持有待适配接口的实例，然后根据待适配的实例实现原先的接口中的方法。

2、外观模式

外观模式
定义：提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。

public class CPU {
     public void startup(){
         System.out.println("cpu startup!");
    }
     public void shutdown(){
         System.out.println("cpu shutdown!");
     }
 }

 public class Memory {
     public void startup(){
         System.out.println("memory startup!");
     }
    public void shutdown(){
         System.out.println("memory shutdown!");
     }
 }

 public class Disk {
     public void startup(){
        System.out.println("disk startup!");
    }
     public void shutdown(){
        System.out.println("disk shutdown!");
     }
 }
 
//统一的facade接口
 public class Computer {
     private CPU cpu;
     private Memory memory;
     private Disk disk;

     public Computer(){
         cpu = new CPU();
         memory = new Memory();
         disk = new Disk();
     }
     public void startup(){
         System.out.println("start the computer!");
         cpu.startup();
         memory.startup();
         disk.startup();
         System.out.println("start computer finished!");
     }

     public void shutdown(){
         System.out.println("begin to close the computer!");
         cpu.shutdown();
         memory.shutdown();
         disk.shutdown();
         System.out.println("computer closed!");
     }
 }

User类如下：
 public class User {
     public static void main(String[] args) {
         Computer computer = new Computer();
         computer.startup();
         computer.shutdown();
     }
 }

输出：
start the computer!
cpu startup!
memory startup!
disk startup!
start computer finished!
begin to close the computer!
cpu shutdown!
memory shutdown!
disk shutdown!
computer closed!

如果我们没有Computer类，那么，CPU、Memory、Disk他们之间将会相互持有实例，产生关系，这样会造成严重的依赖，修改一个类，可能会带来其他类的修改，这不是我们想要看到的，有了Computer类，他们之间的关系被放在了Computer类里，这样就起到了解耦的作用，这，就是外观模式！