C#继承中virtual、override、new的使用C#继承中virtual、override、new的使用

115 阅读 0 评论 76 点赞

我是靠谱客的博主感性早晨，最近开发中收集的这篇文章主要介绍C#继承中virtual、override、new的使用C#继承中virtual、override、new的使用，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

C#继承中virtual、override、new的使用

1.第一个关键字：new — 子类中用于屏蔽父类对子类中同样签名（子类中的方法和父类中的方法名字和参数都一模一样）方法的影响。示例如下

//父类：动物类
public class Animal{
    public void Eat(){
        Console.WriteLine("我是动物，我每顿都要吃饭!");
    }
    public void Run(){
        Console.WriteLine("我是动物，我每天都要跑步!");
    }
}
//子类：狗类
public class Dog：Animal{
    //这个Eat()在编译器中会显示下划线，表示警告
    public void Eat(){
        Console.WriteLine("我是狗，我每顿都吃骨头!");
    }
    //这个Run()因为加了new，所以不会报警告
     public new void Run(){
        Console.WriteLine("我是狗，我跑一千米都不会丢!");
    }
}
###  main函数  ####
public static void Main(string[] args){
    Animal animal1 = new Animal();//实例化一个动物类对象
    Dog  dog1 = new Dog();//实例化一个狗类对象
    Animal animalDog1 = new Dog();//使用子类实例化父类（需要注意）

    animal1.Eat();//输出：我是动物，我每顿都要吃饭!
    animal1.Run();//输出：我是动物，我每天都要跑步!

    dog1.Eat();//输出：我是狗，我每顿都吃骨头!
    dog1.Run();//输出：我是狗，我跑一千米都不会丢!

    animalDog1.Eat();//输出：我是动物，我每顿都要吃饭!
    animalDog1.Run();//输出：我是动物，我每天都要跑步!
    Console.ReadKey();
}

分析：

1.new 关键字对子类和父类的方法没有任何影响，只是表示子类新写了继承的父类方法
2.new 关键字对用子类实例化父类生成的对象AnimalDog，在使用的过程中没有影响，AnimalDog只会调用父类的方法

2.第二个和第三个关键字：virtual和override — 子类中用于重写与父类有同样签名（子类中的方法和父类中的方法名字和参数都一模一样）方法。示例如下:

//父类：动物类
public class Animal{
    public virtual void Eat(){
        Console.WriteLine("我是动物，我每顿都要吃饭!");
    }
    public virtual void Run(){
        Console.WriteLine("我是动物，我每天都要跑步!");
    }
}
//子类：狗类
public class Dog：Animal{
    //这个Eat()重写了父类的函数体
    public override void Eat(){
        Console.WriteLine("我是狗，我每顿都吃骨头!");
    }
    //这个Run()因为加了new，所以不会报警告
     public new void Run(){
        Console.WriteLine("我是狗，我跑一千米都不会丢!");
    }
}
###  main函数  ####
public static void Main(string[] args){
    Animal animal2 = new Animal();//实例化一个动物类对象
    Dog  dog2 = new Dog();//实例化一个狗类对象
    Animal animalDog2 = new Dog();//使用子类实例化祖父类（需要注意）

    animal2.Eat();//输出：我是动物，我每顿都要吃饭!
    animal2.Run();//输出：我是动物，我每天都要跑步!

    dog2.Eat();//输出：我是狗，我每顿都吃骨头!
    dog2.Run();//输出：我是狗，我跑一千米都不会丢!!

    animalDog2.Eat();//输出：我是狗，我每顿都吃骨头!（实现子类方法体）
    animalDog2.Run();//输出：我是动物，我每天都要跑步!（实现父类自己的函数体）
    Console.ReadKey();
}

分析：

1.（1）父类方法没有声明virtual，子类方法声明override是错误的；（2）父类方法声明了virtual，子类方法可以声明new也可以声明override。
2.当子类使用override重写父类方法时，在用子类实例化的父类中，父类调用自己的virtual方法时，实现的子类重写的方法体，而如果子类是用new的话，那么父类调用自己的virtual的还是自己原来的方法体。

3.三级继承

//父类：动物类
public class Animal{
    public virtual void Eat(){
        Console.WriteLine("我是动物，我每顿都要吃饭!");
    }
    public virtual void Run(){
        Console.WriteLine("我是动物，我每天都要跑步!");
    }
}
//子类：狗类
public class Dog：Animal{
    //这个Eat()在编译器中会显示下划线，表示警告
    public override void Eat(){
        Console.WriteLine("我是狗，我每顿都吃骨头!");
    }
    //这个Run()因为加了new，所以不会报警告
     public new void Run(){
        Console.WriteLine("我是狗，我跑一千米都不会丢!");
    }
}
//孙子类：泰迪
public class TaidiDog：Dog{
    //这个Eat()在编译器中会显示下划线，表示警告
    public new void Eat(){
        Console.WriteLine("我是泰迪狗，我每顿都吃许多肾宝片!");
    }
    //这个Run()因为父类是new，所以会报错！！！！
     public override void Run(){
        Console.WriteLine("我是泰迪狗，我腿很短，所以我的频率很快!");
    }
}
###  main函数  ####
public static void Main(string[] args){
    Animal animal3 = new Animal();//实例化一个动物类对象
    Dog  dog3 = new Dog();//实例化一个狗类对象
    Animal animalDog3 = new Dog();//使用子类实例化父类（需要注意）
    Animal animalTaidiDog3 = new TaidiDog();//使用子类实例化父类（需要注意）

    animal3.Eat();//输出：我是动物，我每顿都要吃饭!
    animal3.Run();//输出：我是动物，我每天都要跑步!

    dog3.Eat();//输出：我是狗，我每顿都吃骨头!
    dog3.Run();//输出：我是狗，我跑一千米都不会丢!

    animalDog3.Eat();//输出：我是狗，我每顿都吃骨头!
    animalDog3.Run(); //输出：我是动物，我每天都要跑步!

    animalTaidiDog3.Eat();//输出：我是狗，我每顿都吃骨头!（泰迪类没有重写，但是其父类狗类重写了这个函数体，所以此处调用的狗类的函数体）
    animalTaidiDog3.Run();//报错（因为泰迪类的父类狗类这个函数是new，没有virtual，所以泰迪类使用virtual会报错）

    Console.ReadKey();
}