桥接模式

现实中场景:发送提示消息
从业务上看，消息又分成普通消息、加急消息和特急消息多种，
不同的消息类型，业务功能处理是不一样的：
    加急消息是在消息上添加加急，而特急消息除了添加特急外，还会做一条催促的记录，多久不完成会继续催促。

从发送消息的手段上看，又有系统内短消息、手机短消息、邮件等等。


考虑简单情况：
    消息先只是实现发送普通消息，先实现系统内短消息和邮件。其它的功能
 
   

 public interface Message {   
    	public void send(String message,String toUser);   
    }

 public  class CommonMessageSMS implements Message{   
    	public void send(String message, String toUser) {   
            System.out.println("使用站内短消息的方式，发送消息'"      +message+"'给"+toUser);   
    	}   
    }
    
    public class CommonMessageEmail implements Message{   
    	public void send(String message, String toUser) {   
            System.out.println("使用Email的方式，发送消息'"  +message+"'给"+toUser);   
    	}   
    }

添加发送加急消息的功能，也有两种发送的方式，同样是站内短消息和Email的方式。

public interface UrgencyMessage extends Message{   
    public Object watch(String messageId);   
}

public class UrgencyMessageSMS implements UrgencyMessage{   
    public void send(String message, String toUser) {   
        message = "加急："+message;   
        System.out.println("使用站内短消息的方式，发送消息'"   
		+message+"'给"+toUser);   
    }   
   
    public Object watch(String messageId) {   
        //获取相应的数据，组织成监控的数据对象，然后返回          
        return null;   
    }      
}   



public class UrgencyMessageEmail implements UrgencyMessage{   
    public void send(String message, String toUser) {   
        message = "加急："+message;   
        System.out.println("使用Email的方式，发送消息'"   
		+message+"'给"+toUser);   
    }   
    public Object watch(String messageId) {   
        //获取相应的数据，组织成监控的数据对象，然后返回          
        return null;   
    }      
}

对于特急消息，在普通消息的处理基础上，需要添加催促的功能。
如果要实现特急消息的功能，又要新继承一个借口 并且新增两个实现类

以上继承的方式实现的缺陷是:

扩展消息的种类不太容易,不同种类的消息具有不同的业务，也就是有不同的实现.
更可怕的是，如果要新加入一种消息的发送方式，那么会要求所有的消息种类，都要加入这种新的发送方式的实现。

桥接模式定义:  将抽象部分与它的实现部分分离，使它们都可以独立地变化。
应用桥接模式来解决的思路:
示例的变化具有两个纬度，一个纬度是抽象的消息这边，包括普通消息、加急消息和特急消息，另一个纬度为消息发送方式：包括站内短消息、Email和手机短信息。

Implementor：
        定义实现部分的接口,提供基本操作
Abstraction：
        抽象部分的接口。里面定义的是基于这些基本操作的业务方法，
RefinedAbstraction
          扩展抽象部分的接口，通常在这些对象里面，定义跟实际业务相关的方法，
       
ConcreteImplementor：
         真正实现Implementor接口的对象。

public interface Implementor {   
    public void operationImpl();   
}

public abstract class Abstraction {   
    protected Implementor impl;   
    public Abstraction(Implementor impl){   
        this.impl = impl;   
    }   
    public void operation() {   
        impl.operationImpl();   
    }   
    
}
 



public class ConcreteImplementorA implements Implementor {   
    public void operationImpl() {    
        //真正的实现   
    }   
}

public class ConcreteImplementorB implements Implementor {   
    public void operationImpl() {    
        //真正的实现   
    }   
}   


public class RefinedAbstraction extends Abstraction {   
    public RefinedAbstraction(Implementor impl) {   
        super(impl);   
    }   
    /**  
     * 示例操作，实现一定的功能  
     */   
    public void otherOperation(){   
        //实现一定的功能，可能会使用具体实现部分的实现方法，   
        //但是本方法更大的可能是使用Abstraction中定义的方法，   
        //通过组合使用Abstraction中定义的方法来完成更多的功能   
    }   
}   

使用上述架构实现发送提示消息的实例如下:
//消息发送业务接口

public interface MessageImplementor {   
    public void send(String message,String toUser);   
}   

public abstract class AbstractMessage {   
       
    protected MessageImplementor impl;   
       
    public AbstractMessage(MessageImplementor impl){   
        this.impl = impl;   
    }   
       
    public void sendMessage(String message,String toUser){   
        this.impl.send(message, toUser);   
    }      
}   


public  class MessageSMS implements MessageImplementor{   
    public void send(String message, String toUser) {   
        System.out.println("使用站内短消息的方式，发送消息'"   
		+message+"'给"+toUser);   
    }   
    
    
    public class MessageEmail implements MessageImplementor{   
    public void send(String message, String toUser) {   
        System.out.println("使用Email的方式，发送消息'"   
                               +message+"'给"+toUser);   
    }   
}



public class CommonMessage extends AbstractMessage{   
    public CommonMessage(MessageImplementor impl) {   
        super(impl);   
    }   
    public void sendMessage(String message, String toUser) {   
        super.sendMessage(message, toUser);   
    }      
}


public class UrgencyMessage extends AbstractMessage{   
    public UrgencyMessage(MessageImplementor impl) {   
        super(impl);   
    }   
    public void sendMessage(String message, String toUser) {   
        message = "加急："+message;   
        super.sendMessage(message, toUser);   
    }   
    
    public Object watch(String messageId) {   
        return null;   
    }      
}   

这样，如果我们想扩展实现发送特急消息，只需要增加一个抽象的实现：

public class SpecialUrgencyMessage extends AbstractMessage{   
    public SpecialUrgencyMessage(MessageImplementor impl) {   
        super(impl);   
    }   
    public void hurry(String messageId) {   
        //执行催促的业务，发出催促的信息   
    }   
    public void sendMessage(String message, String toUser) {   
        message = "特急："+message;   
        super.sendMessage(message, toUser);   
        //还需要增加一条待催促的信息   
    }   
}   

  
 

如果要增加一种发送方式：比如手机发送，只需要增加一种实现就OK了

public  class MessageMobile implements MessageImplementor{   
    public void send(String message, String toUser) {   
        System.out.println("使用手机短消息的方式，发送消息'"   
		+message+"'给"+toUser);   
    }   
}   

测试功能:

public class Client {   
    public static void main(String[] args) {   
        //创建具体的实现对象   
        MessageImplementor impl = new MessageSMS();   
        //创建一个普通消息对象   
        AbstractMessage m = new CommonMessage(impl);   
        m.sendMessage("请喝一杯茶", "小李");          
        //创建一个紧急消息对象   
        m = new UrgencyMessage(impl);   
        m.sendMessage("请喝一杯茶", "小李");          
        //创建一个特急消息对象   
        m = new SpecialUrgencyMessage(impl);   
        m.sendMessage("请喝一杯茶", "小李");   
           
        //把实现方式切换成手机短消息，然后再实现一遍   
        impl = new MessageMobile();   
        m = new CommonMessage(impl);   
        m.sendMessage("请喝一杯茶", "小李");   
        m = new UrgencyMessage(impl);   
        m.sendMessage("请喝一杯茶", "小李");   
        m = new SpecialUrgencyMessage(impl);   
        m.sendMessage("请喝一杯茶", "小李");   
    }   
}   

桥接模式和策略模式的区别:
桥接模式的抽象部分，是可以继续扩展和变化的，而策略模式只有上下文，是不存在所谓抽象部分的。