学习与记录。

0%

C# 中的 abstract, virtual, override, new 关键字

发表于 更新于 分类于 Valine：

本文主要记录 C# 中 abstract, virtual, override, new 关键字作为方法的修饰符时的使用方法及其区别。

抽象方法 abstract

  1. 用 abstract 关键字进行修饰的方法称为抽象方法。
  2. 抽象方法不能有方法体。
  3. 子类中必须实现父类中的所有抽象方法。
  4. 抽象方法不能用 private 关键字进行修饰。
  5. 子类中实现的父类中的抽象方法要用 override 关键字进行修饰。

C# 中抽象方法的写法如下：

1
2
3
4
5
6
7
8
9
10
11
12
abstract class Father
{
    public abstract void AbstractMethod();
}

class Son : Father
{
    public override void AbstractMethod()
    {
        Console.WriteLine("Son's override method of Father's abstract method.");
    }
}

虚方法 virtual

  1. 用 virtual 关键字进行修饰的方法称为虚方法。
  2. 虚方法必须要有方法体。
  3. 派生类中不要求重写基类中的虚方法。
  4. 虚方法可以用 private 关键字进行修饰，但是一般不用，因为如果派生类无法访问虚方法的话，virtual 关键字就没有意义了。
  5. 派生类中重写的基类中的虚方法要用 override 关键字进行修饰。
  6. 派生类中重写的基类中的虚方法和基类中的虚方法必须具有相同的访问修饰符。

C# 中虚方法的写法如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Father
{
    public virtual void VirtualMethod()
    {
        Console.WriteLine("Father's virtual method.");
    }
}

class Son : Father
{
    public override void VirtualMethod()
    {
        Console.WriteLine("Son's override method of Father's virtual method.");
    }
}

纯虚函数

C# 中的纯虚函数

  1. 纯虚函数是 C++ 中的说法，C# 中没有纯虚函数的说法。
  2. C++ 中的纯虚函数在 C# 中以抽象方法的形式实现，即用 abstract 关键字进行修饰的方法。

C++ 中的纯虚函数

  1. 纯虚函数只有定义，没有实现。
  2. 派生类中必须要实现基类中的所有纯虚函数。

在 C++ 中纯虚函数的写法如下：

1
2
3
4
5
6
7
8
9
10
11
class Father
{
public:
	virtual void virtualFunction() = 0;
};

class Son :Father
{
public:
	void virtualFunction() { }
};

重写方法 override

  1. 对父类中的抽象方法的实现和对基类中的虚方法的重写都要用 override 关键字进行修饰。
  2. override 关键字不可与 new, static, abstract, virtual 关键字同时使用。

同名方法 new

  1. new 关键字可以在派生类中隐藏基类中的同名方法。
  2. 在调用派生类的同名方法时，调用的方法是使用 new 关键字定义的新方法，而不是基类的方法。
  3. 不使用 new 关键字来隐藏基类中的同名方法也是可以的，编译器会提示一个警告：如果是有意隐藏基类的方法，请使用 new 关键字进行修饰。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Father
{
    public void SameNameMethod()
    {
        Console.WriteLine("Father's method of the same name.");
    }
}

class Son : Father
{
    public new void SameNameMethod()
    {
        Console.WriteLine("Son's method of the same name.");
    }
}

总结

相同

  1. 对父类中的抽象方法的实现和对基类中的虚方法的重写都要用 override 关键字进行修饰。

不同

  1. 抽象方法不能有方法体，虚方法必须有方法体。
  2. 子类中必须实现父类的所有抽象方法，派生类中不要求实现基类的虚方法。
  3. 抽象方法不能用 private 关键字进行修饰，虚方法可以用但是一般不用。
  4. 在派生类中对基类中的 virtual 方法使用 new 和 override 关键字进行重写的机理不同。