虚方法与隐藏方法

虚⽅法

把⼀个基类函数声明为virtual,就可以在任何派⽣类中重写该函数:

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

在派⽣类中重写另外⼀个函数时，要使⽤override关键字显⽰声明

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

示例代码

c#
// Enemy.cs 基类
    class Enemy
    {
        public virtual void Move()
        {
            Console.WriteLine("敌人进行移动");
        }
    }

c#
// Boss.cs 派生类
    class Boss:Enemy
    {
        public override void Move()
        {
            Console.WriteLine("Boss特有的移动方法");
        }

        public void BossSkill()
        {
            
            Console.WriteLine("Boss特有的技能");
        }
    }

c#
// Program.cs 使用
            Boss b = new Boss();
            b.Move();
            
            //虚函数
            Enemy b2 = new Boss();
            b2.Move();

隐藏⽅法

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

基类

c#
class MyBaseClass{
public int MyMethod(){
}
}

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

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

示例代码

c#
// Enemy.cs 基类
    class Enemy
    {
        public void AI()
        {
            Console.WriteLine("敌人的AI");
        }
    }

c#
// Boss.cs 派生类
    class Boss:Enemy
    {
        public new void AI()
        {
            Console.WriteLine("Boss自己的AI");
        }
    }

c#
// Program.cs 使用
            Boss b = new Boss();
            b.AI();

            Enemy b = new Boss();
            b.AI();

抽象类

C#允许把类和函数声明为 abstract。 抽象类不能实例化,抽象类可以包含普通函数和抽象函数，抽象函数就是只有函数定义没有函数体。显然,抽象函数本⾝也是虚拟的Virtual(只有函数定义，没有函数体实现)。
类是⼀个模板，那么抽象类就是⼀个不完整的模板，我们不能使⽤不完整的模板去构造对象。

c#
abstract class Building{
public abstract decimal CalculateHeatingCost();
}

示例代码

c#
// Enemy.cs 抽象类
    public abstract class Enemy
    {
        private int hp;
        private int speed;

        public void Move()
        {
            Console.WriteLine("Move");
        }
        public abstract void Attack();

    }

c#
// Boss.cs 派生类
    public class Boss : Enemy  //光标定位到这一行，右键 💡 实现抽象类
    {
        public override void Attack()
        {
            Console.WriteLine("Boss进行攻击");
        }
    }

c#
// Program.cs 使用
            Enemy e = new Boss();
            e.Attack();

密封类和密封⽅法

C#允许把类和⽅法声明为 sealed。对于类 ,这表⽰不能继承该类；对于⽅法表⽰不能重写该⽅法。

c#
sealed FinalClass
{
// etc
}

什么时候使⽤密封类和密封⽅法？

防⽌重写某些类导致代码混乱
商业原因

派⽣类（⼦类）的构造函数

1,在⼦类中调⽤⽗类的默认构造函数（⽆参）（会先调⽤⽗类的，然后是⼦类的）

c#
public class MyDerivedClass{
public MyDerivedClass():base(){
//do something
}
}

在这⾥：base()可以直接不写，因为默认会调⽤⽗类中的默认构造函数

2，调⽤有参数的构造函数

c#
public class MyDerivedClass{
public MyDerivedClass(string name):base(name){
//do something
}
}

示例代码

c#
// BaseClass.cs 父类
    class BaseClass
    {
        private int hp;
        private int speed=900;

        public BaseClass(int hp, int speed)
        {
            this.hp = hp;
            this.speed = speed;
        }
        
        public BaseClass()
        {
            Console.WriteLine("构造函数：BaseClass");
        }
    }

c#
// DrivedClass.cs 子类
    class DrivedClass:BaseClass
    {
        private int attack;

        public DrivedClass()
        {
            Console.WriteLine("构造函数：DrivedClass");
        }

        public DrivedClass(int attack)
        {
            this.attack = attack;
        }
        public DrivedClass(int attack,int hp,int speed):base(hp,speed)
        {
            this.attack = attack;
        }
    }

c#
// Program.cs 使用
            DrivedClass dc = new DrivedClass(100,80,10);
            Boss b = new Boss();

            // 1、添加别的项目的引用 using System.Collections.Generic;
            // 2、引入命名空间  
            // 3、把类设置为public

目录

虚⽅法

隐藏⽅法

抽象类

密封类和密封⽅法

派⽣类（⼦类）的构造函数