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();

        }

    }

}

结果是：

巴特西

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

最新文章

热门文章