求高手解决

Question

运用面向对象思想实现如下机制：
猫叫了，老鼠跑了，主人惊醒了
要求：运用OOP思想，要实现联动性
提示：运用观察者模式或者委托和事件本人不理解这什么意思，求高手能把这个案例写下！加点注视谢谢

Answer 1

委托方式 public delegate void 叫();

public class 猫
{
public event 叫 当猫叫;

public void 叫()
{
当猫叫();
}
}

public class 主人
{
public void 惊了()
{
//吓醒....
}
}

public class 老鼠
{
public void 逃跑()
{
//逃跑....
}
}

                //调用代码
void 调用()
{
猫 cat = new 猫();
主人 master = new 主人();
老鼠 mouse = new 老鼠();
cat.当猫叫 += new 叫(master.惊了);
cat.当猫叫 += new 叫(mouse.逃跑);

cat.叫();
}

Answer 2

观察者模式 java下只能用这个 public class 猫
{
private List<猫叫> list = new List<猫叫>();

public void AddObserver(I猫叫 obj)
{
list.Add(obj);
}

public void 叫()
{
foreach(I猫叫 observer in list)
{
observer.当猫叫();
}
}
}

public class 主人 : I猫叫
{
public void 惊了()
{
//惊醒...
}

#region I猫叫 成员 public void 当猫叫()
{
this.惊了();
} #endregion
} public class 老鼠 : I猫叫
{
public void 逃跑()
{
//逃跑....
} #region I猫叫 成员 public void 当猫叫()
{
this.逃跑();
} #endregion
}

public interface I猫叫
{
void 当猫叫();
}

void 调用()
{
猫 cat = new 猫();
cat.AddObserver(new 主人());
cat.AddObserver(new 老鼠());
cat.叫();
}

Answer 3

上面 猫 类有点错 public class 猫
{
private List<I猫叫> list = new List<I猫叫>();

public void AddObserver(I猫叫 obj)
{
list.Add(obj);
}

public void 叫()
{
foreach(I猫叫 observer in list)
{
observer.当猫叫();
}
}
}

Answer 4

想了想 委托模式的 delegate 名称叫 听到猫叫的反应 更恰当
调整一下 委托方式 public delegate void 听到猫叫的反应(); public class 猫
{
public event 听到猫叫的反应 当猫叫; public void 叫()
{
当猫叫();
}
} public class 主人
{
public void 惊了()
{
//吓醒....
}
} public class 老鼠
{
public void 逃跑()
{
//逃跑....
}
} //调用代码
void 调用()
{
猫 cat = new 猫();
主人 master = new 主人();
老鼠 mouse = new 老鼠();
cat.当猫叫 += new 听到猫叫的反应(master.惊了);
cat.当猫叫 += new 听到猫叫的反应(mouse.逃跑); cat.叫();
}

Answer 5

C# code  
      public delegate void 听到猫叫的反应();        public class 猫
        {
            public event 听到猫叫的反应 当猫叫;            public void 叫()
            {
                当猫叫();
            }
        }        public class 主人
        {
            public void 惊了()
            {
                //吓醒....
            }
        }        public class 老鼠
        {
            public void 逃跑()
            {
                //逃跑....
            }
        }        //调用代码
        void 调用()
        {
            猫 cat = new 猫();
            主人 master = new 主人();
            老鼠 mouse = new 老鼠();
            cat.当猫叫 += new 听到猫叫的反应(master.惊了);
            cat.当猫叫 += new 听到猫叫的反应(mouse.逃跑);            cat.叫();
        }

Answer 6

基本上，这个题目认为世界上就是这三个东西，没有其它。不然为什么不交代一下场景呢？可见它就是假设没有场景。所以可以使用static变量来描述它们。static 猫 obj1 = new 猫();
static 老鼠 obj2 = new 老鼠();
static 女仆 obj3 = new 女仆 { name = "小苍" };static void Main(string[] args)
{
    obj1.叫了 += new Action(obj1_叫了);
    obj1.叫();
    Console.ReadKey();
}static void obj1_叫了()
{
    obj2.跑();
    obj3.醒();
}public class 猫
{
    public event Action 叫了;    public void 叫()
    {
        Console.WriteLine("猫叫了");
        if (this.叫了 != null)
            this.叫了();
    }
}public class 老鼠
{
    public void 跑()
    {
        Console.WriteLine("老鼠跑了");
    }
}public class 女仆
{
    public string name;    public void 醒()
    {
        Console.WriteLine("{0}醒了", this.name);
    }
}

Answer 7

只有你定义猫类的事件时并不依赖于其它实体对象的类型，你才懂得了面向对象设计基本原则中的有关扩展性的要求。你可以看到不管你是使用Action，还是在猫类中为事件专门定义一个委托类型，关键是它的定义都在猫类之前实现了。假设（像某些代码所显示的）你在猫类中搞什么输入老鼠对象来把调用它的“跑”方法，这就是纠结了，你就没有得到分层设计、事后扩展的基本技术知识。

Answer 8

哦 您这里是吧猫叫的行为绑定了一个方法。 您这里面用的是策略模式。
当猫叫了，我执行预定的行为。 "obj1_叫了" 
这个行为里面同时"绑死"了2个行为。obj2.跑(); 和 obj3.醒();这样做犯了2个错:
1. 将obj2.跑(); 和 obj3.醒();绑定在一起，完全耦合了。
2. 在不正确的地方使用策略模式，属于过渡设计。您把猫叫 通过委托绑定到 1对1的 "obj1_叫了" 这个行为上，在这个场景下是属于过度设计的。当然猫确实可能又除了"叫"之外的其他行为，但这个题目中没有要求。只是要求猫叫了和不同的实体可能产生的反应。
所以我认为这里使用策略模式是不正确的。因为作为发起事件的主体猫有且仅有一个行为。而这个题目的重点是如何将另外2个实体的行为与猫叫挂上关系而已。
我不说我的伪代码绝对好，但从思想上是完全符合题目的要求的。题目需求是使用委托和观察者。 
其实这2种模式只有一个共通点，就是适合作为事件的实现方式。委托是.net平台下的事件实现方式，而观察者是java平台下的事件实现方式。

Answer 9

声音和世界
public class VisualWorld 
    {
        public delegate void VoiceTrans();
        public  VoiceTrans VoiceTransing { get; set; }
        public List<VisualAnimal> Animals { get; set; }
        private  Voice transingVoice = new Voice();
        public  Voice TransingVoice 
        {
            get { return transingVoice; }
            set 
            {
                    transingVoice = value;
                    VoiceTransing();
            }
        }
        public VisualWorld() 
        {
            this.Animals = new List<VisualAnimal>();
            this.Animals.Add(new Cat());
            this.Animals.Add(new Mouse());
            this.Animals.Add(new Master());
        }        public VisualWorld(int catNumber, int mouseNumber,int masterNumber) 
        {
            this.Animals = new List<VisualAnimal>();
            for (int i = 0; i < catNumber; i++) 
            {
                this.Animals.Add(new Cat());
            }
            for (int i = 0; i < mouseNumber; i++) 
            {
                this.Animals.Add(new Mouse());
            }
            for (int i = 0; i < masterNumber; i++)
            {
                this.Animals.Add(new Master());
            }
        }        public void RunTheFuckWorld() 
        {
            VoiceTransing = (VoiceTrans)delegate 
            {
                foreach(VisualAnimal animal in Animals)
                {
                    animal.ReceiveVoice(TransingVoice);
                }
            };            foreach (VisualAnimal animal in Animals) 
            {
                TransingVoice = animal.MakeVoice();
            }
        }
    }
    public enum VoiceType
    {
        Mute = 0,
        CatMiao = 1,
    }
    public interface IMakeVoice 
    {
        Voice MakeVoice();
    }
    
    public interface IReceiveVoice 
    {
        void ReceiveVoice(Voice voice);
    }    public abstract class VisualAnimal : IMakeVoice, IReceiveVoice 
    {
        public abstract Voice MakeVoice();
        public abstract void ReceiveVoice(Voice voice);
    }    public class Voice 
    {
        public VoiceType Type { get; set; }
        public int Volume { get; set; }
    }
    public class Cat :VisualAnimal
    {        public override Voice MakeVoice()
        {
            int volume = new Random().Next(1,100);
            if (volume <= 20)
            {
                Console.WriteLine("Cat:\"Hey, Miss Mouse~\"");
            }
            else
            {
                Console.WriteLine("Cat:\"Hey,Fuck your ass!!!MOUSE!!!!!\"");
            }
            return new Voice { Type= VoiceType.CatMiao , Volume = volume};
        }        public override void ReceiveVoice(Voice voice)
        {
            DoNothing();
        }        private void DoNothing() { }
    }
    public class Mouse :VisualAnimal
    {        public override Voice MakeVoice()
        {
            return new Voice { Type= VoiceType.Mute};
        }        public override void ReceiveVoice(Voice voice)
        {
            if (voice.Type == VoiceType.CatMiao && voice.Volume > 10)
            {
                RunAway();
            }
            else 
            {
                DoNothing();
            }
        }
        private void RunAway() 
        {
            Console.WriteLine("A mouse runs away!!");
        }
        private void DoNothing() { }
    }    public class Master:VisualAnimal
    {        public override Voice MakeVoice()
        {
            return new Voice {  Type= VoiceType.Mute};
        }        public override void ReceiveVoice(Voice voice)
        {
            if (voice.Type == VoiceType.CatMiao && voice.Volume > 20)
            {
                WakeUp();
            }
            else 
            {
                DoNothing();
            }
        }
        private void DoNothing() 
        {
            ;
        }
        private void WakeUp() 
        {
            Console.WriteLine("Shut up!! Fuck hell bitch cat!!");
        }
    }