JAVA设计模式《四》

浏览数：23 / 时间：2015年06月08日

　　经过前几篇的介绍相信大家对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();
    }
}