Question

我有这段代码：

class Super{ 
   public static List<Super> methodA() { . . . }
}
class Sub:Super{ 
   public static List<Sub> methodA() { . . . }
}

然后我打电话给：

 Sub.methodA();

但执行的是来自超级。无论如何，我可以执行子类的静态方法？它们具有相同的静态方法名称。

更新：您可以看到Product是我的超类，purchase是子类。两者都具有相同的静态getAll（）但返回了不同的类型。在这种情况下，它返回List

Answer 1

在超类中提供的子类中使用相同的方法名称，您必须覆盖它 - 但是C＃中的静态方法是不可能的。

请看一下这篇文章，它提供了很好的内容：

http://blogs.msdn.com/b/kirillosenkov/archive/2008/02/06/how-to-override-static-methods.aspx

Answer 2

子类中的

methodA将隐藏基类中的方法。因此Sub.methodA将调用 sub 类中的方法，而不是基类。

Sub.MethodA（）'隐藏继承的成员'Super.MethodA（）'。如果想要隐藏，请使用new关键字。

Answer 3

Super.methodA();将从任何地方调用超级静态方法......来自超类，子类，外部两个类等等。

Sub.methodA();会从任何地方调用子方法的静态方法......

这是我的测试代码：

class Program
{
    class Super
    {
        public static List<Super> methodA() { Console.WriteLine("SUPER"); return new List<Super>(); }

        public void callSuper()
        {
            Super.methodA();
        }

        public void callSub()
        {
            Sub.methodA();
        }
    }
    class Sub : Super
    {
        public static List<Sub> methodA() { Console.WriteLine("SUB"); return new List<Sub>(); }

        public void callSuper()
        {
            Super.methodA();
        }

        public void callSub()
        {
            Sub.methodA();
        }
    }

    static void Main(string[] args)
    {
        Super.methodA();

        Sub.methodA();

        var s = new Sub();
        s.callSuper();
        s.callSub();

        var Sup = new Super();
        Sup.callSuper();
        Sup.callSub();

        Console.ReadLine();
    }
}

Answer 4

这可以按预期工作，请参阅以下示例（runnable）。在示例代码和真实代码之间出现了一些问题。

public class Program
{
    public static void Main()
    {
        Console.WriteLine(Sub.methodA());
        Console.WriteLine(Super.methodA());
    }
}
class Super{ 
   public static List<Super> methodA() { return new List<Super>(); }
}
class Sub:Super{ 
   public new static List<Sub> methodA() { return new List<Sub>(); }
}

Answer 5

只需使用类型名称调用它们：

 Sub.methodA();
 Super.methodA();

静态方法仅适用于声明它的类。它不能被继承，也不能在类的实例上调用。

class Super
{
    public static char methodA() 
    {
        return 'a'; 
    }
}
class Sub : Super
{
    public static char methodA() 
    {
        return 'b'; 
    }
}

class Program
{
    static void Main(string[] args)
    {
        var res = Sub.methodA();
        var res2 = Super.methodA();

        Console.WriteLine(res == res2);

        Console.ReadKey();
}

输出：false

Answer 6

这被称为＆＃34;隐藏＆＃34;而不是＆＃34;覆盖＆＃34;。虽然不推荐，但确实有效。如果调用Super.MethodA，它将在基类上运行该方法。如果运行Sub.MethodA，它将在派生类中运行该方法。我刚刚证实这是100％肯定的。

您可能想在此重新考虑您的设计。如果这个想法只是为了让某人能够获得你的对象列表，而不必每次都要上新课，那么有很多不同的方法可以做到这一点，不需要隐藏。一些实现细节可能有助于我们建议一种有效的方法。

C＃如何从子类

6 个答案: