设计模式-8-适配器模式-继承

简介：将类自己的接口包裹在一个已存在的类中

目的：让一个类即有原有类的功能，又能实现某个接口

总结：通过继承+实现，使类具有被继承类和接口的功能

组成：继承+实现类

缺点：实现接口后，子类有不该实现的方法产生

举例：让HashMap成为观察者，被观察者发生变化，HashMapi做出相应处理

1，基础类

观察者

package com.design.h.adapter.classs;
/**
 * 观察者接口
 */
public interface ObserverService {
    
    /**
     * 被观察者发生改变需要观察者执行的动作
     */
    Boolean update();

}

package com.design.h.adapter.classs;

/**
 * 观察者A
 */
public class ObserverAServiceImpl implements ObserverService {

    @Override
    public Boolean update() {
        System.out.println("收到被观察者的变化    --> 观察者A  -->  相应的处理 ");
        return true;
    }

}

package com.design.h.adapter.classs;

/**
 * 观察者B
 */
public class ObserverBServiceImpl implements ObserverService {

    @Override
    public Boolean update() {
        System.out.println("收到被观察者的变化    --> 观察者B  -->  相应的处理 ");
        return true;
    }

}

被观察者

package com.design.h.adapter.classs;

import java.util.ArrayList;
import java.util.List;

/**
 * 被观察者
 */
public class Observable {
    
    
    //1-记录观察者
    private List<ObserverService> observers = new ArrayList<ObserverService>();
    public Boolean addObserver(ObserverService observerService){
        return observers.add(observerService);
    }
    
    
    //2-发生改变的动作
    public void changed(){
        System.out.println("被观察者已发生变化   ... ... ");
        notifyObserver();
        
    }
    
    //3-通知观察者
    private void notifyObserver(){
        System.out.println("被观察者开始通知观察者   ... ... ");
        for(ObserverService observerService : observers){
            observerService.update();
        }
    }

}

2，继承+实现类

package com.design.h.adapter.classs;

import java.util.HashMap;
/**
 * 使用适配器模式  - 让HashMap成为观察者
 * 
 * HashMap没有实现Observer接口无法使用观察者模式  - 但是通过适配器可以实现该功能
 * 
 * @param <K>
 * @param <V>
 */
public class HashMapObserverAdapter<K, V> extends HashMap<K, V> implements ObserverService {

    private static final long serialVersionUID = 8102076452770429152L;

    @Override
    public Boolean update() {
        
        System.out.println("收到被观察者的变化    --> HashMap适配器  -->  相应的处理   <清空Map> ");
        //被观察者发生变化-清空Map
        super.clear();
        return false;
    }

}

3，Main

package com.design.h.adapter.classs;
/**
 * 适配器模式 - 类适配器(继承)
 * 
 * 需求:需要HashMap这种源码中的类支持观察者模式,因为HashMap没有实现观察者接口ObserverService不能直接观察,所以必须使用适配器模式实现
 *     HashMapObserverAdapter先继承HashMap拥有HashMap功能,然后实现观察者接口ObserverService
 * 
 * 实现方式：1-类适配器(继承)    2-对象适配器(组合)
 * 使用目的：1-特殊适配器(复用原有代码)   2-缺省适配器(避免子类实现不该实现的方法)
 */
public class MainTest {
    
    public static void main(String[] args) {
        
        /**
         * 观察者模式-自定义
         */
        //1-创建观察者
        ObserverService observerA = new ObserverAServiceImpl();
        ObserverService observerB = new ObserverBServiceImpl();
        
        /**
         * HashMap适配器  - 使用HashMap成为观察者
         */
        @SuppressWarnings("rawtypes")
        HashMapObserverAdapter hashMapObserverAdapter = new HashMapObserverAdapter();
        
        //2-向被观察者添加观察者
        Observable observed = new Observable();
        observed.addObserver(observerA);
        observed.addObserver(observerB);
        
        /**
         * HashMap适配器加入到观察者列表
         */
        observed.addObserver(hashMapObserverAdapter);
        
        //3-触发被观察者发生改变,通知观察者
        observed.changed();
    }

}

4，Result

被观察者已发生变化   ... ... 
被观察者开始通知观察者   ... ... 
收到被观察者的变化    --> 观察者A  -->  相应的处理 
收到被观察者的变化    --> 观察者B  -->  相应的处理 
收到被观察者的变化    --> HashMap适配器  -->  相应的处理   <清空Map>