[Toc]

概述参考请看 参考博客

观察者模式：其定义了对象之间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖它的对象都会得到通知，并响应对应的行为。

1、观察者模式原型

观察者模式原型UML

观察者模式原型代码

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class ObserverMode : MonoBehaviour
{
    private void Start () {

        ConcreteSubjectA subjectA = new ConcreteSubjectA();

        IObserver observerA = new ConcreteObserverA(subjectA);
        IObserver observerB = new ConcreteObserverB(subjectA);
        subjectA.AddObserber(observerA);
        subjectA.AddObserber(observerB);

        //改变subjectA的状态
        subjectA.State = "状态A";
	}
}

/// <summary>
/// 被观察者抽象类
/// </summary>
public abstract class ISubject
{
    /// <summary>
    /// 所有观察这个被观察者的   观察者集合
    /// </summary>
    protected List<IObserver> mObserverList;

    public ISubject()
    {
        mObserverList = new List<IObserver>();
    }

    /// <summary>
    /// 添加观察者
    /// </summary>
    public void AddObserber(IObserver observer)
    {
        if (mObserverList.Contains(observer) == false && observer != null)
        {
            mObserverList.Add(observer);
            return;
        }
        Debug.Log("报错");
    }
    /// <summary>
    /// 移除观察者
    /// </summary>
    public void RemoveObserber(IObserver observer)
    {
        if (mObserverList.Contains(observer))
        {
            mObserverList.Remove(observer);
            return;
        }
        Debug.Log("报错");
    }
    /// <summary>
    /// 通知所有观察者更新
    /// </summary>
    public void NotifyObserver()
    {
        foreach (IObserver item in mObserverList)
        {
            item.Update();
        }
    }
}
public class ConcreteSubjectA:ISubject
{
    private string mState;
    public string State
    {
        get { return mState; }
        set {
            mState = value;
            NotifyObserver();
        }
    }
}

/// <summary>
/// 观察者抽象类
/// </summary>
public abstract class IObserver
{
    public abstract void Update();
}
public class ConcreteObserverA : IObserver
{
    private ConcreteSubjectA mSubject;

    public ConcreteObserverA(ConcreteSubjectA subject)
    {
        mSubject = subject;
    }

    public override void Update()
    {
        Debug.Log("ConcreteObserverA显示更新：" + mSubject.State);
    }
}
public class ConcreteObserverB : IObserver
{
    private ConcreteSubjectA mSubject;

    public ConcreteObserverB(ConcreteSubjectA subject)
    {
        mSubject = subject;
    }

    public override void Update()
    {
        Debug.Log("ConcreteObserverB显示更新：" + mSubject.State);
    }
}

2、观察者模式实例

游戏应用：成就系统。 例如成就要要检测敌人死亡个数。 被观察者就是敌人死亡，观察者就是成就系统。当敌人死亡个数大过一定值时，会触发成就系统中的成就。

3、观察者模式优缺点

优点

1. 降低耦合度。
2. 满足开闭原则。

缺点

1. 类个数较多。