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# 中实现重写的示例。
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”);
}
}在上面的例子中有两个类，一个是基类或父类，另一个是派生类，或者我们可以说，子类。子类中派生出基类方法。在这种情况下，父类中的方法是虚拟的，这意味着它可以被子类覆盖。在子类中重写意味着该方法与具有相同方法签名的父类方法相同。
下面是显示使用各种关键字覆盖的示例。
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方法中，父引用用于调用子方法。因此，在这种情况下，当不使用关键字时，将调用父方法而不是子方法。所以输出将是
输出：
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，这意味着它赋予子类以自己的方式实现方法的权限。在派生类中，使用重写，这意味着子方法是重写方法。两种方法具有相同的名称和相同的方法签名，但实现部分不同。在此示例中，父引用也用于调用子方法。但由于父方法是虚拟的，因此首先调用子方法而不是父方法。所以输出将是
输出：
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();
}
}
}此示例与上一个示例相同，但此子方法仅供参考。
输出：
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();
}
}
}上面的例子中，在派生类中使用了基类来调用基类的方法。因此，在此基础方法中首先调用，然后调用派生方法。
输出：
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();
}
}
}在上面的例子中，使用了抽象方法。抽象类由包含抽象方法的派生类实现。
输出：
重写在运行时多态性中很有用。它允许派生类以自己的方式实现基类方法。因此派生类与其基类的方法实现是不同的。重写的方法可以是虚拟的、重写的或抽象的。
以上是在 C# 中重写的详细内容。更多信息请关注PHP中文网其他相关文章！
