- 代理模式就是多一个代理类出来,替原对象进行一些操作,
比如我们在租房子的时候回去找中介,为什么呢?因为你对该地区房屋的信息掌握的不够全面,希望找
一个更熟悉的人去帮你做,此处的代理就是这个意思。再如我们有的时候打官司,我们需要请律师,因
为律师在法律方面有专长,可以替我们进行操作,表达我们的想法。先来看看关系图
我们废话不多说直接上代码:
public class Source implements Sourceable {
@Override
public void method() {
System.out.println("this is souce method");
}
}
public interface Sourceable {
public void method();
}
public class Porxy implements Sourceable{
private Sourceable source;
public Porxy(Sourceable source) {
super();
this.source = source;
}
@Override
public void method() {
before();
source.method();
after();
}
public void before(){
System.out.println("before porxy");
}
public void after(){
System.out.println("after porxy");
}
}
看上面的代码像不像aop 哈哈.
public class PorxyTest {
public static void main(String[] args) {
Sourceable s = new Source();
Porxy p = new Porxy(s);
p.method();
}
}
before porxy
this is souce method
after porxy
代理模式和装饰模式很像 但是被代理的类并不知道自己已经被代理过了.
被装饰者一定知道自己被装饰过
装饰模式:主要是增强方法
代理模式: 主要是限制方法
观察模式
观察者模式很好理解,类似于邮件订阅和 RSS 订阅,当我们浏览一
些博客或 wiki 时,经常会看到 RSS 图标,就这的意思是,当你订阅了该文章,如果后续有更新,会及
时通知你。其实,简单来讲就一句话:当一个对象变化时,其它依赖该对象的对象都会收到通知,并且
随着变化!对象之间是一种一对多的关系。先来看看关系图:
我解释下这些类的作用:MySubject 类就是我们的主对象,Observer1 和 Observer2 是依赖于 MySubject
的对象,当 MySubject 变化时, Observer1 和 Observer2 必然变化。 AbstractSubject 类中定义着需要
监控的对象列表,可以对其进行修改:增加或删除被监控对象,且当 MySubject 变化时,负责通知在
列表内存在的对象。我们看实现代码:
//一个observer的 接口
public interface Observer {
public void update();
}
//实现类
public class Observer1 implements Observer{
@Override
public void update() {
System.out.println("observer1 has received");
}
}
public class Observer2 implements Observer{
@Override
public void update() {
System.out.println("observer2 has reveived");
}
}
public interface Subject {
/**
* 增加 observer
*/
public void add(Observer server);
/*删除观察者*/
public void del(Observer observer);
/*通知所有的观察者*/
public void notifyObservers();
/*自身的操作*/
public void operation();
}
public abstract class AbstractSubject implements Subject{
//Vector属于线程安全级别的,但是大多数情况下不使用Vector,因为线程安全需要更大的系统开销。
private Vector<Observer> vo = new Vector<Observer>();
@Override
public void add(Observer server) {
vo.add(server);
}
@Override
public void del(Observer observer) {
vo.remove(observer);
}
@Override
public void notifyObservers() {
Enumeration<Observer> elements = vo.elements();
while (elements.hasMoreElements()) {
elements.nextElement().update();
}
}
}
public class MySubject extends AbstractSubject{
@Override
public void operation() {
System.out.println("update self");
notifyObservers();
}
}
测试类:
public class Test {
public static void main(String[] args) {
Subject sub = new MySubject();
sub.add(new Observer1());
sub.add(new Observer2());
sub.operation();
}
}
update self
observer1 has received
observer2 has reveived