C# 中什么是重写（子类改写父类方法）

方法重写是指在继承关系中，子类重新实现父类或基类的某个方法。这种方法允许子类根据需要修改或扩展父类或基类的方法功能。在面向对象编程中，方法重写是一种多态的表现形式，它使得子类可以根据不同的需求和场景提供不同的方法实现。

方法重写的基本规则如下：

1. 方法重写要求子类中的方法与父类或基类中的方法具有相同的方法名、返回类型和参数列表。
2. 方法重写中的方法可以有不同的实现逻辑，但方法名、返回类型和参数列表必须与父类或基类中的方法保持一致。
3. 方法重写只能在子类中进行，不能在父类或基类中进行。

在C#中，override 是一个关键字，用于在子类中重写（覆盖）父类中已有的虚拟方法、属性或索引器。

当一个方法、属性或索引器被声明为 virtual 时，它允许子类通过 override 关键字来提供自己的实现版本。通过重写父类的成员，子类可以修改或扩展继承的行为，以满足自身的需求。

下面是使用 override 的一个简单示例：

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("我是动物。");
    }
}
 
public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("我是一只猫咪，喵喵喵~");
    }
}

在这个示例中，Animal 类中的 Speak() 方法被声明为 virtual，表示它可以被子类重写。Cat 类继承了 Animal 类，并使用 override 关键字重写了父类的 Speak() 方法。

通过使用 override，Cat 类提供了自己的 Speak() 方法实现。当我们实例化 Cat 对象并调用 Speak() 方法时，会执行子类重写后的方法，输出 "我是一只猫咪，喵喵喵~"。

总结起来，override 关键字用于在子类中重写（覆盖）父类中已有的虚拟方法、属性或索引器。它允许子类根据自身需要修改或扩展继承的成员的行为。通过使用 virtual 和 override，可以实现多态性，在运行时根据对象的实际类型调用相应的重写版本。

其他案例

class Animal {  
   void makeSound() {  
       System.out.println("The animal makes a sound");  
   }  
}
 
class Dog extends Animal {  
   @Override  
   void makeSound() {  
       System.out.println("The dog barks");  
   }  
}
 
public class Main {  
   public static void main(String[] args) {  
       Dog dog = new Dog();  
       dog.makeSound(); // 输出：The dog barks  
   }  
}

在这个示例中，Dog 类继承了 Animal 类，并重写了 makeSound() 方法。当创建一个 Dog 对象并调用 makeSound() 方法时，将执行 Dog 类中的方法实现，输出 "The dog barks"。

2.子类重写了父类的方法，子类的实例化对象在调用该方法输出子类方法结果

当子类重写了父类的方法后，子类的实例化对象在调用该方法名字时，将输出子类重写的新方法的结果。这是因为在 C# 中，方法重写遵循一种称为“动态绑定”的规则。

动态绑定是指在运行时，根据实际的对象类型来调用相应的方法。当子类实例化对象调用重写的方法时，实际上是在调用子类中的新方法。因此，输出的结果是子类重写的新方法的结果。

以下是一个简单的示例：

public class Animal {  
   public void MakeSound() {  
       Console.WriteLine("The animal makes a sound");  
   }  
}
 
public class Dog : Animal {  
   public override void MakeSound() {  
       Console.WriteLine("The dog barks");  
   }  
}
 
public class Main {  
   public static void Main() {  
       Dog dog = new Dog();  
       dog.MakeSound(); // 输出：The dog barks  
   }  
}

这个示例中，子类 Dog 重写了父类 Animal 的 MakeSound 方法。在 Main 类中，我们创建了一个 Dog 对象，并调用了其 MakeSound 方法。由于动态绑定的规则，调用的是子类中的新方法，因此输出的结果是 "The dog barks"。