结构型设计模式之桥接模式（Bridge）

这里假设我要从网上每购买一件产品，都会经历一下步骤：下单->生产->邮寄->签收,四个流程，代码实现如下：

public class Bridge_01 {

    static abstract class Product{

        public abstract void product();

        public abstract void post();

        public void order(){
            this.product();
            this.post();
        }
    }
    //衣服厂商
    static class Clothes extends Product{
        @Override
        public void product() {
            System.out.println("==============生产衣服==============");
        }

        @Override
        public void post() {
            System.out.println("==============邮寄衣服==============");
        }

        @Override
        public void order() {
            System.out.println("==============衣服下单==============");
            super.order();
        }
    }
    //鞋子厂商
    static class Shoes extends Product{
        @Override
        public void product() {
            System.out.println("==============生产鞋子==============");
        }

        @Override
        public void post() {
            System.out.println("==============邮寄鞋子==============");
        }

        @Override
        public void order() {
            System.out.println("==============鞋子下单==============");
            super.order();
        }
    }

    public static void main(String[] args) {
        //购买衣服
        Product clothes = new Clothes();
        clothes.order();
        System.out.println("====================================");
        //购买鞋子
        Product shoes = new Shoes();
        shoes.order();
    }
}

以上代码使用了模板方法模式，模拟了下单后厂家生产和邮寄商品的过程，每购买一件不同种类商品都要新增加一个商品类，实现这两个方法。同时在客户端也要新创建一个对象，然后调用对应的order()。
但是突然有一天，鞋子厂商和衣服厂商合并了，那么就意味着新的厂商可以同时生产两种不同的产品，那这个时候怎么正确下单购买商品呢，看下面的代码：

public class Bridge_02 {

    static abstract class Product{

        public abstract void product();

        public abstract void post();

        public void order(){
            this.product();
            this.post();
        }
    }
    //衣服
    static class Clothes extends Product{
        @Override
        public void product() {
            System.out.println("==============生产衣服==============");
        }

        @Override
        public void post() {
            System.out.println("==============邮寄衣服==============");
        }

        @Override
        public void order() {
            System.out.println("==============衣服下单==============");
            super.order();
        }
    }
    //鞋子
    static class Shoes extends Product{
        @Override
        public void product() {
            System.out.println("==============生产鞋子==============");
        }

        @Override
        public void post() {
            System.out.println("==============邮寄鞋子==============");
        }

        @Override
        public void order() {
            System.out.println("==============鞋子下单==============");
            super.order();
        }
    }
    //鞋子和衣服厂商
    static class ShoesAndClothes extends Product{
        private Product product;

        public ShoesAndClothes(Product product) {
            this.product = product;
        }

        @Override
        public void product() {
            this.product.product();
        }

        @Override
        public void post() {
            this.product.post();
        }

        @Override
        public void order() {
            this.product.order();
        }
    }
    public static void main(String[] args) {
        //购买鞋子
        ShoesAndClothes shoesAndClothes = new ShoesAndClothes(new Shoes());
        shoesAndClothes.order();
        System.out.println("-----------------------------------");
        //购买鞋子
        shoesAndClothes = new ShoesAndClothes(new Clothes());
        shoesAndClothes.order();
    }
}

这里新增了一个衣服和鞋子厂商，接受了一个厂商类型（任然保留各自的生产线）作为构造函数参数传入，调用对应的方法就可以准确下单。但是作为一个新的厂商来讲，我收购了衣服和鞋子厂商，他们的流水线、工人、还有工作流程都全部保留，只是我赚钱的工具，以后有兴趣还可以自己建一个流水线，生产其他的产品呢。
所以新的厂商只是将其他的生产线收购而来，要生产什么，只需要告诉新厂商，新厂商会自动下发到对应的流水线进行生产工作等。但是这里存在问题，新厂商和就的厂商都继承Product,那如果Product新增一个流水操作，对应的所有子类都必须添加，但是对新的厂商来讲，我根本不关心啊，我只要把单子给到流水线，自动生产就行了呀，多省事儿呢，那根据以上逻辑我们对上面的代码做些优化：

public class Bridge_03 {
    //厂家
    static abstract class Factory{
        private Product product;

        public Factory(Product product) {
            this.product = product;
        }

        public void order(){
            this.product.product();
            this.product.post();
        }

        public Product getProduct() {
            return product;
        }
    }
    //商品生产流水线
    interface Product{
        public abstract void product();

        public abstract void post();
    }
    //衣服
    static class Clothes implements Product{
        @Override
        public void product() {
            System.out.println("==============生产衣服==============");
        }

        @Override
        public void post() {
            System.out.println("==============邮寄衣服==============");
        }

    }
    //鞋子
    static class Shoes implements Product{
        @Override
        public void product() {
            System.out.println("==============生产鞋子==============");
        }

        @Override
        public void post() {
            System.out.println("==============邮寄鞋子==============");
        }

    }
    //厂商
    static class ProductFactory extends Factory{

        public ProductFactory(Product product) {
            super(product);
        }

        @Override
        public void order() {
            super.order();
            System.out.println("==============做其他事情=============");
        }
    }
    public static void main(String[] args) {
        Factory factory = new ProductFactory(new Clothes());
        factory.order();
    }
}

以上代码进行了重构，将商品流水线的工作抽象成一个接口，各个流水线去实现对应的方法，一心一意的去做该做的事情。而抽象了一个厂家类，接受要生产商品的流水线，然后调用模板方法进行下单生产即可。

桥梁模式的官方定义：将抽象和实现解耦，使得两者可以独立的变化。