在 C# 中重写

C# 中的重写是在派生类中重新实现基类方法。在此，基类方法在子类中被重写。派生类方法与基类方法具有相同的名称和签名。重写对于实现运行时多态性很有用。

方法重写中使用了一些关键字。

1。 Virtual – 该关键字与基类一起使用，表示基类的方法可以被重写。

public virtual void Method()
{
// implementation
}

2。 Override – 此关键字与派生类一起使用，表示派生类重写基类的方法。

public override void Method()
{
// implementation
}

3。 Base – 该关键字在派生类中用于调用基类方法。

public override void Method()
{
base.Method();
// implementation
}

C# 中的重写是如何工作的？

下面是我们如何在 C# 中实现重写的示例。

class Parent
{
public virtual void Demo()  // base class
{
Console.WriteLine(“This is parent”);
}
}
class Child: Parent
{
public override void Demo()  // derived class
{
Console.WriteLine(“This is child”);
}
}

在上面的例子中有两个类，一个是基类或父类，另一个是派生类，或者我们可以说，子类。子类中派生出基类方法。在这种情况下，父类中的方法是虚拟的，这意味着它可以被子类覆盖。在子类中重写意味着该方法与具有相同方法签名的父类方法相同。

C# 中的重写类型

下面是显示使用各种关键字覆盖的示例。

示例 1 – 没有 Virtual 和 Override 关键字

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird   // base class
{
public void fly()  // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird   // derived class
{
public new void fly()  // derived class method
{
Console.WriteLine("Peacock is flying");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Bird b = new Peacock();
b.fly();
Console.ReadLine();
}
}
}

在上面的示例中，基类方法和派生方法均未使用关键字。

同样在main方法中，父引用用于调用子方法。因此，在这种情况下，当不使用关键字时，将调用父方法而不是子方法。所以输出将是

输出：

示例 2 (a)- 使用 Virtual 和 Override 关键字

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird   // base class
{
public virtual void fly()   // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird   // derived class
{
public override void fly()   // derived class method
{
Console.WriteLine("Peacock is flying");
}
}
class Program
{
// main method
static void Main(string[] args)
{
Bird b = new Peacock();
b.fly();
Console.ReadLine();
}
}
}

在这个例子中，基类中使用了virtual，这意味着它赋予子类以自己的方式实现方法的权限。在派生类中，使用重写，这意味着子方法是重写方法。两种方法具有相同的名称和相同的方法签名，但实现部分不同。在此示例中，父引用也用于调用子方法。但由于父方法是虚拟的，因此首先调用子方法而不是父方法。所以输出将是

输出：

示例 2 (b) – Virtual 和 Override 关键字

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird  // base class
{
public virtual void fly()   // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird   // derived class
{
public override void fly()  // derived class method
{
Console.WriteLine("Peacock is flying");
}
}
class Program
{
//main method
static void Main(string[] args)
{
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
}
}
}

此示例与上一个示例相同，但此子方法仅供参考。

输出：

示例 3 – 使用基本关键字

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
class Bird  // base class
{
public virtual void fly()  // base class method
{
Console.WriteLine("Birds are flying");
}
}
class Peacock : Bird  // derived class
{
public override void fly()  // derived class method
{
base.fly();  // base is use to call parent method
Console.WriteLine("Peacock is flying");
}
}
class Program
{
static void Main(string[] args)
{
Peacock p = new Peacock();
p.fly();
Console.ReadLine();
}
}
}

上面的例子中，在派生类中使用了基类来调用基类的方法。因此，在此基础方法中首先调用，然后调用派生方法。

输出：

示例 4 – 具有重写的抽象类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Overriding
{
abstract class Calculate
{
public abstract int sum();
}
class Values : Calculate // derived class
{
int val1;
int val2;
public Values(int a = 0, int b = 0)
{
val1 = a;
val2 = b;
}
public override int sum()
{
Console.WriteLine("sum of two values");
return (val1 + val2);
}
}
class Program
{
static void Main(string[] args)
{
Values v = new Values(10, 20);
int a = v.sum();
Console.WriteLine(a);
Console.ReadLine();
}
}
}

在上面的例子中，使用了抽象方法。抽象类由包含抽象方法的派生类实现。

输出：

方法重写规则

• 派生类的方法签名应与基类相同。
• 在同一个类中不可能覆盖。
• 虚拟方法和重写方法的访问修饰符必须相同。
• virtual 关键字用于基类方法，Override 用于派生类方法。
• 基类方法不应该是静态的。

结论

重写在运行时多态性中很有用。它允许派生类以自己的方式实现基类方法。因此派生类与其基类的方法实现是不同的。重写的方法可以是虚拟的、重写的或抽象的。

以上是在 C# 中重写的详细内容。更多信息请关注PHP中文网其他相关文章！