首页 / 设计模式 / JAVA设计模式《四》
JAVA设计模式《四》
内容导读
互联网集市收集整理的这篇技术教程文章主要介绍了JAVA设计模式《四》，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含5533字，纯文字阅读大概需要8分钟。
内容图文
经过前几篇的介绍相信大家对JAVA的设计模式一定有所解了，本篇我们再一起学习一下适配器模式、代理模式和工厂模式。
适配器模式使用的场景非常多，例如现实生活中，我们的笔记本电脑的充电线大部分都是三向插头，而当我们遇见一个二向插口时，如何给我们的笔记本充电呢？这时我们就需要一个适配器，帮我们把二向插口转化为三向插口。接下来我们需要讨论的适配器模式，就是如同这里的二向转三向插口，下面我们就以这个现实问题，来用代码实现一下适配器模式。
1、创建三向电流接口：
/*
* 定义一个三相充电器接口
*/
public
interface
ThreePathIm {
//
使用三相电流供电
public
void
powerWithThree();
}
2、创建三向电流类：
public
class ThreePath implements ThreePathIm {
publicvoid 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;
}
publicvoid powerWithThree() {
System.out.println("通过适配器转化");
two.prowerWithTwo();
}
}
5、创建继承二向电流类并实现了三向电流接口的类（继承适配器）：
/*
* 继承适配器
*/
public
class extendsAdapt extends TwoPath implements ThreePathIm {
publicvoid powerWithThree() {
System.out.println("\n使用继承适配器转化");
this.prowerWithTwo();
}
}
6、创建测试类：
public
class
noteBook {
private
ThreePathIm path ;
private
noteBook(ThreePathIm path){
this.path = path;
}
privatevoid change(){
path.powerWithThree();
}
publicstaticvoid 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 {
//左偏分publicvoid getHair() {
System.out.println("我的头发是左偏分");
}
}
b、右偏分：
public
class rightHair implements Hair {
//右偏分publicvoid getHair() {
System.out.println("我的头发是右偏分");
}
}
3、创建头发工厂：
public
class
hairFactory {
Hair hair;
//
通过关键词来获得相应的头发类型类
public
Hair getHairKey(String key){
if("left".equals(key)){
hair = new leftHair();
}elseif("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 {
publicvoid 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 {
publicvoid 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;
publicvoid 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;
publicvoid 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)+"毫秒");
returnnull;
}
}
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中的设计模式已经为大家分析完毕，当然这些都是很基本的东西，想真正的在开发中使用，还需要多多练习。如有疑问，可以留言讨论。
原文：http://www.cnblogs.com/AndroidJotting/p/4362328.html
内容总结
以上是互联网集市为您收集整理的JAVA设计模式《四》全部内容，希望文章能够帮你解决JAVA设计模式《四》所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。
内容备注
版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。
内容手机端
扫描二维码推送至手机访问。