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