C#多态概述:通过继承实现的不同对象调用相同的方法,表现出不同的行为

简介: C#多态概述:通过继承实现的不同对象调用相同的方法,表现出不同的行为

封装、继承、多态,面向对象的三大特性,前两项理解相对容易,但要理解多态,特别是深入的了解,对于初学者而言可能就会有一定困难了。我一直认为学习OO的最好方法就是结合实践,封装、继承在实际工作中的应用随处可见,但多态呢?也许未必,可能不经意间用到也不会把它跟“多态”这个词对应起来。在此抛砖引玉,大家讨论,个人能力有限,不足之处还请指正。

之前看到过类似的问题:如果面试时主考官要求你用一句话来描述多态,尽可能的精炼,你会怎么回答?当然答案有很多,每个人的理解和表达不尽相同,但我比较趋向这样描述:通过继承实现的不同对象调用相同的方法,表现出不同的行为,称之为多态。

例1:

代码

public class Animal

    {

        public virtual void Eat()

        {

            Console.WriteLine("Animal eat");

        }

    }

    public class Cat : Animal

    {

        public override void Eat()

        {

            Console.WriteLine("Cat eat");

        }

    }

    public class Dog : Animal

    {

        public override void Eat()

        {

            Console.WriteLine("Dog eat");

        }

    }

    class Tester

    {

        static void Main(string[] args)

        {

            Animal[] animals = new Animal[3];

            animals[0] = new Animal();

            animals[1] = new Cat();

            animals[2] = new Dog();

            for (int i = 0; i < 3; i++)

            {

                animals[i].Eat();

            }

        }

    }

在上面的例子中,通过继承,使得Animal对象数组中的不同的对象,在调用Eat()方法时,表现出了不同的行为。

多态的实现看起来很简单,要完全理解及灵活的运用c#的多态机制,也不是一件容易的事,有很多需要注意的地方。

new的用法

先看下面的例子。

例2:

代码

public class Animal

    {

        public virtual void Eat()

        {

            Console.WriteLine("Animal eat");

        }

    }

    public class Cat : Animal

    {

        public new void Eat()

        {

            Console.WriteLine("Cat eat");

        }

    }

    class Tester

    {

        static void Main(string[] args)

        {

            Animal a = new Animal();

            a.Eat();

            Animal ac = new Cat();

            ac.Eat();

            Cat c = new Cat();

            c.Eat();

        }

    }

运行结果为:

复制  

Animal eat...
Animal eat...
Cat eat...

可以看出,当派生类Cat的Eat()方法使用new修饰时,Cat的对象转换为Animal对象后,调用的是Animal类中的Eat()方法。其实可以理解为,使用new关键字后,使得Cat中的Eat()方法和Animal中的Eat()方法成为毫不相关的两个方法,只是它们的名字碰巧相同而已。所以, Animal类中的Eat()方法不管用还是不用virtual修饰,也不管访问权限如何,或者是没有,都不会对Cat的Eat()方法产生什么影响(只是因为使用了new关键字,如果Cat类没用从Animal类继承Eat()方法,编译器会输出警告)。

我想这是设计者有意这么设计的,因为有时候我们就是要达到这种效果。严格的说,不能说通过使用new来实现多态,只能说在某些特定的时候碰巧实现了多态的效果。

override实现多态

真正的多态使用override来实现的。回过去看前面的例1,在基类Animal中将方法Eat()用virtual标记为虚拟方法,再在派生类Cat和Dog中用override对Eat()修饰,进行重写,很简单就实现了多态。需要注意的是,要对一个类中一个方法用override修饰,该类必须从父类中继承了一个对应的用virtual修饰的虚拟方法,否则编译器将报错。

好像讲得差不多了,还有一个问题,不知道你想没有。就是多层继承中又是怎样实现多态的。比如类A是基类,有一个虚拟方法method()(virtual修饰),类B继承自类A,并对method()进行重写(override修饰),现在类C又继承自类B,是不是可以继续对method()进行重写,并实现多态呢?看下面的例子。

例3:
代码

public class Animal

   {

       public virtual void Eat()

       {

           Console.WriteLine("Animal eat");

       }

   }

   public class Dog : Animal

   {

       public override void Eat()

       {

           Console.WriteLine("Dog eat");

       }

   }

   public class WolfDog : Dog

   {

       public override void Eat()

       {

           Console.WriteLine("WolfDog eat");

       }

   }

   class Tester

   {

       static void Main(string[] args)

       {

           Animal[] animals = new Animal[3];

           animals[0] = new Animal();

           animals[1] = new Dog();

           animals[2] = new WolfDog();

           for (int i = 0; i < 3; i++)

           {

               animals[i].Eat();

           }

       }

}

运行结果为:

Animal eat...
Dog eat...
WolfDog eat...

在上面的例子中类Dog继承自类Animal,对方法Eat()进行了重写,类WolfDog又继承自Dog,再一次对Eat()方法进行了重写,并很好地实现了多态。不管继承了多少层,都可以在子类中对父类中已经重写的方法继续进行重写,即如果父类方法用override修饰,如果子类继承了该方法,也可以用override修饰,多层继承中的多态就是这样实现的。要想终止这种重写,只需重写方法时用sealed关键字进行修饰即可。

abstract-override实现多态

先在我们在来讨论一下用abstract修饰的抽象方法。抽象方法只是对方法进行了定义,而没有实现,如果一个类包含了抽象方法,那么该类也必须用abstract声明为抽象类,一个抽象类是不能被实例化的。对于类中的抽象方法,可以再其派生类中用override进行重写,如果不重写,其派生类也要被声明为抽象类。看下面的例子。

例4:


代码

    public abstract class Animal

    {

      public abstract void Eat();

    }

    public class Cat : Animal

    {

        public override void Eat()

        {

            Console.WriteLine("Cat eat");

        }

    }

    public class Dog : Animal

    {

        public override void Eat()

        {

            Console.WriteLine("Dog eat");

        }

    }

    public class WolfDog : Dog

    {

        public override void Eat()

        {

            Console.WriteLine("Wolfdog eat");

        }

    }

    class Tester

    {

        static void Main(string[] args)

        {

            Animal[] animals = new Animal[3];

            animals[0] = new Cat();

            animals[1] = new Dog();

            animals[2] = new WolfDog();

            for (int i = 0; i < animals.Length; i++)

            {

                animals[i].Eat();

            }

        }

    }

运行结果为:

Cat eat...
Dog eat...
Wolfdog eat...

从上面可以看出,通过使用abstract-override可以和virtual-override一样地实现多态,包括多层继承也是一样的。不同之处在于,包含虚拟方法的类可以被实例化,而包含抽象方法的类不能被实例化。

目录
打赏
10
63
65
2
94
分享
相关文章
C# 去掉字符串最后一个字符的 4 种方法
在实际业务中,我们经常会遇到在循环中拼接字符串的场景,循环结束之后拼接得到的字符串的最后一个字符往往需要去掉,看看 C# 提供了哪4种方法可以高效去掉字符串的最后一个字符
478 0
C# 比较对象新思路,利用反射技术打造更灵活的比较工具
中途接手的项目,碰到需要在更新对象信息时比较并记录差异的需求,最变态的还有附加要求,怎么办?有没有既能满足需求又能对项目影响最小的方法呢?分享这个我封装的方法,一个利用反射技术打造的更灵活的比较工具
使用 C# 比较两个对象是否相等的7个方法总结
比较对象是编程中的一项基本技能,在实际业务中经常碰到,比如在ERP系统中,企业的信息非常重要,每一次更新,都需要比较记录更新前后企业的信息,直接比较通常只能告诉我们它们是否指向同一个内存地址,那我们应该怎么办呢?分享 7 个方法给你!
|
3月前
|
C# 异步方法async / await任务超时处理
通过使用 `Task.WhenAny`和 `Task.Delay`方法,您可以在C#中有效地实现异步任务的超时处理机制。这种方法允许您在指定时间内等待任务完成,并在任务超时时采取适当的措施,如抛出异常或执行备用操作。希望本文提供的详细解释和代码示例能帮助您在实际项目中更好地处理异步任务超时问题,提升应用程序的可靠性和用户体验。
123 3
|
4月前
|
【C#】大批量判断文件是否存在的两种方法效率对比
【C#】大批量判断文件是否存在的两种方法效率对比
81 1
|
5月前
|
C# 面向对象编程的三大支柱:封装、继承与多态
【9月更文挑战第17天】在C#中,面向对象编程的三大支柱——封装、继承与多态,对于编写安全、可维护、可复用的代码至关重要。封装通过访问修饰符和属性保护数据;继承允许子类继承父类的属性和方法,实现代码复用和多态;多态则提高了代码的灵活性和通用性。掌握这三大概念能显著提升C#编程能力,优化开发效率和代码质量。
|
4月前
|
C#
C#的方法的参数传递
C#的方法的参数传递
46 0
C#中windows应用窗体程序的输入输出方法实例
C#中windows应用窗体程序的输入输出方法实例
79 0
|
3月前
|
C# 一分钟浅谈:Code Contracts 与契约编程
【10月更文挑战第26天】本文介绍了 C# 中的 Code Contracts,这是一个强大的工具,用于通过契约编程增强代码的健壮性和可维护性。文章从基本概念入手,详细讲解了前置条件、后置条件和对象不变量的使用方法,并通过具体代码示例进行了说明。同时,文章还探讨了常见的问题和易错点,如忘记启用静态检查、过度依赖契约和性能影响,并提供了相应的解决建议。希望读者能通过本文更好地理解和应用 Code Contracts。
61 3
学懂C#编程:属性(Property)的概念定义及使用详解
通过深入理解和使用C#的属性,可以编写更清晰、简洁和高效的代码,为开发高质量的应用程序奠定基础。
120 12