设计模式之桥接模式

1. 桥接模式（Bridge Pattern）

• Decouple an abstraction from its implementation so that the two can varyindependently.
• 桥接模式使用组合关系将代码的实现层和抽象层分离，让实现层与抽象层代码可以分别自由变化
• 桥接模式可替代多重继承

1.2 组成部分

抽象实现器 Implementor接口
具体实现器 ConcreteImplementor

2. 示例

@Test
public void test() {
    IPost simplePost = new SimplePost();
    Letter letter = new Letter(simplePost);
    letter.post();
}

public interface IPost {
    // 发送邮件
    void post();
}

public class SimplePost implements IPost {
    @Override
    public void post() {
        System.out.println("This is simple post");
    }
}

public class MarkPost implements IPost {
    @Override
    public void post() {
        System.out.println("This is mark post");
    }
}

public abstract class AbstractThing {
    private IPost post;

    public AbstractThing(IPost post) {
        this.post = post;
    }

    public void post() {
        post.post();
    }
}

public class Letter extends AbstractThing {
    public Letter(IPost post) {
        super(post);
    }
}

public class Parcel extends AbstractThing {
    public Parcel(IPost post) {
        super(post);
    }
}

说明：
先在功能类中选择一个具体的发送功能，再选择一个事物类，最后完成真正的发送过程

总结来说，桥接模式完成的是一个多条件选择问题。
假设有二维条件，分别有N1、N2个选择，桥接模式要求在第1维N1个条件中选择一个，在第2维N2个条件中选择一个，最后完成有效组合

3. 应用场景

3.1 JDK集合排序

public class Collections {
    default void sort(Comparator<? super E> c) {
        Object[] a = this.toArray();
        Arrays.sort(a, (Comparator) c);
        ListIterator<E> i = this.listIterator();
        for (Object e : a) {
            i.next();
            i.set((E) e);
        }
    }
}

集合对象排序是借助Arrays中的sort()方法完成的
从中也能分析出JDK设计人员的设计思想，即数组和集合类都有排序功能，必须实现数组排序算法；集合对象要先转换成数组，排序后，再填充集合对象即可

扩展：
运用桥接思想实现二分查找

@Test
public void demo() {
    List<String> list = Arrays.asList("111", "444", "555", "222", "444");
    MyList myList = new MyList(list);
    int i = myList.binarySearch("444");
    System.out.println(i);
}

public class MyList<T> {
    List<T> list;
    Object[] arr;

    /**
     * 在构造方法中直接将集合对象转为数组
     */
    public MyList(List<T> vec) {
        list = vec;
        arr = vec.toArray();
    }

    public void sort() {
        Arrays.sort(arr);
    }

    /**
     * 直接对排序后的数组二分查找
     * @param key 查找的值
     */
    public int binarySearch(T key) {
        int pos = Arrays.binarySearch(arr, key);
        return pos;
    }

    public void show() {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + "\t");
        }
    }

    /**
     * 将数组填充回集合
     */
    public void fill() {
        ListIterator<T> i = list.listIterator();
        for (int j = 0; j < arr.length; j++) {
            i.next();
            i.set((T) arr[j]);
        }
    }
}