观察者模式（Observer Pattern）案例解析

观察者模式（Observer Pattern）

定义：

定义对象间一种一对多的依赖关系，使得当每一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。

类图：

案例描述：

有一个雷达负责扫描目标，一旦发现目标，就会通知攻击序列对目标进行摧毁，攻击序列中的所有武器会向目标发动攻击。

现有的武器可以加入攻击序列，也可以退出攻击序列。

雷达扮演Subject，大炮和导弹扮演Observer，大炮和导弹通过attach加入到雷达的攻击序列，一旦雷达发现目标，启动攻击序列摧毁目标。

案例源码：

/*
 * shsheng
 */
package DesignPatterns;

import java.util.ArrayList;
import java.util.List;

public class ObserverPattern {

    public static void main(String[] args) {
        Radar radar = new Radar();
        Missile missile = new Missile(1);
        Cannon cannon = new Cannon(1);

        radar.attach(missile);
        radar.attach(cannon);
        radar.find(new Fighter(1));

        radar.detach(cannon);
        radar.find(new Fighter(2));
    }

    static class Fighter {
        int num;

        public Fighter(int num) {
            this.num = num;
        }

        @Override
        public String toString() {
            return "战斗机" + num;
        }
    }

    static class Radar {
        List
   
   
    
     attacks = new ArrayList
    
    
     
     ();

        public void attach(Attack attack) {
            System.out.println(attack + "加入攻击序列！");
            attacks.add(attack);
        }

        public void detach(Attack attack) {
            System.out.println(attack + "退出攻击序列！");
            if (attacks.contains(attack)) {
                attacks.remove(attack);
            }
        }

        public void find(Object obj) {
            System.out.println("雷达发现" + obj + "，通知攻击！");
            for (Attack attack : attacks) {
                attack.attack(obj);
            }
        }
    }

    static interface Attack {
        public void attack(Object obj);
    }

    static class Missile implements Attack {
        int num;

        public Missile(int num) {
            this.num = num;
        }

        @Override
        public void attack(Object obj) {
            System.out.println("导弹锁定" + obj + "，准备发射！");
        }

        @Override
        public String toString() {
            return "导弹" + num;
        }
    }

    static class Cannon implements Attack {
        int num;

        public Cannon(int num) {
            this.num = num;
        }

        @Override
        public void attack(Object obj) {
            System.out.println("大炮瞄准" + obj + "，准备开炮！");
        }

        @Override
        public String toString() {
            return "大炮" + num;
        }
    }

}

    
    
   
   

运行结果：

导弹1加入攻击序列！
大炮1加入攻击序列！
雷达发现战斗机1，通知攻击！
导弹锁定战斗机1，准备发射！
大炮瞄准战斗机1，准备开炮！
大炮1退出攻击序列！
雷达发现战斗机2，通知攻击！
导弹锁定战斗机2，准备发射！