JAVA设计模式《四》

经过前几篇的介绍相信大家对 JAVA 的设计模式一定有所解了，本篇我们再一起学习一下适配器模式、代理模式和工厂模式。

适配器模式使用的场景非常多，例如现实生活中，我们的笔记本电脑的充电线大部分都是三向插头，而当我们遇见一个二向插口时，如何给我们的笔记本充电呢？这时我们就需要一个适配器，帮我们把二向插口转化为三向插口。接下来我们需要讨论的适配器模式，就是如同这里的二向转三向插口，下面我们就以这个现实问题，来用代码实现一下适配器模式。

1、创建三向电流接口：

/*  * 定义一个三相充电器接口  */ public interface ThreePathIm {  //使用三相电流供电  public void powerWithThree(); } 

2、创建三向电流类：

public class ThreePath implements ThreePathIm {      public void powerWithThree() {         System.out.println("使用三向电流供电/n");     }  }

3、创建二向电流类：

/*  * 二相电流类  */ public class TwoPath {  public void prowerWithTwo(){   System.out.println("使用二相电流供电");  } } 

4、创建二向接口转三向接口类（接口适配器）：

/*  * 电源接口适配器  * 二向接口适配三口接口  */ public class TwoPlugAdapt implements ThreePathIm {  private TwoPath two ;  public TwoPlugAdapt(TwoPath two){   this.two = two;  }  public void powerWithThree() {   System.out.println("通过适配器转化");   two.prowerWithTwo();  } } 

5、创建继承二向电流类并实现了三向电流接口的类（继承适配器）：

/*  * 继承适配器  */ public class extendsAdapt extends TwoPath implements ThreePathIm {  public void powerWithThree() {   System.out.println("/n使用继承适配器转化");   this.prowerWithTwo();  } } 

6、创建测试类：

public class noteBook {  private ThreePathIm path ;  private noteBook(ThreePathIm path){   this.path = path;  }  private void change(){   path.powerWithThree();  }  public static void main(String [] args){   ThreePathIm tpi = new ThreePath();   tpi.powerWithThree();   TwoPath two = new TwoPath();//获得二相接口对象   ThreePathIm three = new TwoPlugAdapt(two);//把二相电流接口转为三向   noteBook notebook = new noteBook(three);   notebook.change();   three = new extendsAdapt();   notebook = new noteBook(three);   notebook.change();  } } 

public interface Hair {      public void getHair();//获得发型方法      }

2、通过该方法实现两个头发类型：

a 、左偏分：

public class leftHair implements Hair {      //左偏分     public void getHair() {         System.out.println("我的头发是左偏分");     }  }

b 、右偏分：

public class rightHair implements Hair {      //右偏分     public void getHair() {         System.out.println("我的头发是右偏分");     }  }

3、创建头发工厂：

public class hairFactory {  Hair hair;  //通过关键词来获得相应的头发类型类  public Hair getHairKey(String key){   if("left".equals(key)){    hair = new leftHair();   }else if("right".equals(key)){    hair = new rightHair();   }   return hair;  }  //通过类地址来获得相应的头发类型类  public Hair getHairClass(String cls){   try {    hair = (Hair)Class.forName(cls).newInstance();   } catch (InstantiationException e) {    // TODO Auto-generated catch block    e.printStackTrace();   } catch (IllegalAccessException e) {    // TODO Auto-generated catch block    e.printStackTrace();   } catch (ClassNotFoundException e) {    // TODO Auto-generated catch block    e.printStackTrace();   }   return hair;  } } 

4、创建测试类：

public class hairTest {  /**   * 测试类   * @param args   */  public static void main(String[] args) {   Hair hair1 = new leftHair();   Hair hair2 = new rightHair();   hair1.getHair();   hair2.getHair();   //通过工厂对象进行创建类   hairFactory factory = new hairFactory();   Hair hair3 = factory.getHairKey("left");   hair3.getHair();   Hair hair4 = factory.getHairClass("cn.edu.hpu.hair.rightHair");   hair4.getHair();  } } 

代理模式是对一个对象提供一种代理，用来控制对这个对象的控制。

下面我们通过实现一个汽车行驶时，记录行车时间和日志的功能，不多说，上代码：

1、封装一个汽车行驶的方法：

public interface MoveAble {     public void move(); }

2、创建一个汽车类：

public class Car implements MoveAble {  public void move(){   try { //   System.out.println("汽车开始行驶"); //   long start = System.currentTimeMillis();        System.out.println("汽车在行驶中");    Thread.sleep(new Random().nextInt(1000));//模拟汽车行驶 //   long end = System.currentTimeMillis(); //   System.out.println("汽车停止行驶  汽车行驶了："+(end-start)+"毫秒");   } catch (InterruptedException e) {    e.printStackTrace();   }  } } 

3、实现一个汽车子类：

通过继承方法，创建不同子类来实现行驶时间和日志的记录。

public class Car2 extends Car {  public void move() {   System.out.println("汽车开始行驶");   long start = System.currentTimeMillis();   super.move();//执行父类的方法   long end = System.currentTimeMillis();   System.out.println("汽车停止行驶  汽车行驶了："+(end-start)+"毫秒");  } } 

4、创建接口代理：

a、时间代理对象：

public class CarTimeProxy implements MoveAble {  public CarTimeProxy(MoveAble m){   this.m = m;  }  public MoveAble m;  public void move() {   System.out.println("汽车开始行驶");   long start = System.currentTimeMillis();   m.move();   long end = System.currentTimeMillis();   System.out.println("汽车停止行驶  汽车行驶了："+(end-start)+"毫秒");  } } 

b、日志代理对象：

public class CarLogProxy implements MoveAble {  public CarLogProxy(MoveAble m) {   super();   this.m = m;  }  public MoveAble m;  public void move() {   System.out.println("日志开始");   m.move();   System.out.println("日志结束");  } }
 

5、测试类：

public class carTest {     /**      * @param 测试      */     public static void main(String[] args) { // Car car = new Car(); // car.move();  //继承模式的静态代理 // Car car = new Car2(); // car.move();  //接口模式的静态代理，叠加操作  Car car = new Car();  MoveAble m1 = new CarTimeProxy(car);  MoveAble m2 = new CarLogProxy(m1);  m2.move();     } } 

6、通过JDK实现代理：

public class TimeHander implements InvocationHandler {     public TimeHander(Object object) {  super();  this.object = object;     }     Object object;     /*      * 参数：      * proxy:被代理的对象      * method:被代理对象的方法      * args:方法的参数      */     public Object invoke(Object proxy, Method method, Object[] args)      throws Throwable {  System.out.println("汽车开始行驶");  long start = System.currentTimeMillis();  method.invoke(object, null);  long end = System.currentTimeMillis();  System.out.println("汽车停止行驶  汽车行驶了："+(end-start)+"毫秒");  return null;     } } 

7、JDK代理测试：

//jdk动态代理 public class Test {  public static void main(String [] args){   Car car = new Car();   InvocationHandler hander = new TimeHander(car);   Class cls = car.getClass();   MoveAble m = (MoveAble) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), hander);   m.move();  }
} 

截止到本篇关于JAVA中的设计模式已经为大家分析完毕，当然这些都是很基本的东西，想真正的在开发中使用，还需要多多练习。如有疑问，可以留言讨论。