C#多态--虚方法实现多态

1.虚方法提供一种默认实现，子类可以选择是否重写，如果不重写，那么就使用父类已经实现的方法。（重写可以改变方法的指针)

如果需要改变类型指针，那么需要做方法的重写：

1.如果子类方法是重写方法，那么系统会扫描父类方法中，有没有相同签名的可重写方法，如果没有就报错。

2.如果父类方法是虚方法，那么子类可以选择是否重写，如果重写，就会调用子类的重写方法，实现多态；如果没有重写，就会使用父类已经实现的方法。

3.实现多态需要实现方法的重写

3.实现重写得实现类的继承

多态的使用：申明父类变量，实例化子类对象。

多态：一种操作，多种响应。

实现多态的思路：

1.先创建好父类，在创建好子类；

2.在父类中创建需要被重写的虚方法或者抽象方法

3.在子类中重写父类的虚方法或者抽象方法

4.申明父类类型的变量，实例化子类对象---写出通用代码；

1.声明父类变量，实例化子类对象  如：Person per=new Student()

2.以父类作为方法的返回值类型，返回具体的子类对象---（简单工厂，封装变化点）；

3，父类作为参数，传入具体的子类对象；

父类People

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态的实现
{
    class People
    {
        #region ID
        int id;

        public int ID
        {
            get { return id; }
            set { id = value; }
        }
        #endregion

        #region Name
        string name;

        public string Name
        {
            get { return name; }
            set { name = value; }
        }
        #endregion

        #region Age
        int age;

        public int Age
        {
            get
            {
                //如果年龄大于0小于等于100，就返回，否则返回18岁
                if (age >  && age <= )
                {
                    return age;
                }
                else
                {
                    return ;
                }
            }
            set
            {
                if (value >  && value <= ) //注意这里不是： if(age>0&&age<=100)
                {
                    age = value;
                }
                else
                {
                    age = ;
                }
            }
        }
        #endregion

        #region Sex
        string sex;

        public string Sex
        {
            get
            {
                //如果性别是男，或者女，就返回相应值，否则就设置为人妖
                if (sex == "男" || sex == "女")
                {
                    return sex;
                }
                else
                {
                    return "人妖";
                }
            }
            set
            {
                if (value == "男" || value == "女")
                {
                    sex = value;
                }
                else
                {
                    sex = "人妖";
                }
            }
        }
        #endregion

        public virtual void Show()
        {
            Console.WriteLine("我是父类People的Show方法");
        }

    }
}

子类Student

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态的实现
{
    /// <summary>
    ///
    /// </summary>
    class Student : People   //实现多态必须要实现方法的重写，实现重写，必须要实现继承
    {
        public override void Show()
        {

             Console.WriteLine("我是Student类的Show方法");
        }
        //public override void Show()
        //{
        //    //方法重写默认是，调用父类的同名方法
        //    base.Show();
        //}
    }
}

子类Teacher

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态的实现
{
    class Teacher:People  //实现多态必须要实现方法的重写，实现重写，必须要实现继承
    {
        override public void Show()
        {
            Console.WriteLine("我是teacher类的Show方法");
        }
    }
}

测试：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态的实现
{
    class Program
    {
        static void Main(string[] args)
        {
            //创建父类变量
            People[] p = new People[];

            //实例化子类对象
            p[] = new Student();
            p[] = new Teacher();

            //写出通用代码
            p[].Show();
            p[].Show();
            Console.ReadKey();
        }
    }
}

例子2：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态的练习
{
    class Animal
    {
        public virtual void GetFood()
        {
           //虚方法往往不知道，怎么实现。
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态的练习
{
    class LaoYing:Animal
    {
        public override void GetFood()
        {
            Console.WriteLine("老鹰靠俯冲捕食。");
            //base.GetFood();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态的练习
{
    class Snack:Animal
    {
        public override void GetFood()
        {
            Console.WriteLine("蛇靠偷袭捕食");
            //base.GetFood();  //虚方法提供了默认实现，就是调用父类的方法
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 多态的练习
{
    class Program
    {
        static void Main(string[] args)
        {
            //实现多态的步骤
            //1.先写好父类，和可以被重写的方法
            //2.写好子类，重写父类的方法
            //3.声明父类变量，实例化子类对象

            Animal[] ans = new Animal[];
            ans[] = new Snack();
            ans[] = new LaoYing();

            foreach (var item in ans)
            {
                item.GetFood();
            }
            Console.ReadKey();
        }
    }
}

结果是：