面試題：貓叫、老鼠跑、人醒的一點看法

這些天一直在面試中，做着不同的面試題，唉，悲催

上周做的一道面試題今天正好出現在園里的首頁，看了一下這位同學的實現，基本上方向是對的，就是代碼上細節沒有注意，有一些錯誤，這里我就寫一下我的理解

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

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）尤其是調用代碼部分，感覺很別扭