C#--多态\ 抽象

多态

指同一个事物具有多种表现形式，既对象可以表现多个类型的能力。
允许将子类类型的指针赋值给父类类型的指针（就是别人讲课通过自己吸收在讲给别人听就是自己的了）

     public class Teacher:Person 
        {
            public override void Show()

            {
                Console.writeline("");
             }

        }

举例： 同一个事物，可以扫地、旋转、驾驶等等。

多态练习：

//随机产生10个类的对象
//方法数组里
//之后便利这个数组，把方法调出来
//animal 猪4母狗

 class Program
    {
        static void Main(string[] args)
        {
//-----------------------------
            Animal[]animal=new Animal[10];
            Random r = new Random();

//-----------------------------循环加载
            for (int i = 0; i < animal.Length ; i++)
            {
                int num=r.Next(1,5);
                switch (num )
                {
                    case 1: animal[i] = new Pig("老黄"); break;
                    case 2: animal[i] = new Cow("老牛"); break;
                    case 3: animal[i] = new Cat("老白"); break;
                    case 4: animal[i] = new Dog("老的"); break;


                }
            }

//-----------------------------循环显示
            for (int i = 0; i < animal.Length ; i++)
            {
                animal[i].Shout();
            }
            Console.ReadKey();
        }

    }


//-----------------------------  
//-----------------------------以下是各种方法
     //父类
    public abstract  class Animal
    {
        string _name;
        public string name
        {
            get { return _name; }
            set { _name = value; }

        }

        public abstract  void Shout();  //抽象方法
    }

    //下面是四个子类
    public class Pig:Animal 
    {
        public Pig(string name)
            : base(name) 
        { 
        }
        public override void Shout()
        {
            Console.WriteLine("{0}哼哼哼。。。",this.name );
        }
     }

    public class Dog : Animal
    {
         public Dog (string name)
            : base(name) 
        { 
        }
        public override void Shout()
        {
            Console.WriteLine("{0}汪汪汪",this.name);
        }
    }

    public class Cow : Animal
    {
         public Cow (string name)
            : base(name) 
        { 
        }
        public override void Shout()
        {
            Console.WriteLine("{0}某某某",this.name );
        }
    }

    public class Cat : Animal
    {

        public Cat(string name) : base(name) { }
        public override void Shout()
        {
            Console.WriteLine("{0}喵喵。。。",this.name );

        }
    }

---

多态两种方法： 虚方法和重写

1. 方法不能用static修饰
2. 方法重写与基类的签名必须一致
3. virtual不能与private一起使用

虚方法练习：

 class Program
    {
        static void Main(string[] args)
        {

         Person p=new Person() ;
         Console.WriteLine(p);
         Console.ReadKey();

        }
    }

    public class Person
    {
        public void Show()
        {
            Console.WriteLine("哈哈答复");
        }
    }
//显示这个页的名字

---

抽象方法

1. 抽象方法是用abstract修饰
2. 抽象方法没有方法体
3. 抽象方法必须在抽象类中
4. 抽象类 无法实例化
5. 父类是抽象类，子类继承了这个类，必须把抽象类中的抽象方法必须要重写。

 class Program
    {
        static void Main(string[] args)
        {
           pig pig = new pig();  //定义新的
           pig.Shout();    //显示        
           Console.ReadKey();
        }
    }

//抽象出父类
    public abstract class Animal
    {

        private string _name;
        public string name
        {
            get { return _name; }
            set { _name = value; }
        }

        private int _age = 18;
        public int Age
        {
            get { return _age; }
            set { _age = value; }

        }

        private char _gender;
        public char Gender
        {
            get { return _gender; }
            set { _gender = value; }
        }

        public abstract void Shout();


    }
//子类继承
    public class pig : Animal
    {
        public override void Shout()
        {
            Console.WriteLine("哼哼叫");
        }
    }

//结果显示：哼哼叫

abstract 使用注意：

1. 抽象方法没有方法体
2. 抽象成员只能存在于抽象类
3. 抽象类可以有非抽象成员
4. 抽象类的派生类必须实现抽象方法体
5. 抽象类只能用作基类、无法实例化。

---

虚方法和抽象方法区别：