结构型模式----适配器模式

最新推荐文章于 2024-08-26 15:04:52 发布

Zach_ZSZ

最新推荐文章于 2024-08-26 15:04:52 发布

阅读量194

点赞数

分类专栏：学习笔记设计模式设计模式--Java实现篇文章标签：学习笔记设计模式

本文链接：https://blog.csdn.net/z_s_z2016/article/details/80725401

版权

学习笔记同时被 3 个专栏收录

24 篇文章 0 订阅

订阅专栏

设计模式--Java实现篇

18 篇文章 1 订阅

订阅专栏

设计模式

17 篇文章 0 订阅

订阅专栏

1. 适配器模式定义

将一个接口转换成客户希望的另一个接口,使接口不兼容的那些类可以一起工作.(注:该处的接口是指广义的接口,可以表示一个方法或者方法的集合)

2. 结构图

3. 角色分析

Target(目标抽象类):定义客户所需接口,可以是一个抽象类,接口或具体类
Adapter(适配器类):可调用另一个接口,作为一个转换器,对Adaptee和Target进行适配,是适配器模式的核心,在对象适配器模式中,通过继承一个Target并关联一个Adaptee对象使二者产生联系
Adaptee(适配者类):即被适配的角色

4. 核心代码

Class Adapter extends Target{ 
	private Adaptee adaptee;  //维持一个对适配者对象的引用
	 
	public Adapter(Adaptee adaptee){ 
	  this.adaptee=adaptee;
	}
	 
	public void request(){ 
	   adaptee.specificRequest(); 转发调用
	}
}

5. 实践案例

1) 方案结构图

2) 实现代码

package com.zach.adapter;

//抽象成绩操作类:目标接口
public interface ScoreOperation {
        public int[] sort(int array[]);  //成绩排序
        public int search(int array[],int key);  //成绩查找
}


package com.zach.adapter;
//快速排序类:适配者
public class QuickSort {
        
        public int[] quickSort(int array[]){
                sort(array,0,array.length-1);
                return array;
        }

        public void sort(int array[], int p, int r) {
                // TODO Auto-generated method stub
                int q=0;
                if(p<r){
                        q=partition(array,p,r);
                        sort(array,p,q-1);
                        sort(array,q+1,r);
                }
        }

        public int partition(int[] a, int p, int r) {
                int x=a[r];
                int j=p-1;
                for(int i=p;i<=r-1;i++){
                        if(a[i]<=x){
                                j++;
                                swap(a,j,i);
                        }
                }
                swap(a,j+1,r);
                return j+1;
                // TODO Auto-generated method stub
        }

        public void swap(int[] a, int i, int j) {
                // TODO Auto-generated method stub
                int t = a[i];
                a[i] = a[j];
                a[j] = t;
        }
}


package com.zach.adapter;

//二分法查找类:适配者
public class BinarySearch {
        
        public int binarySearch(int array[],int key){
                int low = 0;
                int high = array.length-1;
                while(low<=high){
                        int mid = (low +high)/2;
                        int midVal = array[mid];
                        if(midVal<key){
                                low = mid+1;
                        }else if(midVal >key){
                                high = mid-1;
                        }else {
                                return 1;  //找到元素
                        }
                }
                
                return -1;  //未找到元素返回-1
        }
}


package com.zach.adapter;

//操作适配器:适配器
public class OperationAdapter implements ScoreOperation {
        
        private QuickSort sortObj;  //定义适配者QuickSort对象
        private BinarySearch searchObj;  //定义适配者binarySearch对象
        
        
        public OperationAdapter() {
                sortObj = new QuickSort();
                searchObj = new BinarySearch();
        }

        @Override
        public int[] sort(int[] array) {
                
                return sortObj.quickSort(array);
        }

        @Override
        public int search(int[] array, int key) {
                // TODO Auto-generated method stub
                return searchObj.binarySearch(array, key);  //调用适配者类BinarySearch的查找方法
        }

}


package com.zach.adapter;

//客户端代码
public class Client {
        public static void main(String[] args) {
                
                //可以将类配置在配置文件中,提高扩展性,此处就不展示
                ScoreOperation operation = new OperationAdapter();
                int scores[] = {84,76,50,69,90,91,88,96};
                System.out.println("成绩排序结果:");
                int result[] = operation.sort(scores);
                
                //遍历输出成绩
                for (int i : result) {
                        System.out.print(i+",");
                        
                }
                
                System.out.println();
                int score = 0;
                System.out.println("查找成绩90:");
                 score = operation.search(result, 90);
                
                if(score !=-1){
                        System.out.println("找到成绩90.");
                }else{
                        System.out.println("没有找到成绩90.");
                }
                
                System.out.println("查找成绩92:");
                 score = operation.search(result, 92);
                
                if(score !=-1){
                        System.out.println("找到成绩92.");
                }else{
                        System.out.println("没有找到成绩92.");
                }
                
        }
}

6. 类适配器模式

类适配器模式与对象适配器模式最大的区别在于其适配器和适配者之间关系是继承关系

1) 类适配器模式结构图

2) 核心代码

class Adapter extends Adaptee implements Target{ 

    public void request(){
        specificRequest();
    
    }
}

7. 双向适配器模式

在对象适配器模式使用过程中,如果在适配器中同时包含对目标类和适配者类的引用,适配者可以通过它调用目标类的方法,目标类也可以通过它调用适配者类中的方法,则该适配器就是一个双向适配器

1) 双向适配器结构图

2) 核心代码

class Adapter implements Target,Adaptee {  

    //同时维持对抽象目标类和适配者的引用  
    private Target target;  
    private Adaptee adaptee;
    

    public Adatpter(Target target){  
        
        this.target = target;

    }

    public Adapter(Adaptee adaptee) { 

        this.adaptee = adaptee; 
    }

    public void request(){ 
        adaptee.specificRequest();
    }

    public void specificRequest(){ 
        target.request();
    }
}