Posted on 2010-08-10 23:24
java小爬虫 阅读(3244)
评论(1) 编辑 收藏
1：代理模式：
为其它对象提供一种代理以控制对目标对象的访问。即第三方对象通过访问代理对象而达到访问目标对象之目的，与此同时，代理对象在访问目标对象前后加入特定的逻辑以实现功能的扩展。
以静态代理为例：
package static_proxy;
public interface Movable {
public void move();
}
package static_proxy;
import java.util.Random;
public class Tank implements Movable {
@Override
public void move() {
System.out.println(" Tank is moving 
");
try {
Thread.sleep(new Random().nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
package static_proxy;
public class TankLogProxy implements Movable {
private Movable obj;
public TankLogProxy(Movable obj) {
super();
this.obj = obj;
}
@Override
public void move() {
System.out.println("the log is begin ");
obj.move();
System.out.println("the log is end ");
}
}
package static_proxy;
public class TankTimeProxy implements Movable {
private Movable obj;
public TankTimeProxy(Movable obj) {
super();
this.obj = obj;
}
@Override
public void move() {
long begintime = System.currentTimeMillis();
System.out.println(" Tank is begining to move !");
obj.move();
long endtime = System.currentTimeMillis();
System.out.println(" Tank is stop !");
System.out.println("move time : "+(endtime-begintime));
}
}
package static_proxy;
public class Client {
/**
* @param args
*/
public static void main(String[] args) {
Movable tankTime = new TankTimeProxy(new Tank());
Movable tankLog = new TankLogProxy(tankTime);
tankLog.move();
}
}
代理模式：目标对象和代理对象实现同一接口；代理对象访问目标对象时在其前后加入一定的逻辑实现功能扩展；可多次代理。
2.装饰者模式：
动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更加灵活。
package decorator;
public abstract class car_parent {
// 汽车抽象父类
private String make_address;
private int speed;
public String getMake_address() {
return make_address;
}
public void setMake_address(String make_address) {
this.make_address = make_address;
}
public int getSpeed() {
return speed;
}
public void setSpeed(int speed) {
this.speed = speed;
}
public abstract void print_face();
}
package decorator;
public abstract class decorator_parent extends car_parent {
// 装饰者父类
protected car_parent car_parent_ref;
public decorator_parent(car_parent carParentRef) {
super();
car_parent_ref = carParentRef;
}
@Override
public void print_face() {
car_parent_ref.print_face();
}
}
package decorator;
public class decorator_audi_red extends decorator_parent {
public decorator_audi_red(car_parent carParentRef) {
super(carParentRef);
}
@Override
public void print_face() {
super.print_face();
System.out.println("给 奥迪 喷涂鸦 - 颜色为 红色火焰");
}
}
package decorator;
public class decorator_audi_purple extends decorator_parent {
public decorator_audi_purple(car_parent carParentRef) {
super(carParentRef);
}
@Override
public void print_face() {
super.print_face();
System.out.println("给 奥迪 喷涂鸦 - 颜色为 紫色霞光");
}
}
package decorator;
public class main_run {
public static void main(String[] args) {
car_parent audi_sub_ref = new audi_sub();
audi_sub_ref.setMake_address("北京市朝阳区");
audi_sub_ref.setSpeed(200);
decorator_audi_red decorator_audi_red_ref = new decorator_audi_red(audi_sub_ref);
decorator_audi_purple decorator_audi_purple_ref = new decorator_audi_purple(decorator_audi_red_ref);
decorator_audi_purple_ref.print_face();
}
}
装饰者模式：装饰者和被装饰者应继承或实现同一父类或接口，以表示它们为同一类对象（非必须）；装饰者对象对被装饰者对象增加一定的职责；可多次装饰。
可以发现：代理模式和装饰者模式上在语法形式上几乎完全一样，那么它们的区别在哪里呢？
装饰者模式：动态地给一个对象添加一些额外的职责。就增加功能来说，装饰模式相比生成子类更加灵活代理模式：
为其它对象提供一种代理以控制对这个对象的访问。其实，它们的着重点一个在于“增加”职责，另一个在于“控制”访问。这是它们最本质的区别。
由此可以看到：学习设计模式重点在于“语义”上把握，而不是追求它的“形式。