设计模式之桥接模式

桥接模式 Bridge


定义：
将抽象部分与实现部分分离，使得他们都可以独立地进行变化


好处：简化类结构


Abstraction：抽象部分
RefinedAbstraction：具体的抽象实现（优化的抽象部分）


Implementor：实现部分
ConcreteImplementorA/ConcreteImplementorB 具体的实现

场景一：
咖啡
大杯加糖、大杯不加糖
小杯加糖、小杯不加糖


抽象部分：Coffee


实现部分：CoffeeAdditives


相互独立成一个维度，可以独立变化




场景二：
消息类型，普通消息，加急消息，特级消息


消息发送的方式：系统内短消息，手机短消息，邮件，微信


被动-抽象
主动、具体-实现


不使用继承，使用动态组合


优点：
减少子类
更好的扩展性
动态组合


本质：分离抽象和实现


View 抽象部分

HardwareLayer Canvas DisplayList 实现部分

具体代码如下：

场景一：

咖啡相关接口类：

/**
 * 抽象咖啡（抽象部分）
 */
public abstract class Coffee {

	// 咖啡添加物（实现部分的引用）
	protected CoffeeAdditives impl;

	public Coffee(CoffeeAdditives impl) {
		super();
		this.impl = impl;
	}
	
	/**
	 * 制作具体的咖啡
	 */
	public abstract void makeCoffee();

}

/**
 * 大杯咖啡
 * @date 2016年2月25日
 */
public class LargelCoffee extends Coffee {

	public LargelCoffee(CoffeeAdditives impl) {
		super(impl);
	}

	@Override
	public void makeCoffee() {
		System.out.println("大杯的"+impl.add()+"咖啡");
	}

}

/**
 * 中杯咖啡
 * @date 2016年2月25日
 */
public class MiddleCoffee extends Coffee {

	public MiddleCoffee(CoffeeAdditives impl) {
		super(impl);
	}

	@Override
	public void makeCoffee() {
		System.out.println("中杯的"+impl.add()+"咖啡");
	}

}

/**
 * 小杯咖啡
 * @date 2016年2月25日
 */
public class SmallCoffee extends Coffee {

	public SmallCoffee(CoffeeAdditives impl) {
		super(impl);
	}

	@Override
   public void makeCoffee() {
        System.out.println("小杯的"+impl.add()+"咖啡");
   }

}

咖啡添加作料接口类：

/**
 * 咖啡添加物（实现部分）
 * @date 2016年2月25日
 */
public abstract class CoffeeAdditives {

	/**
	 * 添加
	 * @return
	 */
	public abstract String add();
	
}

/**
 * 原味
 * @date 2016年2月25日
 */
public class Ordinary extends CoffeeAdditives {

	@Override
	public String add() {
		return "原味";
	}

}

/**
 * 糖
 * @date 2016年2月25日
 */
public class Sugar extends CoffeeAdditives {

	@Override
	public String add() {
		return "加糖";
	}

}

调用示例：

public class Client {

	public static void main(String[] args) {
		//实现部分
		//添加物
		Sugar s1 = new Sugar();
		
		//抽象部分
		//杯型
		LargelCoffee c1 = new LargelCoffee(s1);
		
		c1.makeCoffee();
		
		//
		MiddleCoffee c2 = new MiddleCoffee(s1);
		c2.makeCoffee();
		
		SmallCoffee c3 = new SmallCoffee(s1);
		c3.makeCoffee();
		
	}

}

运行结果：

大杯的加糖咖啡
中杯的加糖咖啡
小杯的加糖咖啡

###################################################################################

场景二：消息场景

消息结口类：

/**
 * 消息类型（抽象部分）
 * @date 2016年2月25日
 */
public abstract class AbstractMessage {

	//实现部分的引用（能够类组合的关键）
	protected MessageImplementor implementor;
	
	public AbstractMessage(MessageImplementor implementor) {
		this.implementor = implementor;
	}
	
	/**
	 * 发送消息
	 * @param message
	 * @param to
	 */
	public void sendMessage(String message,String to){
		implementor.send(message, to);
	}
	
}

/**
 * 普通消息
 * @date 2016年2月25日
 */
public class CommonMessage extends AbstractMessage {

	public CommonMessage(MessageImplementor implementor) {
		super(implementor);
	}
	@Override
    public void sendMessage(String message, String to) {
    	message = "普通消息 --- "+message;
    	super.sendMessage(message, to);
    }
}

/**
 * 特急消息 
 * @date 2016年2月25日 
 */
public class SpecialUrgencyMessage extends AbstractMessage{

	public SpecialUrgencyMessage(MessageImplementor implementor) {
		super(implementor);
	}
	
    @Override
    public void sendMessage(String message, String to) {
    	message = "特急消息 --- "+message;
    	super.sendMessage(message, to);
    }
}

/**
 * 紧急消息 
 * @date 2016年2月25日 
 */
public class UrgencyMessage extends AbstractMessage {

	public UrgencyMessage(MessageImplementor implementor) {
		super(implementor);
	}
	@Override
    public void sendMessage(String message, String to) {
    	message = "紧急消息 --- "+message;
    	super.sendMessage(message, to);
    }
}

发送方式相关类接口：

/**
 * 发送方式（实现部分接口）
 * @date 2016年2月25日
 */
public interface MessageImplementor {

	/**
	 * 发送消息
	 * @param message
	 * @param to
	 */
	public void send(String message,String to);
}

/**
 * 邮件消息
 * @date 2016年2月25日
 */
public class MessageEmail implements MessageImplementor {

	@Override
	public void send(String message, String to) {
		System.out.println("发送一条邮件消息："+message+",给："+to);
	}

}

/**
 * 手机短消息
 * @date 2016年2月25日
 */
public class MessageMobile implements MessageImplementor{

	@Override
	public void send(String message, String to) {
		System.out.println("发送手机短消息："+message+",给："+to);
	}

}

/**
 * 站内消息
 * @date 2016年2月25日
 */
public class MessageSMS implements MessageImplementor {

	@Override
	public void send(String message, String to) {
		System.out.println("发送一条站内消息："+message+",给："+to);
	}

}

调用示例：

public class Client {

	public static void main(String[] args) {
		
		//发送一条普通的站内消息
		
		//具体的实现部分
		MessageSMS im1 = new MessageSMS();
		//具体的抽象部分
		CommonMessage m1 = new CommonMessage(im1);
		
		m1.sendMessage("大家都在关心你有没有男盆友？", "丽丽童鞋");
		
		//邮件方式
		MessageEmail im2 = new MessageEmail();
		//特急消息
		SpecialUrgencyMessage m2 = new SpecialUrgencyMessage(im2);
		
		m2.sendMessage("月亮要你回家吃饭！", "太阳"); 
	}

}

运行结果：即达到发送方式和消息类型可以随意组合的效果

发送一条站内消息：普通消息 --- 大家都在关心你有没有男盆友？,给：丽丽童鞋
发送一条邮件消息：特急消息 --- 月亮要你回家吃饭！,给：太阳

整理自教程