SIKI学习——C#中级教程_08虚方法

最新推荐文章于 2019-04-30 15:26:45 发布

原创最新推荐文章于 2019-04-30 15:26:45 发布 · 177 阅读

0 ·

CC 4.0 BY-SA版权

siki中级教程专栏收录该内容

14 篇文章

订阅专栏

本文详细介绍了C#中的虚方法（虚函数），包括如何声明和重写虚方法。此外，还讲解了隐藏方法的概念，即在派生类中不使用override而是使用new关键字来隐藏基类方法。最后，探讨了this和base关键字的用途，它们分别用于访问当前类的成员和父类的成员。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

1.虚方法(也叫虚函数)

1.虚方法
把一个基类函数声明为virtual,就可以在任何派生类中重写该函数:

 class MyBaseClass
 {
 	 public virtual string VirtualMethod()
 	 {
  		 return "Method is called in base class";
  	}
 }

在派生类中重写另外一个函数时，要使用override关键字显示声明

class MyDerivedClass:MyBaseClass
 { 
 	 public override string VirtualMethod()
 	 {
  		 return "Method is called in derivedclass.";
  	}
 }

我们在子类里面重写虚函数之后，不管在哪里调用都是调用重写之后的方法

namespace 面向对象编程_继承
{
    class Enemy
    {
        private float hp;
        private float speed;
        public float HP 
        {
            get { return hp; }
            set { hp = value; }
        }
        public float Speed
        {
            get { return speed; }
            set { speed = value; }
        }
        public void AI()
        {
            Move();
            Console.WriteLine("这里是enemy1的共有Ai方法");
        }
        public virtual void Move()//将方法声明，此时是一个虚函数
        {
            Console.WriteLine("这里是enemy1共有的move方法");
        }
    }
}

namespace 面向对象编程_继承
{
    class Boss : Enemy
    {
        public override void Move()
        {
            Console.WriteLine("这里是Boss的移动方法");
        }
        public void Attack()
        {
            //AI();
            //Move();
            ////hP = 100;//这个调用不到
            //HP = 100;//父类里面共有的数据和函数成员才可以在子类里面访问
            Move();
            Console.WriteLine("Boss正在进行攻击");
        }
    }
}

namespace 面向对象编程_继承
{
    class Program
    {
        static void Main(string[] args)
        {
            //Boss boss = new Boss();
            //boss.AI();//继承：父类里面所有的数据成员和函数成员都会继承到子类里面
            //boss.Attack();
            
            //Enemy enemy;
            //enemy = new Boss();//父类声明的对象，可以使用子类去构造 子类声明的对象不可以使用父类构造
            ////enemy虽然使用父类进行了声明，但是使用了子类构造，所以本质上是一个子类类型的，我们可以强制类型转换成子类类型
            //Boss boss = (Boss)enemy;
            //boss.Attack();

            //Enemy enemy = new Enemy();
            //Boss boss = (Boss)enemy;//（不能进行强制转换）一个对象是什么类型的 主要看它是通过什么构造的，这里enemy是用来父类的构造函数，所以只有父类中的字段和方法，不能强制转换成子类

          //Boss boss = new Boss();
            ////boss.Attack();显示写的Move方法
            //boss.AI();
            
            Enemy enemy = new Enemy();
            enemy.AI();//只有当我们用子类去调用的时候，才能调用重写的，这里调用的还是父类中的方法
            Console.ReadKey();
        }
    }
}

2.隐藏方法

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

class MyBaseClass
{
  public int MyMethod()
  {
  }
}

派生类(在派生类中把基类同名的方法隐藏掉了)

class MyDerivedClass :MyBaseClass
{
	public new void MyMethod()
	{
	}
}

namespace 面向对象编程_继承
{
    class Enemy
    {
        private float hp;
        private float speed;
        public float HP 
        {
            get { return hp; }
            set { hp = value; }
        }
        public float Speed
        {
            get { return speed; }
            set { speed = value; }
        }
        public void AI()
        {
            //Move();
            Console.WriteLine("这里是enemy1的共有Ai方法");
        }
        //public virtual void Move()//将方法声明，此时是一个虚函数
        //{
        //    Console.WriteLine("这里是enemy1共有的move方法");
        //}
        public void Move()
        {
            Console.WriteLine("这里是enemy1共有的move方法");
        }
    }
}

namespace 面向对象编程_继承
{
    class Boss : Enemy
    {
        //public override void Move()//重写：原来的方法不存在了
        //{
        //    Console.WriteLine("这里是Boss的移动方法");
        //}
        public new void Move()//（父类里的Move方法是隐藏方法 ）当子类里面有一个签名和父类相同的方法的时候，就会把父类中的方法隐藏。
        {//隐藏：只是把父类中的方法隐藏了，看不到了，实际这个方法还存在
            Console.WriteLine("这里是Boss的移动方法");
        }
        public void Attack()
        {
            //AI();
            //Move();
            ////hP = 100;//这个调用不到
            //HP = 100;//父类里面共有的数据和函数成员才可以在子类里面访问
            Move();
            Console.WriteLine("Boss正在进行攻击");
        }
    }
}

 class Program
    {
        static void Main(string[] args)
        {
            //Boss boss = new Boss();
            //boss.AI();//继承：父类里面所有的数据成员和函数成员都会继承到子类里面
            //boss.Attack();
            
            //Enemy enemy;
            //enemy = new Boss();//父类声明的对象，可以使用子类去构造 子类声明的对象不可以使用父类构造
            ////enemy虽然使用父类进行了声明，但是使用了子类构造，所以本质上是一个子类类型的，我们可以强制类型转换成子类类型
            //Boss boss = (Boss)enemy;
            //boss.Attack();
            
            //Enemy enemy = new Enemy();
            //Boss boss = (Boss)enemy;//（不能进行强制转换）一个对象是什么类型的 主要看它是通过什么构造的，这里enemy是用来父类的构造函数，所以只有父类中的字段和方法，不能强制转换成子类
            
            //Boss boss = new Boss();
            ////boss.Attack();显示写的Move方法
            //boss.AI();
            
            //Enemy enemy = new Enemy();
            //enemy.AI();//只有当我们用子类去调用的时候，才能调用重写的，这里调用的还是父类中的方法
            
            Enemy boss = new Boss();
            boss.Move();//隐藏方法：如果使用子类声明的对象，调用隐藏方法会调用子类的，如果使用父类声明对象，那么就会调用父类中的隐藏方法。
            
            Console.ReadKey();
        }
    }
}

3.this和base关键字的作用

this可以访问当前类中定义的字段,属性和方法，有没有this都可以访问，有this可以让IDE-VS编译器给出提示，另外当方法的参数跟字段重名的时候，使用this可以表明访问的是类中的字段，base可以调用父类中的公有方法和字段,有没有base都可以访问，但是加上base.IDE工具会给出提示，把所有可以调用的字段和方法罗列出来方便选择。