面试题：猫叫、老鼠跑、人醒的一点看法

这些天一直在面试中，做着不同的面试题，唉，悲催

上周做的一道面试题今天正好出现在园里的首页，看了一下这位同学的实现，基本上方向是对的，就是代码上细节没有注意，有一些错误，这里我就写一下我的理解

---------------------------

C#面试题：

猫大叫一声，所有的老鼠都开始逃跑，主人被惊醒。

要求：

1、要有联动性，老鼠和人的行为是被动的

2、考虑可扩展行，猫叫声可能会引起其他联动效应

 -------------

步骤1：先提取出对象，猫、老鼠、人（Cat,Mouse,Person）

步骤2：再提取对象的动作，猫叫、老鼠跑、人醒（Cat.Call,Mouse.Run,Person.Wake）

步骤3：关联关系，

这里有两种理解

1）  猫叫->老鼠跑

猫叫->人醒

2）  猫叫->老鼠跑->人醒(多级联动)

步骤4：很明显，对应c#这里可以直接使用委托链和事件实现

另外可以使用设计模式中的观察者模式

------------------------------------------

以下分别给出对应代码：

观察者模式：这里的老鼠有两种实现方式，对应步骤3中的关联关系

声明接口

//观察者
public interface IObserver
{
     void Update(ISubject sub);
}

//被观察者
public interface ISubject
{
     void Notify();
     void AddObserver(IObserver o);
     void RemoveObserver(IObserver o);
}

//猫
public class Cat:ISubject
{
    //缓存自己的观察者
    private System.Collections.Generic.List<IObserver> _list;
    public Cat()
    {
        _list=new System.Collections.Generic.List<IObserver>();
        
    }
    //通知所有自己得观察者
    public void Notify()
    {
        foreach(IObserver o in  _list)
        {
            o.Update(this);
        }
    }
    public void AddObserver(IObserver o)
    {
        _list.Add(o);
    }
    public void RemoveObserver(IObserver o)
    {
        _list.Remove(o);
    }
    //猫叫的时候通知观察者
    public void Call()
    {
        System.Console.WriteLine("Cat Call");
        Notify();
    }
}

//这里对应步骤3中关联关系的第一种理解
//猫叫->老鼠跑
//猫叫->人醒

public class Mouse:IObserver
{
    public void Update(ISubject sub) 
    {
        Run();
    }
    public void Run()
    {
        System.Console.WriteLine("Mouse Run");
    }
}

//这里对应步骤3中关联关系的第二种理解
//猫叫->老鼠跑->人醒
//这里老鼠是猫的观察者,同时被人观察,所以两个接口都实现
public class MouseA:IObserver,ISubject
{
    //实现观察者接口
    public void Update(ISubject sub) 
    {
        //注意，这里当猫通知老鼠后，老鼠要接着改变自己得状态，并通知自己得观察者
        Run();    
        
    }
    public void Run()
    {
        System.Console.WriteLine("MouseA Run");
        //这里老鼠的跑动通知观察者
        Notify();
    }
    
    #region//实现被观察者接口
    private System.Collections.Generic.List<IObserver> _list;
    public MouseA()
    {
        _list=new System.Collections.Generic.List<IObserver>();        
    }
    
    public void Notify()
    {
        foreach(IObserver o in  _list)
        {
            o.Update(this);
        }
    }
    public void AddObserver(IObserver o)
    {
        _list.Add(o);
    }
    public void RemoveObserver(IObserver o)
    {
        _list.Remove(o);
    }
    #endregion 
}

 

//人
public class Person:IObserver{

    public void Update(ISubject sub)
    {
        Wake();
    }
    public void Wake()
    {
        System.Console.WriteLine("People Wake");
    }
}

调用方法：

对应第一种：猫同时有两个观察者，或更多个，只需要调用AddObserver加入就行了

    public static void Main()
    {
        //被观察者
        ISubject c=new Cat();
        //观察者
        IObserver m=new Mouse();
        IObserver p=new Person();
        //加入观察者
        c.AddObserver(m);
        c.AddObserver(p);
        //被观察者状态改变
        ((Cat)c).Call();
    }

对应第二种，猫有老鼠一个观察者，老鼠也有人一个观察者，多级联动关系

public static void Main()
    {
        //被观察者
        ISubject c=new Cat();
        //既是观察者，也是被观察者
        IObserver m=new MouseA();    
        //加入观察者
        c.AddObserver(m);    
        
        //观察者
        IObserver p=new Person();
        //加入观察者    
        ((ISubject)m).AddObserver(p);
        //被观察者状态改变
        ((Cat)c).Call();
    }

 

设计模式的使用最大的好处是，解耦合，

这位同学的观察者模式用的是没有错误的，但是代码中有问题，主要是Mouse和Peolple的构造函数中的参数，直接使用了Cat这个对象，这样就使得Mouse、Peolple与Cat绑死在一起，这里的Cat应该换成接口Subject

 -----------------------------以下使用事件和委托实现相同的功能，分为三种实现，第一种是单纯的类，并未解耦合，第二种使用接口解耦合，第三种使用抽象类

public delegate void NotifyEventHandler(object sender,EventArgs e);

public class TCat
{
    public event NotifyEventHandler OnNotify;
    public void DoOnNotify(EventArgs e)
    {
        if (OnNotify!=null)
            OnNotify(this,e);
    }
    
    public void Call()
    {
        System.Console.WriteLine("TCat Call");
        EventArgs e=new EventArgs();
        DoOnNotify(e);
    }
}

public class TMouse
{
    private TCat _Cat;
    public TMouse(TCat c)
    {
        _Cat=c;
        c.OnNotify+=new NotifyEventHandler(OnMouseRun);
    }
    void OnMouseRun(object sender,EventArgs e)
    {        
        Run();
    }
    
    public void Run()
    {
        System.Console.WriteLine("TMouse Run");
    }
}

public class TPeople
{
    private TCat _Cat;
    public TPeople(TCat c)
    {
        _Cat=c;
        c.OnNotify+=new NotifyEventHandler(OnPeopleWake);
    }
    void OnPeopleWake(object sender,EventArgs e)
    {
        Wake();
    }    
    public void Wake()
    {
        System.Console.WriteLine("TPeople Wake");
    }
}

使用方法：

public static void Main3()
{
    TCat c=new TCat();        
    TMouse m=new TMouse(c);
    TPeople p=new TPeople(c);
    c.Call();
}

 

事件的第二种实现：

public interface INofify
{
    event NotifyEventHandler OnNotify;
}

public delegate void NotifyEventHandler(object sender,EventArgs e);

public class CCat:INofify
{
    public event NotifyEventHandler OnNotify;
    public void DoOnNotify(EventArgs e)
    {
        if (OnNotify!=null)
            OnNotify(this,e);
    }
    
    public void Call()
    {
        System.Console.WriteLine("CCat Call");
        EventArgs e=new EventArgs();
        DoOnNotify(e);
    }
}

public class CMouse:INofify
{
    private INofify _Cat;
    public CMouse(INofify c)
    {
        _Cat=c;
        c.OnNotify+=new NotifyEventHandler(OnMouseRun);
    }
    void OnMouseRun(object sender,EventArgs e)
    {        
        Run();
    }
    
    public void Run()
    {
        System.Console.WriteLine("CMouse Run");
        EventArgs e=new EventArgs();
        DoOnNotify(e);
    }
    
    public event NotifyEventHandler OnNotify;
    public void DoOnNotify(EventArgs e)
    {
        if (OnNotify!=null)
            OnNotify(this,e);
    }    
}

public class CPeople
{
    private INofify _Cat;
    public CPeople(INofify c)
    {
        _Cat=c;
        c.OnNotify+=new NotifyEventHandler(OnPeopleWake);
    }
    void OnPeopleWake(object sender,EventArgs e)
    {
        Wake();
    }    
    public void Wake()
    {
        System.Console.WriteLine("CPeople Wake");
    }
}

使用方法：

public static void Main()
{
    INofify c=new CCat();        
    INofify m=new CMouse(c);
    CPeople p=new CPeople(m);//注意，这里的Peolple并未实现INotify接口，如果需要实现步骤3中的更多级级联，请实现这个接口
    ((CCat)c).Call();
}

 

 事件的第三种实现：

////Notify
public abstract class Notify
{
    public event NotifyEventHandler OnNotify;
    public void DoOnNotify(EventArgs e)
    {
        if (OnNotify!=null)
            OnNotify(this,e);
    }
    //这里是缓存被观察者
    protected  Notify _subject;
    
    public Notify(Notify c)
    {
        if (c!=null)
        {
            _subject=c;
            _subject.OnNotify+=new NotifyEventHandler(Do);
        }
    }
    public abstract void Do(object sender,EventArgs e);
    
}

public class ACat:Notify
{//注意，这里由于继承于抽象类，所以必须要由一个Do函数的实现，函数体为空就可以了，要么就把抽象类的抽象函数改成virtual的
    public ACat(Notify c):base(c)
    {
    }
    public void Call()
    {
        System.Console.WriteLine("ACat Call");
        EventArgs e=new EventArgs();
        DoOnNotify(e);
    }
}

public class AMouse:Notify
{
    public AMouse(Notify c):base(c)
    {
    }
    public override void Do(object sender,EventArgs e)
    {
        Run();
    }
    public void Run()
    {
        System.Console.WriteLine("AMouse Run");
        EventArgs e=new EventArgs();
        DoOnNotify(e);
    }
}

public class APeople:Notify
{
    public APeople(Notify c):base(c)
    {
    }
    public override void Do(object sender,EventArgs e)
    {
        Wake();
    }
    public void Wake()
    {
        System.Console.WriteLine("APeople Wake");
    }    
    
}

使用方法:

    public static void Main()
    {
        //不需要被观察者
        Notify cat=new ACat(null);    
        //观察猫
        Notify mouse=new AMouse(cat);
        //观察老鼠
        Notify people=new APeople(mouse);
        ((ACat)cat).Call();
    }

以上各种代码，区别在于使用模式和事件，或者是接口和抽象类，或者是扩展性的区别，另外使用的时候都是非常简单的，几行代码而已。

还有这位同学的实现，从结果上是正确的，但是缺点也很明显

1）各个类之间毫无结构性的关联，没有充分利用面向对象的一些特性，扩展性很差

2）尤其是调用代码部分，感觉很别扭