設計模式之適配器模式

　　　　　　

　　　　　　設計模式是一套被反覆使用，多數人知曉，通過分類編目的，代碼設計的總結，也能夠說是前人的智慧結晶。學習設計模式能讓咱們對一些應用場景使用相同的套路達到很好的效果，我會不定時更新一些本身

　　對設計模式的理解的文章，從定義，實現，應用場景來講說設計模式，今天我要說的對象是適配器模式
　　　　一：定義
　　　　　　　　　　適配器模式也被稱爲不協調的兼容模式，當想調用某個接口，但有發現這個接口不能被直接調用，須要一箇中間類來處理的時候，適配器模式就出現了，而這個中間類也被稱爲適配器類，
　　　　　　它的定義是這樣的：將一個接口轉換成客戶但願的另外一個接口，使接口不兼容的那些類能夠一塊兒工做，其別名爲包裝器(Wrapper)。適配器模式既能夠做爲類結構型模式，也可以做爲對象結構型模式。

　　　　　　　　　　　　　　適配器模式的結構圖以下

　　　　　　　　能夠看出適配器模式組成成員有4個，他們的介紹以下

　　　　　　　　1.客戶端類（Client）：須要調用某個接口的類，它是具體的使用者
　　　　　　　　2.目標類（Target）：它是被調用的抽象，通常定義了一個抽象的方法，它能夠是抽象類或者接口
　　　　　　　　3.適配器類（Adapter）：適配器模式的核心，實現Target中的抽象方法，而且調用須要被適配（不能直接調用）類的方法
　　　　　　　　4.適配者類（Adaptee）:含有一個須要被調用的方法，但這個方法不能被客戶端直接調用，須要適配器適配，至關於作一個兼容處理
　　　　　　

　　　　二：實現
　　　　　　　　　　適配器模式根據實現的不一樣能夠分爲對象適配器，類適配器，缺省適配器
　　　　　　　　假設咱們如今遇到一種這樣的情形，咱們的類庫裏面有 一個針對int進行排序的算法，可是如今有一家公司須要對他們的一筆帳單進行排序，帳單都是含有
　　　　　　　　兩位小數的double類型，很顯然類庫已有的int排序方法，不能直接用於對這筆帳單進行排序，咱們須要作一個適配器
　　　　　　　　1.對象適配器
　　　　　　　　　　對象適配器的核心就是在這個適配器中會引入一個適配者類的成員變量
　　　　

　　　　　　　　　　/**
　　　　　　　　　　 * 適配者類，有一個給int類型排序的方法
　　　　　　　　　　 */
　　　　　　　　　　class SortAdaptee{

   　　　　　　　　　　 /**
     　　　　　　　　　　* 一個簡單的冒泡排序算法
    　　　　　　　　　　 * @param numbers
     　　　　　　　　　　*/
   　　　　　　　　　　 public  void bubbleSort(int[] numbers) {
        　　　　　　　　　　int temp = 0;
        　　　　　　　　　　int size = numbers.length;
        　　　　　　　　　　for(int i = 0 ; i < size-1; i ++) {
           　　　　　　　　　　 for(int j = 0 ;j < size-1-i ; j++) {
               　　　　　　　　　　 if(numbers[j] > numbers[j+1]){//交換兩數位置
                    　　　　　　　　　　temp = numbers[j];
                    　　　　　　　　　　numbers[j] = numbers[j+1];
                    　　　　　　　　　　numbers[j+1] = temp;
               　　　　　　　　　　 }
           　　　　　　　　　　 }
       　　　　　　　　　　 }
    　　　　　　　　　　}
　　　　　　　　　　}

　　　　　　　　　　/**
 　　　　　　　　　　* 適配器類
 　　　　　　　　　　*/
　　　　　　　　　　class SortAdapter{
    　　　　　　　　　　private SortAdaptee sortAdaptee=new SortAdaptee();



   　　　　　　　　　　public  double[] bubbleSort(double[] numbers){
        　　　　　　　　　　int[] ints=doubleToInt(numbers);
        　　　　　　　　　　sortAdaptee.bubbleSort(ints);
        　　　　　　　　　　return intToDouble(ints);
    　　　　　　　　　　}

    　　　　　　　　　　/**
    　　　　　　　　　　 * 將double數組轉換成int數組，double轉int確定會丟失精度，這裏假設客戶要求保留2位小數
     　　　　　　　　　　* @param numbers
     　　　　　　　　　　* @return
     　　　　　　　　　　*/
    　　　　　　　　　　private static int[]  doubleToInt(double[] numbers){
       　　　　　　　　　　 int[] its=new int[numbers.length];
       　　　　　　　　　　 for(int i=0;i<numbers.length;i++){
           　　　　　　　　　　 its[i]=(int)(numbers[i]*100);//先放大100倍，而後再縮小，就達到了保存2位小數的目的
       　　　　　　　　　　 }
        　　　　　　　　　　return its;
    　　　　　　　　　　}

    　　　　　　　　　　/**
    　　　　　　　　　　 * 將int數組轉換成double數組
    　　　　　　　　　　 * @param numbers
     　　　　　　　　　　* @return
    　　　　　　　　　　 */
    　　　　　　　　　　private static double[]  intToDouble(int[] numbers){
        　　　　　　　　　　double[] doubles=new double[numbers.length];
        　　　　　　　　　　for(int i=0;i<numbers.length;i++){
           　　　　　　　　　　 doubles[i]=(double)(numbers[i])/100;//縮小
       　　　　　　　　　　 }
       　　　　　　　　　　 return doubles;

   　　　　　　　　　　 }

　　　　　　　　　　}

　　　　　　　　class  Test{

       　　　　　　　　　　 public static void main(String[] dfd){
           　　　　　　　　　　 double[]  moneys=new double[]{23.22,17.98,88.99,65.33,5.88,8.53};

            　　　　　　　　　　moneys=new SortAdapter().bubbleSort(moneys);

           　　　　　　　　　　 System.out.println("這是排序後的數據：");
           　　　　　　　　　　 for (double money:moneys){
                　　　　　　　　　　System.out.println(money);
           　　　　　　　　　　 }
        　　　　　　　　　　}

　　　　　　　　　　　　}
　　　　　　　　　　　　　　這是打印的結果：
　　　　　　　　　　　　　　　　

　　　　　　　　　　這是排序後的數據：
　　　　　　　　　　5.88
　　　　　　　　　　8.52
　　　　　　　　　　17.98
　　　　　　　　　　23.22
　　　　　　　　　　65.33
　　　　　　　　　　88.99

　　　　　　　　2.類適配器
　　　　　　　　　　類適配器其實是運用繼承，適配器類繼承適配者類，在適配方法中直接調用父類的方法，在上面代碼的基礎之上更改以下

　　　　　　　　　　/**
　　　　　　　　　　 * 適配者類，有一個給int類型排序的方法
　　　　　　　　　　 */
　　　　　　　　　　class SortAdaptee{

   　　　　　　　　　　 /**
     　　　　　　　　　　* 一個簡單的冒泡排序算法
    　　　　　　　　　　 * @param numbers
     　　　　　　　　　　*/
   　　　　　　　　　　 public  void bubbleSort(int[] numbers) {
        　　　　　　　　　　int temp = 0;
        　　　　　　　　　　int size = numbers.length;
        　　　　　　　　　　for(int i = 0 ; i < size-1; i ++) {
           　　　　　　　　　　 for(int j = 0 ;j < size-1-i ; j++) {
               　　　　　　　　　　 if(numbers[j] > numbers[j+1]){//交換兩數位置
                    　　　　　　　　　　temp = numbers[j];
                    　　　　　　　　　　numbers[j] = numbers[j+1];
                    　　　　　　　　　　numbers[j+1] = temp;
               　　　　　　　　　　 }
           　　　　　　　　　　 }
       　　　　　　　　　　 }
    　　　　　　　　　　}
　　　　　　　　　　}

　　　　　　　　　　/**
 　　　　　　　　　　* 適配器類
 　　　　　　　　　　*/
　　　　　　　　　　class SortAdapter extends SortAdaptee{
    　　　　　　　　　

   　　　　　　　　　　public  double[] bubbleSort(double[] numbers){
        　　　　　　　　　　int[] ints=doubleToInt(numbers);
        　　　　　　　　　　super.bubbleSort(ints);
        　　　　　　　　　　return intToDouble(ints);
    　　　　　　　　　　}

    　　　　　　　　　　/**
    　　　　　　　　　　 * 將double數組轉換成int數組，double轉int確定會丟失精度，這裏假設客戶要求保留2位小數
     　　　　　　　　　　* @param numbers
     　　　　　　　　　　* @return
     　　　　　　　　　　*/
    　　　　　　　　　　private static int[]  doubleToInt(double[] numbers){
       　　　　　　　　　　 int[] its=new int[numbers.length];
       　　　　　　　　　　 for(int i=0;i<numbers.length;i++){
           　　　　　　　　　　 its[i]=(int)(numbers[i]*100);//先放大100倍，而後再縮小，就達到了保存2位小數的目的
       　　　　　　　　　　 }
        　　　　　　　　　　return its;
    　　　　　　　　　　}

    　　　　　　　　　　/**
    　　　　　　　　　　 * 將int數組轉換成double數組
    　　　　　　　　　　 * @param numbers
     　　　　　　　　　　* @return
    　　　　　　　　　　 */
    　　　　　　　　　　private static double[]  intToDouble(int[] numbers){
        　　　　　　　　　　double[] doubles=new double[numbers.length];
        　　　　　　　　　　for(int i=0;i<numbers.length;i++){
           　　　　　　　　　　 doubles[i]=(double)(numbers[i])/100;//縮小
       　　　　　　　　　　 }
       　　　　　　　　　　 return doubles;

   　　　　　　　　　　 }

　　　　　　　　　　}

　　　　　　　　class  Test{

       　　　　　　　　　　 public static void main(String[] dfd){
           　　　　　　　　　　 double[]  moneys=new double[]{23.22,17.98,88.99,65.33,5.88,8.53};

            　　　　　　　　　　moneys=new SortAdapter().bubbleSort(moneys);

           　　　　　　　　　　 System.out.println("這是排序後的數據：");
           　　　　　　　　　　 for (double money:moneys){
                　　　　　　　　　　System.out.println(money);
           　　　　　　　　　　 }
        　　　　　　　　　　}

　　　　　　　　　　　　}
　　　　　　　　　　　　　　這是打印的結果：
　　　　　　　　　　　　　　　　

　　　　　　　　　　這是排序後的數據：
　　　　　　　　　　5.88
　　　　　　　　　　8.52
　　　　　　　　　　17.98
　　　　　　　　　　23.22
　　　　　　　　　　65.33
　　　　　　　　　　88.99

　　　　　　　　3.缺省適配器

　　　　　　　　　　設計一個抽象類實現該接口，併爲接口中每一個方法提供一個默認實現（空方法），那麼該抽象類的子類能夠選擇性地覆蓋父類的某些方法來實現需求，它適用於不想使用一個接口中的
　　　　　　　　　　全部方法的狀況，又稱爲單接口適配器模式。這種實現方式較爲簡單，我這裏就不實現了

　　　　三：應用場景
　　　　　　　　
　　　　　　　　(1) 系統須要使用一些現有的類或者接口，而這些類或者接口（如方法名）不符合系統的須要，甚至沒有這些類的源代
　　　　　　　　(2) 想建立一個能夠重複使用的類或者接口，用於與一些彼此之間沒有太大關聯的一些類，包括一些可能在未來引進的類一塊兒工做