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();
    }

}

  工程模式使用的场景也比较多,比如之前很火的一款名为脸萌的图片制作软件,我们可以根据我们的需要来选择头发的类型,这是如何实现的呢?下面我们来一起学习一下。
 1、创建头发类型接口:

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中的设计模式已经为大家分析完毕,当然这些都是很基本的东西,想真正的在开发中使用,还需要多多练习。如有疑问,可以留言讨论。

posted @ 2015-03-24 11:49  小破孩123  阅读(683)  评论(0编辑  收藏  举报