設計模式——6介面卡模式（Adapter）

6、介面卡模式（Adapter）
介面卡模式將某個類的介面轉換成客戶端期望的另一個介面表示，目的是消除由於介面不匹配所造成的類的相容性問題。主要分為三類：類的介面卡模式、物件的介面卡模式、介面的介面卡模式。

核心思想就是：有一個Source類，擁有一個方法，待適配，目標介面時Targetable，通過Adapter類，將Source的功能擴充套件到Targetable裡，看程式碼：
[java] view plaincopy

1. public class Source {
3. public void method1() {
4. System.out.println(“this is original method!”);
5. }
6. }
   [java] view plaincopy
7. public interface Targetable {
8. / 與原類中的方法相同 /
9. public void method1();
10. / 新類的方法 /
11. public void method2();
12. }
    [java] view plaincopy
13. public class Adapter extends Source implements Targetable {
14. @Override
15. public void method2() {
16. System.out.println(“this is the targetable method!”);
17. }
18. }
    Adapter類繼承Source類，實現Targetable介面，下面是測試類：

[java] view plaincopy

1. public class AdapterTest {
2. public static void main(String[] args) {
3. Targetable target = new Adapter();
4. target.method1();
5. target.method2();
6. }
7. }
   輸出：

this is original method!
this is the targetable method!
這樣Targetable介面的實現類就具有了Source類的功能。
物件的介面卡模式
基本思路和類的介面卡模式相同，只是將Adapter類作修改，這次不繼承Source類，而是持有Source類的例項，以達到解決相容性的問題。

只需要修改Adapter類的原始碼即可：
[java] view plaincopy

1. public class Wrapper implements Targetable {
2. private Source source;
3. public Wrapper(Source source){
4. super();
5. this.source = source;
6. }
7. @Override
8. public void method2() {
9. System.out.println(“this is the targetable method!”);
10. }
11. @Override
12. public void method1() {
13. source.method1();
14. }
15. }
    測試類：

[java] view plaincopy

1. public class AdapterTest {
2. public static void main(String[] args) {
3. Source source = new Source();
4. Targetable target = new Wrapper(source);
5. target.method1();
6. target.method2();
7. }
8. }
   輸出與第一種一樣，只是適配的方法不同而已。

第三種介面卡模式是介面的介面卡模式，介面的介面卡是這樣的：有時我們寫的一個介面中有多個抽象方法，當我們寫該介面的實現類時，必須實現該介面的所有方法，這明顯有時比較浪費，因為並不是所有的方法都是我們需要的，有時只需要某一些，此處為了解決這個問題，我們引入了介面的介面卡模式，藉助於一個抽象類，該抽象類實現了該介面，實現了所有的方法，而我們不和原始的介面打交道，只和該抽象類取得聯絡，所以我們寫一個類，繼承該抽象類，重寫我們需要的方法就行。

在實際開發中，我們也常會遇到這種介面中定義了太多的方法，以致於有時我們在一些實現類中並不是都需要。看程式碼：
[java] view plaincopy

1. public interface Sourceable {
3. public void method1();
4. public void method2();
5. }
   抽象類Wrapper2：

[java] view plaincopy

1. public abstract class Wrapper2 implements Sourceable{
3. public void method1(){}
4. public void method2(){}
5. }
   [java] view plaincopy
6. public class SourceSub1 extends Wrapper2 {
7. public void method1(){
8. System.out.println(“the sourceable interface`s first Sub1!”);
9. }
10. }
    [java] view plaincopy
11. public class SourceSub2 extends Wrapper2 {
12. public void method2(){
13. System.out.println(“the sourceable interface`s second Sub2!”);
14. }
15. }
    [java] view plaincopy
16. public class WrapperTest {
17. public static void main(String[] args) {
18. Sourceable source1 = new SourceSub1();
19. Sourceable source2 = new SourceSub2();
20. source1.method1();
21. source1.method2();
22. source2.method1();
23. source2.method2();
24. }
25. }
    測試輸出：

the sourceable interface`s first Sub1!
the sourceable interface`s second Sub2!
達到了我們的效果！
講了這麼多，總結一下三種介面卡模式的應用場景：
類的介面卡模式：當希望將一個類轉換成滿足另一個新介面的類時，可以使用類的介面卡模式，建立一個新類，繼承原有的類，實現新的介面即可。
物件的介面卡模式：當希望將一個物件轉換成滿足另一個新介面的物件時，可以建立一個Wrapper類，持有原類的一個例項，在Wrapper類的方法中，呼叫例項的方法就行。
介面的介面卡模式：當不希望實現一個介面中所有的方法時，可以建立一個抽象類Wrapper，實現所有方法，我們寫別的類的時候，繼承抽象類即可。