十四、重写与多态

最新推荐文章于 2024-05-09 17:06:44 发布
最新推荐文章于 2024-05-09 17:06:44 发布
阅读量835 收藏 20
点赞数 20
分类专栏： C#学习 文章标签： c# 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62598265/article/details/136520166
版权

重写、多态

上一讲是，子类对父类横向上的扩展

这一讲是，子类对父类纵向上的扩展

在这里插入图片描述

方法重写

使用override关键字重写父类的方法

将父类原本方法的逻辑更新成新版本的逻辑

注：仅能重写可见的父类成员，并且重写要保持签名一致。

签名一致：对函数来说即，返回类型，名称，参数列表

python中对象有类型，但是变量是没有类型的，变量的类型永远是跟着对象走的。在Python中没有代差，重写就看不到多态的效果。

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

namespace OverrideExample {
    internal class Program {
        static void Main(string[] args) {
            /* 重写表示：
             * 在继承链上不同的对象实例调用同一个方法，
             * 就会触发相对应的版本的方法
             */
            var car = new Car();
            car.Run();//触发的是Car版本的Run方法
            //Car is running.

            var vehicle = new Vehicle();
            vehicle.Run();//触发的是基类版本的Run方法
            //I'm running.
        }
    }
    class Vehicle {
        /* virtual关键字
         * 表示该方法可被子类重写
         */
        public virtual void Run() {
            Console.WriteLine("I'm running.");
        }
    }
    class Car : Vehicle {
        /* override关键字
 * 表示重写父类的方法
 * 此时Car这个类中，只有一个Run方法，就是这个类体中的那个重写了的方法
 */
        public override void Run() {
            Console.WriteLine("Car is running.");
        }
    }
}

注：当一个类重写了父类的方法后，再被其他类所继承，那么其他类实际上继承的是Car版本的重写后的方法。

using System;

namespace OverrideExample {
    internal class Program {
        static void Main(string[] args) {
            var raseCar = new RaseCar();
            raseCar.Run();
            //Car is Running.
            Console.ReadLine();
        }
    }
    class Vehicle {
        public virtual void Run() {
            Console.WriteLine("I'm running.");
        }
    }
    class Car : Vehicle {
        public override void Run() {
            Console.WriteLine("Car is running.");
        }
    }
    class RaseCar : Car {
        /* 此时有子类继承Car
         * 那么Rase类继承的是Car版本的Run方法
         */
    }
}

方法隐藏

如果签名相同的方法在基类和派生类中都进行了声明，但是该方法没有分别声明为virtual和override，派生类就会隐藏基类方法（要使用new关键字进行声明）。隐藏的话，也就是看不到了，实际这个方法还存在。

也就是说，派生类中看不到和基类同名的那个方法了。

using System;

namespace OverrideExample {
    internal class Program {
        static void Main(string[] args) {
            // 父类引用指向子类对象
            Animal a = new Dog();
            // 调用非虚方法，根据引用的静态类型，调用父类的方法
            a.Eat(); // 输出 Animal eats
                     // 调用虚方法，根据对象的动态类型，调用子类的方法
            a.Sleep(); // 输出 Dog sleeps
            Console.ReadKey();
        }
    }
    // 基类
    public class Animal {
        // 非虚方法
        public void Eat() {
            Console.WriteLine("Animal eats");
        }
        // 虚方法
        public virtual void Sleep() {
            Console.WriteLine("Animal sleeps");
        }
    }

    // 子类
    public class Dog : Animal {
        /* 虽然继承了父类的同名方法，但是因为子类中也有同名的方法，
         * 所以子类会隐藏父类的同名的方法，也就是说子类见不到父类的方法
         * 表现在，子类类型引用的对象访问不到父类的同名方法。
         * 
         * 隐藏父类的非虚方法
         */
        //public new void Eat()
        //这两者是等同的
        public void Eat() {
            Console.WriteLine("Dog eats");
        }
        // 重写父类的虚方法
        public override void Sleep() {
            Console.WriteLine("Dog sleeps");
        }
    }
}

总结一下：

如果使用派生类声明的对象，调用隐藏方法会调用派生类的，如果使用基类声明对象，那么就会调用基类的隐藏方法。

三、虚方法与隐藏方法的区别

1、重写和隐藏的定义
重写：继承时发生，在派生类中重新定义基类中的方法，派生类中的方法和基类的方法是一样的 。例如：基类方法声明为virtual（虚方法），派生类中使用override声明此方法的重写。

隐藏：基类方法不做声明（默认为非虚方法），在派生类中使用new声明此方法的隐藏（new可写可不写）。

2、重写和隐藏的区别
重写（virtaul）时，定义的变量为基类或派生类， 赋值为派生类时，皆调用基类的重写方法（会从派生类中查找有重写则调用 ，没则调用基类方法）。
隐藏（new）时，定义的变量为基类，则调用基类的方法（不管赋值是派生类还是基类），定义的变量为派生类则调用派生类的方法。
————————————————

原文链接：https://blog.csdn.net/qq_44034384/article/details/106652112

多态

主要表现在方法和属性上面。

父类的同一种行为，在不同的子类上有不同的实现，这种实现叫做多态。

C#中的多态是指同一个接口或方法，使用不同的对象或参数，可以实现不同的功能或行为。多态可以提高代码的灵活性和可扩展性，实现对象之间的解耦。

C#中的多态可以分为两种：

  • 静态多态：也叫编译时多态，是指在编译时就确定了函数的调用。静态多态主要通过函数重载和运算符重载来实现。函数重载是指在同一个类中，可以定义多个同名但参数不同的函数，根据传入的参数类型和个数来决定调用哪个函数。运算符重载是指可以为用户自定义的类型重新定义运算符的含义和行为，使得运算符可以用于操作这些类型的对象。
  • 动态多态：也叫运行时多态，是指在运行时才确定了函数的调用。动态多态主要通过虚方法，抽象类和接口来实现。虚方法是指在父类中用virtual关键字声明的方法，可以在子类中用override关键字重写，实现不同的功能。抽象类是指用abstract关键字声明的类，不能被实例化，只能作为基类，包含抽象方法和非抽象方法。抽象方法是指在抽象类中用abstract关键字声明的没有方法体的方法，必须在子类中重写。接口是指用interface关键字声明的一种特殊的抽象类，只包含抽象成员，不能包含字段和构造函数，可以被类实现，实现类必须实现接口中的所有成员。

下面的例子主要是，通过虚方法来展现多态性。最下面有个综合示例。

using System;

namespace OverrideExample {
    internal class Program {
        static void Main(string[] args) {
            /* 多态：
             * 使用一个父类的变量，引用一个子类的实例
             * 使用这个变量调用被重写的成员的时候，
             * 总是能调用到 与所引用的对象实例相对应的 版本
             */
            Vehicle veh = new Car();
            veh.Run();//调用的Car类的版本

            Vehicle veh2 = new RaseCar();
            veh2.Run();//调用到RaseCar类的版本

            Console.ReadLine();
        }
    }
    class Vehicle {
        public virtual void Run() {
            Console.WriteLine("I'm running.");
        }
    }
    class Car : Vehicle {
        public override void Run() {
            Console.WriteLine("Car is running.");
        }
    }
    class RaseCar : Car {
        public override void Run() {
            Console.WriteLine("Rase Car is running.");
        }
    }
}

using System;

namespace OverrideExample {
    internal class Program {
        static void Main(string[] args) {
            /* 多态：
             * 使用一个父类的变量，引用一个子类的实例
             * 使用这个变量调用被重写的成员的时候，
             * 总是能调用到 与所引用的对象实例相对应的 版本
             */
            Vehicle veh = new Car();
            veh.Run();//调用的Car类的版本

            Vehicle veh2 = new RaseCar();
            veh2.Run();//调用到RaseCar类的版本

            Console.ReadLine();
        }
    }
    class Vehicle {
        public virtual void Run() {
            Console.WriteLine("I'm running.");
        }
    }
    class Car : Vehicle {
        public override void Run() {
            Console.WriteLine("Car is running.");
        }
    }
    class RaseCar : Car {
        public override void Run() {
            Console.WriteLine("Rase Car is running.");
        }
    }
}

综合例子：

using System;

namespace OverrideExample {
    internal class Program {
        static void Main(string[] args) {
            // 创建一个Shape数组，存放不同的Shape对象
            Shape[] shapes = new Shape[2];
            shapes[0] = new Circle(5, "red");
            shapes[1] = new Rectangle(10, 8, "blue");

            // 遍历数组，调用每个对象的Area和Draw方法
            foreach (Shape shape in shapes) {
                Console.WriteLine($"The area is {shape.Area()}");
                shape.Draw();
            }

            // 创建一个IColor数组，存放不同的IColor对象
            IColor[] colors = new IColor[2];
            colors[0] = new Circle(5, "red");
            colors[1] = new Rectangle(10, 8, "blue");

            // 遍历数组，调用每个对象的GetColor方法
            foreach (IColor color in colors) {
                Console.WriteLine($"The color is {color.GetColor()}");
            }
        }
    }
    // 定义一个抽象类Shape，包含一个抽象方法Area和一个虚方法Draw
    public abstract class Shape {
        public abstract double Area();
        public virtual void Draw() {
            Console.WriteLine("Drawing a shape.");
        }
    }

    // 定义一个接口IColor，包含一个抽象方法GetColor
    public interface IColor {
        string GetColor();
    }

    // 定义一个Circle类，继承自Shape类，实现IColor接口，重写Area和Draw方法，实现GetColor方法
    public class Circle : Shape, IColor {
        private double _radius;
        private string _color;

        public Circle(double radius, string color) {
            _radius = radius;
            _color = color;
        }

        public override double Area() {
            return Math.PI * _radius * _radius;
        }

        public override void Draw() {
            Console.WriteLine("Drawing a circle.");
        }

        public string GetColor() {
            return _color;
        }
    }

    // 定义一个Rectangle类，继承自Shape类，实现IColor接口，重写Area和Draw方法，实现GetColor方法
    public class Rectangle : Shape, IColor {
        private double _length;
        private double _width;
        private string _color;

        public Rectangle(double length, double width, string color) {
            _length = length;
            _width = width;
            _color = color;
        }

        public override double Area() {
            return _length * _width;
        }

        public override void Draw() {
            Console.WriteLine("Drawing a rectangle.");
        }

        public string GetColor() {
            return _color;
        }
    }
}

重写属性

using System;

namespace OverrideExample {
    internal class Program {
        static void Main(string[] args) {
            Vehicle veh = new Vehicle();
            veh.Run();
            Console.WriteLine(veh.Speed);

            Vehicle car = new Car();
            car.Run();
            Console.WriteLine(car.Speed);

            Console.ReadLine();
        }
    }
    class Vehicle {
        private int _speed;
        public virtual int Speed { 
            get => _speed; 
            set => _speed = value; 
        }
        public virtual void Run() {
            Console.WriteLine("I'm running.");
            _speed = 100;
        }
    }
    class Car : Vehicle {
        private int _rpm;
        public override void Run() {
            Console.WriteLine("Car is running.");
            _rpm = 5000;
        }
        public override int Speed { 
            get => _rpm / 100; 
            set => _rpm = value * 100; 
        }
    }
    class RaseCar : Car {
        public override void Run() {
            Console.WriteLine("Rase Car is running.");
        }
    }
}

总结

方法隐藏是指当子类声明了一个与父类签名相同的非虚方法时，会隐藏父类中的同名非虚方法。这种情况下，调用该方法时，会根据引用的静态类型来决定调用哪个类的方法，而不是根据对象的动态类型。

这与方法重写不同，方法重写是指当子类重写了父类的虚方法时，会覆盖父类中的同名虚方法。这种情况下，调用该方法时，会根据对象的动态类型来决定调用哪个类的方法，而不是根据引用的静态类型。

无论是重写基类的方法还是重写基类的属性，这两者都必须是 virtual、abstract 或 override。

不能重写非虚的、静态的方法或属性

// 基类
public class Animal
{
    // 非虚方法
    public void Eat()
    {
        Console.WriteLine("Animal eats");
    }
    // 虚方法
    public virtual void Sleep()
    {
        Console.WriteLine("Animal sleeps");
    }
}

// 子类
public class Dog : Animal
{
    // 隐藏父类的非虚方法
    public new void Eat()
    {
        Console.WriteLine("Dog eats");
    }
    // 重写父类的虚方法
    public override void Sleep()
    {
        Console.WriteLine("Dog sleeps");
    }
}

// 测试
public class Test
{
    public static void Main(string[] args)
    {
        // 父类引用指向子类对象
        Animal a = new Dog();
        // 调用非虚方法，根据引用的静态类型，调用父类的方法
        a.Eat(); // 输出 Animal eats
        // 调用虚方法，根据对象的动态类型，调用子类的方法
        a.Sleep(); // 输出 Dog sleeps
    }
}
白虹思无邪
关注
  • 20
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#重写重载与多态
09-06
重写：是指重写基类的方法，在基类中的方法必须有修饰符virtual，而在子类的方法中必须指明override。重载：用于在给定了参数列表和一组候选函数成员的情况下，选择一个最佳函数成员来实施调用。多态：c#的多态性...
重写和多态
qq_48578877的博客
07-22 634
重写的原则和多态的概念、优点
重载和重写、多态
qq_53028837的博客
06-20 3941
一、重载和重写 1.重载是多态的一种体现，方法的重载是让类以统一的方式处理不同类型数据的一种手段。重载是方法名不变，但参数一定变。 使用方法重载时需注意的： 同一个类中方法名相同，参数列表不同 返回值类型不能用于区分方法的重载 2.构造方法能重载，声明为final的方法不能被重载，声明为static的方法不能被重载但能被再次声明 示例： public class Book { //定义3个重载方法 public float getPrice(){ return 100; } publ
方法的重写与多态
weixin_57328493的博客
05-09 468
方法的重写与多态 一、方法的重写 ​1.方法重写也叫方法覆盖，是指子类根据需求对从父类继承的方法进行重新编写。通常父类的方法被子类继承后，在不同的子类中可能需要做不同的操作。方法只能在子类中进行重写。 2.在​重写时，可以用super.方法的方式来保留父类的方法。但构造方法不能被重写，因为子类不能从父类中继承父类构造方法，而是调用父类的构造方法。 ​二、方法重写的规则 1.方法名和参数类型相同 2.返回值类型相同或是其子类（不能是基本数据类型的自动转换） 3.访问权限不能严于父类（子类中方法的访问修饰符所限
重载,重写与多态的区别
justlpf的专栏
04-23 5942
重载(Overloading) 方法重载是让类以统一的方式处理不同类型数据的一种手段。多个同名函数同时存在，具有不同的参数个数/类型。重载Overloading是一个类中多态性的一种表现。 Java的方法重载，就是在类中可以创建多个方法，它们具有相同的名字，但具有不同的参数和不同的定义。调用方法时通过传递给它们的不同参数个数和参数类型来决定具体使用哪个方法, 这就是多态性。 重载的时候，方法名要一...
【Java】方法的重写和多态
swy2560666141的博客
09-20 1024
1、 继承是Java中实现代码重用的重要手段之一。Java中只支持单根继承，即一个类只能有一个直接父类。Object类是所有Java类的祖先。2、 在子类中可以根据实际需要对从父类继承的方法进行重新编写，称为方法的重写或覆盖。3、 子类中重写的方法和父类中被重写的方法必须具有相同的方法名、参数列表，返回值类型必须和被重写方法的返回值类型相同。4、 在实例化子类是，会首先执行其父类的构造方法，然后在执行子类的构造方法。5、 通过super关键字可以访问父类的成员。
继承、重写与多态
TOTsonny7的博客
11-23 376
继承的概念与应用
C++重载重写和多态区别
点点滴滴
02-05 920
C++重载重写和多态区别 1.重载和重写的区别： 重载overload：在同一个类中，函数名相同，参数列表不同，编译器会根据这些函数的不同参数列表，将同名的函数名称做修饰，从而生成一些不同名称的预处理函数，未体现多态。 重写override：也叫覆盖，子类重新定义父类中有相同名称相同参数的虚函数，主要是在继承关系中出现的，被重写的函数必须是virtual的，重写函数的访问修饰符可以不同，尽管virtual是private的，子类中重写函数改为public,protected也可以，体现了多态。 重
方法重写与多态
小兔子乖乖
01-22 170
方法重写与多态一.方法重写1.方法重写的定义2.方法重写的规则3.方法重写&方法重载4.Object类equals()方法二.多态1.多态的概念2.多态的使用3.抽象方法4.向上转型/向下转型5.练习 一.方法重写 1.方法重写的定义 2.方法重写的规则 在继承的情况下，子类的方法满足以下的条件： 3.方法重写&方法重载 4.Object类 Object类是所有类的父类 Object类被子类经常重写的方法 equals()方法 二.多态 1.多态的概念 2.多态的使用 3.抽象方
重写与重载以及与多态的关系
TSEAHT的博客
04-11 999
关于重载和重写，你应该知道以下几点： 1、重载是一个编译期概念、重写是一个运行期间概念。 2、重载遵循所谓“编译期绑定”，即在编译时根据参数变量的类型判断应该调用哪个方法。 3、重写遵循所谓“运行期绑定”，即在运行的时候，根据引用变量所指向的实际对象的类型来调用方法 4、因为在编译期已经确定调用哪个方法，所以重载并不是多态。而重写是多态。重载只是一种语言特性，是一种语法规则，与多态无关，...
重写与多态
weixin_44871778的博客
01-02 403
重写与重载的区别 1、重载是参数列表不同的同名方法； 2、重写是在继承关系中子类重写父类方法； 重写：需要有父子关系，子类重写父类的方法 1、方法名相同； 2、参数列表相同； 3、修饰符范围可以扩大：public>protected>default>private; 4、抛出异常：范围可以缩小但不能扩大； static方法属于类，不属于实例，不能被重写； final 是常量，不能被重写； private 私有方法不能被重写； 可父类的引用指向子类 Person person = new S
Java基础之方法重写和多态示例
08-25
主要介绍了Java基础之方法重写和多态,结合实例形式分析了java方法重写和多态的相关原理与使用技巧,需要的朋友可以参考下
1.2：多态与重写.pdf
08-20
重写，子类override，父类virtual， 用数组输出两个show，多态 Person[] persons = new Person[2]; Student stu = new Student("aaa", 20, true); Teacher t = new Teacher("aa", 12, false); persons[0] = stu;...
java中重载，继承，重写和多态的区别
09-04
主要介绍了java中重载，继承，重写和多态的区别,需要的朋友可以参考下
C#中多态、重载、重写区别分析
09-04
主要介绍了C#中多态、重载、重写区别,采用实例较为通俗易懂的分析了多态、重载的重写的概念与用法,对于C#初学者有非常不错的借鉴价值,需要的朋友可以参考下
ThinkPHP+MySQL查询数据的时候计算两个经纬度之间的距离并根据距离进行筛选
qq_40088333的博客
05-07 221
ThinkPHP+MySQL查询数据的时候计算两个经纬度之间的距离并根据距离进行筛选
智慧手术室手麻系统源码，C#手术麻醉临床信息系统源码，符合三级甲等医院评审要求
最新发布
baina666的博客
05-09 190
同时与医院信息系统的信息整合，实现了围术期患者信息的自动采集与共享全面支持麻醉文书记录、麻醉流程管理、麻醉术中事件管理、麻醉复苏管理等。手术麻醉临床信息系统功能符合三级甲等医院评审要求，实现与医院现有信息系统如HIS、LIS、PACS、EMR等系统全面对接，全面覆盖从患者入院，经过术前、术中、术后，直至出院的全过程。麻醉访视：麻醉医生需要记录手术麻醉的过程，包括来自监护仪的患者生命体征的变化，还包括术前、术中、术后的麻醉诱导记录，以及术中麻醉记录、各种化验、术后麻醉总结、术后随访；
并发编程总结（二）
靖妖傩舞
05-06 719
系统要求任一进程必须预先申请它所需要的全部资源，而且仅当该进程的全部资源要求能得到满足时，系统才能给予一次性分配，然后启动该进程运行，但是在分配时只要有一种资源不满足，系统就不会给进程分配资源。死锁的检测：检查死锁的办法就是由软件检查系统中由进程和资源构成的有向图是否构成一个或多个环路，若是，则存在死锁，否则不存在。允许系统在运行的过程中产生死锁，但是，系统中有相应的管理模块可以及时检测出已经产生的死锁，并且精确地确定与死锁有关的进程和资源，然后采取适当措施，清除系统中已经产生的死锁。
【C#】某AGV调度系统源码笔记（六）
cxyhjl的博客
05-07 628
AGV数据访问类库1. AGV客户端数据访问AGV系统中数据访问层的详细定义和实现：涉及了系统参数处理、程序集配置、AGV档案信息处理、AGV特殊指令处理、地图信息处理、特殊交通管制处理、报表信息处理、坐标体系处理、用户信息处理、区域、物料等简易档案的处理、呼叫器档案处理、任务生成配置处理、特殊线路线段配置、IO模块功能配置以及平板档案处理等方面的内容。为AGV系统提供了底层数据处理和业务逻辑的实...
继承,重载,重写,多态
07-16
这是面向对象编程的四个重要概念： 1. 继承（Inheritance）：指子类可以继承父类的属性和方法，子类可以使用父类的公有属性和方法，而不需要重新编写。通过继承，可以实现代码的复用和扩展。 2. 重载（Overloading...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值