这里有一种情况，肯定需要继承静态字段和方法:

abstract class Animal
{
  protected static string[] legs;

  static Animal() {
    legs=new string[0];
  }

  public static void printLegs()
  {
    foreach (string leg in legs) {
      print(leg);
    }
  }
}


class Human: Animal
{
  static Human() {
    legs=new string[] {"left leg", "right leg"};
  }
}


class Dog: Animal
{
  static Dog() {
    legs=new string[] {"left foreleg", "right foreleg", "left hindleg", "right hindleg"};
  }
}


public static void main() {
  Dog.printLegs();
  Human.printLegs();
}


//what is the output?
//does each subclass get its own copy of the array "legs"?

我们实际上重写了静态方法(在delphi中)，这有点丑，但它很好地满足了我们的需求。

我们使用它，所以类可以有一个可用对象的列表，而不需要类实例，例如，我们有一个方法看起来像这样:

class function AvailableObjects: string; override;
begin
  Result := 'Object1, Object2';
end; 

它很丑，但却是必要的，这样我们就可以实例化需要的东西，而不是为了搜索可用的对象而对所有的类进行实例化。

这是一个简单的例子，但应用程序本身是一个客户机-服务器应用程序，它在一个服务器上拥有所有可用的类，而多个不同的客户机可能不需要服务器拥有的所有东西，也永远不需要对象实例。

因此，这比为每个客户机使用一个不同的服务器应用程序要容易得多。

希望这个例子很清楚。

另一位受访者(McDowell)说多态性只适用于对象实例。应该是有资格的;有些语言确实将类视为“类”或“元类”类型的实例。这些语言确实支持实例和类(静态)方法的多态性。

c#，就像之前的Java和c++一样，不是这样一种语言;static关键字显式地用于表示该方法是静态绑定的，而不是动态/虚拟的。

抽象方法是隐式虚拟的。抽象方法需要实例，但静态方法没有实例。所以，你可以在一个抽象类中有一个静态方法，它只是不能是静态的抽象(或抽象的静态)。

静态方法不能被继承或重写，这就是为什么它们不能是抽象的。因为静态方法是在类的类型上定义的，而不是在类的实例上，所以必须在该类型上显式地调用它们。所以当你想要在子类上调用一个方法时，你需要使用它的名字来调用它。这使得继承无关紧要。

假设您可以暂时继承静态方法。想象一下这个场景:

public static class Base
{
    public static virtual int GetNumber() { return 5; }
}

public static class Child1 : Base
{
    public static override int GetNumber() { return 1; }
}

public static class Child2 : Base
{
    public static override int GetNumber() { return 2; }
}

如果调用Base.GetNumber()，将调用哪个方法?返回哪个值?很容易看出，如果不创建对象的实例，继承是相当困难的。没有继承的抽象方法只是没有主体的方法，因此不能被调用。

它目前作为预览特性在c# 10中可用。