Java 23種設計模式(四)—配接器模式

一、配接器模式

 配接器模式將某個類的介面轉換成客戶端期望的另一個介面表示，目的是消除由于介面不匹配所造成的類的兼容性問題，

主要分為三類：類的配接器模式、物件的配接器模式、介面的配接器模式，首先，我們來看看類的配接器模式，先看類圖：

1、類的配接器模式

核心思想就是：有一個Source類，擁有一個方法，待適配，目標介面時Targetable，通過Adapter類，將Source的功能擴展到Targetable里，看代碼：

1. public class Source {  
2.   
3.     public void method1() {  
4.         System.out.println(“this is original method!”);  
5.     }  
6. }  

1. public interface Targetable {  
2.   
3.     /* 與原類中的方法相同 */  
4.     public void method1();  
5.   
6.     /* 新類的方法 */  
7.     public void method2();  
8. }  

1. public class Adapter extends Source implements Targetable {  
2.   
3.     @Override  
4.     public void method2() {  
5.         System.out.println(“this is the targetable method!”);  
6.     }  
7. }  

Adapter類繼承Source類，實作Targetable介面，下面是測驗類：

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

輸出：

this is original method!
this is the targetable method!

這樣Targetable介面的實作類就具有了Source類的功能，

2、物件的配接器模式

基本思路和類的配接器模式相同，只是將Adapter類作修改，這次不繼承Source類，而是持有Source類的實體，以達到解決兼容性的問題，看圖：

只需要修改Adapter類的原始碼即可：

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

測驗類：

1. public class AdapterTest {  
2.   
3.     public static void main(String[] args) {  
4.         Source source = new Source();  
5.         Targetable target = new Wrapper(source);  
6.         target.method1();  
7.         target.method2();  
8.     }  
9. }  

輸出與第一種一樣，只是適配的方法不同而已，

3、介面的配接器模式

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

這個很好理解，在實際開發中，我們也常會遇到這種介面中定義了太多的方法，以致于有時我們在一些實作類中并不是都需要，看代碼：

1. public interface Sourceable {  
2.       
3.     public void method1();  
4.     public void method2();  
5. }  

抽象類Wrapper2：

1. public abstract class Wrapper2 implements Sourceable{  
2.       
3.     public void method1(){}  
4.     public void method2(){}  
5. }  

1. public class SourceSub1 extends Wrapper2 {  
2.     public void method1(){  
3.         System.out.println(“the sourceable interface’s first Sub1!”);  
4.     }  
5. }  

1. public class SourceSub2 extends Wrapper2 {  
2.     public void method2(){  
3.         System.out.println(“the sourceable interface’s second Sub2!”);  
4.     }  
5. }  

1. public class WrapperTest {  
2.   
3.     public static void main(String[] args) {  
4.         Sourceable source1 = new SourceSub1();  
5.         Sourceable source2 = new SourceSub2();  
6.           
7.         source1.method1();  
8.         source1.method2();  
9.         source2.method1();  
10.         source2.method2();  
11.     }  
12. }  

測驗輸出：

the sourceable interface’s first Sub1!
the sourceable interface’s second Sub2!

達到了我們的效果！

 講了這么多，總結一下三種配接器模式的應用場景：

類的配接器模式：當希望將一個類轉換成滿足另一個新介面的類時，可以使用類的配接器模式，創建一個新類，繼承原有的類，實作新的介面即可，

物件的配接器模式：當希望將一個物件轉換成滿足另一個新介面的物件時，可以創建一個Wrapper類，持有原類的一個實體，在Wrapper類的方法中，呼叫實體的方法就行，

介面的配接器模式：當不希望實作一個介面中所有的方法時，可以創建一個抽象類Wrapper，實作所有方法，我們寫別的類的時候，繼承抽象類即可，

標籤：Java

上一篇：qt 與 winpcap 中出現的問題

下一篇：WideString和TStrings