Java设计模式 之 接口型模式

  1.适配器模式(Adapter)

      概述:

      在软件开发过程中,我们要经常要复用我们以前开发的一些“现存对象”，但是这些“现存对象”并不能满足我们新的应用环境。怎样才能良好的复用这些对象，以满足我们的应用环境，这就是适配器（Adapter）所要解决的问题。

 

意图：

　　　将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 

　　　　　　　                                                                                               　         ——《设计模式》GOF 

 

生活中的例子：

      在现实生活中，像这种适配器我们经常见到，而且还是经常使用它，如：手机（深信大家都见过），我们手机在充电的时候，不可能直接在220V电源上直接充电，而是手机“充电器”.列如我们

的电脑也不可能直接在220V电影上直接冲电,也用到了电源适配器,然而电脑电源适配器和手机电源

适配器又有所不同。

 

有两类适配器模式：

·对象适配器模式 - 在这种适配器模式中，适配器容纳一个它我包裹的类的实例。在这种情况下，适配器调用被包裹对象的物理实体。

·类适配器模式 - 这种适配器模式下，适配器继承自已实现的类（一般多重继承）。

 

类适配器模式:    

  

/**
 * 电源适配器接口
 * @author tanlvxu
 *
 */
public interface SuittedPower {
    public int getCorrectPower(); 
}


/**
 * 220V电源类
 * @author tanlvxu
 *
 */
public class Power {
	
    public int getPower(){
       //得到220V电压	
    	return 220 ;
    }
}

/**
 * 电脑适配器类
 * @author tanlvxu
 *
 */
public class ComputerAdapter extends Power implements SuittedPower{

	@Override
	public int getCorrectPower() {
	 int power = super.getPower() ;//得到电源电压
	 //经过一些手段改变电压
	  return power/2 ;
	}
}
/**
 * 手机适配器类
 * @author tanlvxu
 *
 */
public class PhoneAdapter extends Power implements SuittedPower{

	@Override
	public int getCorrectPower() {
	 int power = super.getPower() ;//得到电源电压
	 //经过一些手段改变电压
	  return power/3 ;
	}
}
/**
 * 测试类
 * @author tanlvxu
 *
 */
public class MainTest {
    public static void main(String[] args) {
		SuittedPower pAdapter = new PhoneAdapter() ;
		System.out.println("手机得到的电压是: "+pAdapter.getCorrectPower()) ;
		SuittedPower cAdapter = new ComputerAdapter() ;
	    System.out.println("电脑得到的电压是: "+cAdapter.getCorrectPower()) ;
    
    }
    
}

 对象适配器模式：

 将Power类的实例对象作为参数传递到适配器类
         Power power = new Power() ;

         ComputerAdapter cAdapter = new ComputerAdapter(power);
         cAdapter.gerCorrectPower() ;

 

  在SurfaceView中要画出各种状态,又要展示以前所画的,

  所以就采用一个GameState抽象类

  public abstract class GameState{

    private GameState gameState = null ;

    public GameState(GameState gameState){

       this.gameState = gameState ;

    }

    public void rDraw(Canvas canvas){

          gameState.draw() ;

    }

    //子类重写该方法

    public void draw(Canvas canvas) ;

}

 

 

2.外观模式(Facade)和 组合模式(Composite)

      外观模式又称门面模式，它是为了给子系统中提供一个一致的界面，从面定义了一个高层接口 ，这个接口使得这一子系统更加容易使用。

        列如我们以前写的Socket客户端,客户程序可能会像下图一样零乱。

 这样错综复杂,极有可能影响到客户端的性能

 外观模式就是为了解决这种问题而产生的，下面是使用了门用模式后的图

 

我们可以这样设计:1.client

 

/**
 * 消息类
 * @author tanlvxu
 *
 */
public class Message {
	private int type;
	private String content;
    public Message(int type,String content){
    	this.type = type ;
    	this.content = content ;
    }
	//以及属性所对应的getter,setter方法
}

/**
 * 模拟从服务器读取信息
 * @author tanlvxu
 *
 */
public class ReadMsg implements Runnable{
 
    public ReadMsg(){
    	Thread thread = new Thread(this) ;
    	thread.start() ;
    }
	@Override
	public void run() {
		//从服务器读取信息
		Message mes = new Message(1,"再见孙悟空") ;
		for(ListenerAdapter ls : MyConfig.list ){
			ls.dealMsg(mes) ;
		}		
	}
}

            
2.facade：用一个静态对象List来做桥梁
    

/**
 * facade
 * @author tanlvxu
 *
 */
public interface MyConfig {
	List<ListenerAdapter> list = new ArrayList<ListenerAdapter>() ;
}

 
 3.ClietUI:这里运用了组合模式(Composite)

    自定各种组件，实现其独自的监听模式，然后组装起来，互不干扰

   

/**
 * 自定义JFrame
 * @author tanlvxu
 *
 */
public class MyJFrame extends JFrame{
    public void jf(){
    	this.setSize(400,400) ;
    	MyButton button = new MyButton(); 
    	ButtonListener bListener = new ButtonListener(button) ;
    	MyConfig.list.add(bListener) ;
    	button.addActionListener(bListener) ;
    	this.add(button) ;
    	this.setVisible(true) ;
    }
    public static void main(String[] args) {   	
		new MyJFrame().jf();
		new ReadMsg();
	}
}
/**
 * 消息处理接口
 * @author tanlvxu
 *
 */
public interface ListenerAdapter{
     public void dealMsg(Message msg) ;
}

/**
 * 自定义按钮监听
 * @author tanlvxu
 *
 */
public class ButtonListener implements ListenerAdapter,ActionListener{
	private Button button = null ;
    public ButtonListener(Button button){
      this.button = button ;
    }
	@Override
	public void actionPerformed(ActionEvent arg0) {
		// TODO Auto-generated method stub
		System.out.println("AMB");	
	}

	@Override
	public void dealMsg(Message msg) {
	  button.setLabel(msg.getContent()) ;
	}
}
/**
 * 自定义Button
 * @author tanlvxu
 *
 */
public class MyButton extends Button {
    private ListenerAdapter lAdapter = null;
	public void setListerAdapter(ListenerAdapter lAdapter){
		this.lAdapter = lAdapter ;
	}
   
}

        

 3.桥接模式(Bridge):引用行者买刀的理解
桥梁模式的宗旨就是将抽象部分与它的实现部分分离，使它们都可以独立的变化
 

这里引用网上的一个蜡笔的例子我觉得很是恰到好处。

“

小时候我们都用蜡笔画画，一盒蜡笔12种颜色。一开始我都是用最小号的蜡笔画个太阳公公、月亮婆婆足够

了。后来开始画一些抽象派的作品，就得换中号的了，要不然画个背景都要描半天，好一盒中号的也是12种颜

色。再后来我开始转向豪放派，中号就有些捉襟见肘了，只好换大号的了，好一盒大号的也只有12种颜色。你

看，像我这样不太出名的画家就需要36种画笔，哇，太麻烦了。但是据我观察，另一些比我出名的画家倒是没

有这么多笔，他们只有几把刷子和一些颜料，这样就解决了蜡笔的“种类爆炸”问题。”

 

 

 
 这样做起来往往会有事半功倍的效果