面向对象基础（继承类，抽象方法，接口，委托和事件）

1.页面上实现猫叫，狗叫，虎叫

<asp:Button ID="cat" runat="server" Text="猫叫" onclick="cat_Click" /><br/>
<asp:Button ID="dog" runat="server" Text="狗叫" onclick="dog_Click" /><br/>
<asp:Button ID="tiger" runat="server" Text="虎叫" onclick="tiger_Click" /><br/>
<asp:Button ID="shout" runat="server" Text="轮流叫" onclick="shout_Click" /><br/>
<asp:Button ID="change" runat="server" Text="实现了接口" onclick="change_Click" />

2.先实现猫叫，不用任何设计模式，定义一个猫的类(CCat)

无面向对象设计

 public class CCat
    {
        public string Name = string.Empty;//公用
        private int _numb=1;//私有
        public CCat(string name) //构造函数
        {
            this.Name = name;
        }

        public CCat()//2个函数重载，参数个数或者参数类型不一样都能重载
        {
            this.Name = "无名";
        }

        public int Numb //叫几次
        {
            get { return _numb; }//可读
            set {_numb = value<=3 ? value :3 ;} //可赋值
        }
       public string Shout()
       {
           string result = "";
           for (int i = 0; i < _numb; i++)
           {
               result += "喵！";
           }
           return "我叫" + Name +result;
        }
    }

页面上使用这个方法

protected void cat_Click(object sender, EventArgs e)
        {
            CCat cat=new CCat("小猫");
            cat.Numb = 5;
            Response.Write(cat.Shout());
        }

3.使用继承关系，猫狗还有老虎都是属于动物，所以定义一个动物类，Animal，猫狗虎都有构造函数和叫声这个方法，所以定义动物类

抽象类继承

 abstract class Animal //abstract表示是抽象方法，anmial就是抽象类了，抽象类不能实例化，要被子类重写，不然就没意义了
    {
        protected string Name = "";//protected 可以被子类用，其他类不能用

        protected Animal()
        {
            this.Name = "无名";
        }

        protected Animal(string name)
        {
            this.Name = name;
        }

        protected int _numb = 1;
        public int Numb
        {
            get { return _numb; }
            set { _numb = value; }
        }

        //public virtual string Shout()//构建虚方法 virtual
        //{
        //    return "";
        //}
        #region 重构 把shout方法放到父类，getshout()虚写方法，只为得到是谁
        public string Shout()//增加了override表示方法重写
        {
            string result = "";
            for (int i = 0; i < _numb; i++)
            {
                result += GetShout()+",";
            }
            return "我叫" + Name + result;
        }

        public abstract string GetShout();//抽象方法

        #endregion
    }

class CDog: Animal //继承父类 猫和狗都是动物
    {
        public CDog()//base()关键字代表父类
        {

        }
        public CDog(string name): base(name)
        {

        }
        public override string GetShout()//增加了override表示方法重写
        {
            return "汪！";
        }　　　}

  protected void dog_Click(object sender, EventArgs e)
        {
            CDog dog = new CDog("小狗");
            dog.Numb = 5;
            Response.Write(dog.Shout());
        }

3.实现接口猫狗老虎都是地上跑的（一个类可以有多个接口，却不能继承多个基类）

接口　

interface IChange//接口 命名以I开头，不能有构造函数，不能有修饰符，不能虚拟的静态的
        //实现接口的类 必须继承所有接口的方法和属性
    {
        string ChangegThing(string thing);//接口方法返回string类型
    }

class CDog: Animal,IChange //继承父类 猫和狗都是动物 实现接口都能跑
    {
        public CDog()//base()关键字代表父类
        {

        }
        public CDog(string name): base(name)
        {

        }
        public override string GetShout()//增加了override表示方法重写
        {
            return "汪！";
        }

        public string ChangegThing(string thing)
        {
            return base.Shout()+thing;
        }
}

　泛型的优点，比集合少装箱拆箱的过程，集合存在转换失败的可能

 protected void change_Click(object sender, EventArgs e)
        {
            IList<IChange> listAnimal=new List<IChange>();//泛型
            listAnimal.Add(new CDog("小狗"));
            listAnimal.Add(new CTiger("小虎"));

            Response.Write(listAnimal[0].ChangegThing("我是跑的"));//利用多态实现不同的ChangegThing
            Response.Write(listAnimal[1].ChangegThing("我也是跑的"));
        }

4.当猫叫一声，我来了，老鼠1和老鼠2分别叫猫来了快跑，和实现一个跑的方法

委托和事件

class Mouse//定义一个老鼠类
    {
        private string name;

        public Mouse(string name)
        {
            this.name = name;
        }

        public void Run()
        {
            Console.WriteLine("老猫来了快跑{0}",name);
        }
    }

 class Cat//定义一个猫类
    {
        private string Name;

        public Cat(string name)
        {
            this.Name = name;
        }

        public delegate void CatShoutEventHandler();//申明委托（委托是对函数的封装,delegate）

        public event CatShoutEventHandler CatShout;//申明事件 事件是一种特殊的委托,event

        public void Shout()
        {
            Console.WriteLine("喵，我是{0}",Name);
             if (CatShout != null)
            {
                CatShout();//如果CatShout有对象登记事件则执行CatShout,把老鼠跑方法登记在事件里，猫一叫，就执行老鼠的run方法
            }
        }
    }

 static void Main(string[] args)
        {
            Cat cat=new Cat("猫");
            Mouse mouse1=new Mouse("jukery");
            Mouse mouser2=new Mouse("kshds");

            cat.CatShout += new Cat.CatShoutEventHandler(mouse1.Run);
            cat.CatShout += new Cat.CatShoutEventHandler(mouser2.Run);//把方法登记在事件(事件event是特殊的委托delegate)
            cat.Shout();//执行shout方法的时候就是猫教的时候，通知两只老鼠，如果事件不为空，则执行委托里的方法
            Console.Read();
        }