hello world! 大家好!
说到观察者模式,什么是观察者模式?一种一对多的依赖关系,让多个观察者对象同时监听某一主题对象,在它的状态发生变化时,会通知所有的观察者.
那观察者模式的优点优势是什麽??观察者与被观察者之间是属于轻度的关联关系,并且是抽象耦合的,这样,对于两者来说都比较容易进行扩展。
观察者模式是一种常用的触发机制,它形成一条触发链,依次对各个观察者的方法进行处理。
然后,我就讲一下我的观察者模式实现:
首先是这样一个故事,一个偷鸡贼(哦,不!不能这么称呼人家)正在偷别人家的鸡或者狗。这时候正是被警察A和警察B看到,并在最后的角逐中小偷不行被逮!
其中,小偷(被观察者)、警察AB(观察者);当小偷(被观察者)做出某些侮辱妇女行为,错了,是偷!~的行为,触发了警察AB(观察者)的底线并对小偷进行红色全球通缉。
接口 小偷(被观察者):
public interface IThief {
//注册观察者(类似注册监听)
void registerPolice(IPolice police);
//移去观察者(类似移走监听)
void removePolice(WeakReference<IPolice> police);
//notify通知报警方法
void notifyPolice();
//偷鸡
void stealChicken();
//摸狗
void stealDog();
}
实现类 小偷(被观察者):
public class DogThief implements IThief{
public List<WeakReference<IPolice>> polices = new ArrayList<>();
@Override
public void registerPolice(IPolice police) {
//第一步:必须先要进行监听的注册
polices.add(new WeakReference<IPolice>(police));
}
@Override
public void removePolice(WeakReference<IPolice> police) {
int index = polices.indexOf(police);
if(index >= 0){
polices.remove(index);
}
}
@Override
public void notifyPolice() {
for (int i = 0; i < polices.size(); i++){
WeakReference<IPolice> weakPolice = polices.get(i);
IPolice police = weakPolice.get();
police.runAfterThief();//警察听到警报,追赶小偷
}
}
@Override
public void stealChicken() {
System.out.println("警报:有小偷偷鸡了!!!");
notifyPolice();
}
@Override
public void stealDog() {
System.out.println("警报:有小偷,摸狗了!!!");
notifyPolice();
}
}
接口 警察(观察者):
//接口 警察
public interface IPolice {
//追赶小偷
void runAfterThief();
//擒住小偷
void catchThief();
}
对于小偷的行为进行处理的接口类:
public interface IJudgement {
//对小偷的罪行进行判决
void deadBShoot();//枪毙
}
public interface ILower {
//作为律师对偷鸡摸狗贼 辩护
void lowerPlead();
}
实现类 警察A(观察者):
public class PoliceA implements IPolice, IJudgement {
@Override
public void runAfterThief() {
System.out.println("呼哧呼哧。。。追赶小偷!!");
catchThief();
}
@Override
public void catchThief() {
System.out.println("尼玛。。。逮着你了吧?!!");
deadBShoot();//判决,拉出去枪毙
}
@Override
public void deadBShoot() {
//警察对该贼进行监视,最终对小偷的偷窃行为做出来自己的合理操作A
System.out.println("哦!死了。。。");
}
}
实现类 警察B(观察者):
public class PoliceB implements IPolice, ILower{
@Override
public void lowerPlead() {
//警察B对该贼进行监视,最终对小偷的偷窃行为做出来自己的合理操作
System.out.println("我家猫贼,没偷鸡!!");
}
@Override
public void runAfterThief() {
System.out.println("呼哧呼哧。。。追赶小偷!!");
catchThief();
}
@Override
public void catchThief() {
System.out.println("尼玛。。。逮着你了吧?!!");
lowerPlead();
}
}
小贼偷鸡摸狗,被警察发现并逮捕。然后俩警察分别对小贼做了相关处理!
public class MainText {
public static void main(String[] args){
PoliceA policeA = new PoliceA();
PoliceB policeB = new PoliceB();
DogThief dogThief = new DogThief();
dogThief.registerPolice(policeA);
dogThief.registerPolice(policeB);
dogThief.stealChicken();//偷鸡
dogThief.stealDog();//摸狗
}
}
还有一种写法是使用java自带的接口和抽象类:抽象类(被观察者:Observable)、观察者(接口:Observer)
public class MainText {
public static void main(String[] args){
PoliceA policeA = new PoliceA();
PoliceB policeB = new PoliceB();
DogThief dogThief = new DogThief();
dogThief.register(policeA);//注册A
dogThief.register(policeB);//注册B
dogThief.stealChickerDogs();// 开始偷鸡摸狗,触发警察AB的行为
}
}
//被观察者(贼)
public class DogThief extends Observable {
public void register(Observer observer){
this.addObserver(observer);
}
public void stealChickerDogs(){
System.out.println("偷鸡摸狗");
this.notifyObservers();
}
}
//观察者(警察A)
public class PoliceA implements Observer {
@Override
public void update(Observable o, Object arg) {
System.out.println("直接追上去逮住小偷");
}
}
//观察者(警察B)
public class PoliceB implements Observer {
@Override
public void update(Observable o, Object arg) {
System.out.println("打电话请求支援!");
}
}
先将 Observer 注册到 Observable ,那么当 Observable 状态改变时会通知它持有的所有 Observer ,对了,最好 Observable 中的 mList 的泛型是 WeakReference ,防止内存泄漏;看图再理解一下: