是否可以重写同一类(不是派生类)中基类中的方法

本文关键字：派生 基类 方法 重写 是否 一类 | 更新日期: 2023-09-27 17:58:48

我的理解是，可以使用关键字override从派生类重写基类中的方法（标记为Virtual）。

但是重写同一类中的方法呢

在我的特定情况下，我有一个类x，它有两个方法。方法a与b有一些共同的行为，而b为方法a添加了功能。

过去，我在b中复制了a的代码，并在b中添加了新功能。

我想知道是否有更好的方法可以集中方法a的行为。

    public class x
    {
       public static void a() {}
       public static void b() {}         
    }

是否可以重写同一类(不是派生类)中基类中的方法

您可以简单地从方法b()中调用方法a()。不需要（也没有办法）重写方法。

public class x
{
   private static int _i = 0;
   public static void a() {
       _i = 1;
   }
   public static void b() {
       a();
       // here is _i = 1;
   }         
}

另一方面，您的方法可能存在参数重载。

public class x
{
   private static int _i = 0;
   public static void a() {
       a(1);
   }
   public static void a(int i) {
      _i = t;
      // common code which can use _i
   }         
}

在这种情况下，您可以调用a(1)或a()以获得相同的结果。

不能在同一个类中重写，只能在派生类中重写。您可以将方法的常见行为放在方法a中，然后从方法b调用它。

public static void a() 
{
// some common functionality
}
public static void b()
{
// do something
a(); //call a
//do something else
}

您可以根据需要多次从b内部调用a。

据我所知，可以使用关键字Override从派生类重写基类中的方法（标记为Virtual）。但是，同一个类中的同一个重写方法呢？

你不能这样做。虚拟方法用于多态性，这是一种奇特的说法：

如果您编写了一个方法，该方法接受基类，并将派生类传递给它，并且该方法调用基类上的方法，则它将实际调用派生实现。

class A
{
    public virtual void DoSomething() { Console.WriteLine("From A"); }
}
class B : A
{
    public override void DoSomething() { Console.WriteLine("From B"); }
}
class C
{
    public void DoSomethingMagic(A someClassInstance)
    {
        someClassInstance.DoSomething();
    }
}
class Program
{
    public static void Main(string[] args)
    {
        A a = new A();
        B b = new B();
        C c = new C();
        c.DoSomethingMagic(a); // Prints "From A"
        c.DoSomethingMagic(b); // Prints "From B", even though it takes an A
        A bIsAnA = new B();
        c.DoSomethingMagic(bIsAnA); // Prints "From B", because B is also an A
    }
}

有了这个定义，试图在同一个类中"重写"一个方法是没有意义的。

在我的特定情况下，我有一个带有2个方法的x类，方法a是与b的一些常见行为，b为方法a添加了功能。

只需从b():呼叫a()

public class x
{
   public static void a()
   {
       // "base" implementation here
   }
   public static void b()
   {
       a();
       // extra implementation here
   }
}

为什么不直接从b()调用a()？

public static void b()
{
    // Do some stuff
    a(); // Do the common stuff
    // Do more stuff
}

您将公共部分拆分为第三个共享但私有的方法。

如果我理解正确的话，你的问题是方法b与方法a有相同的代码加上更多的代码。类似的东西

public class x
{
    public void a()
    {
        // a code
    }
    public void b()
    {
        // a code
        // b code
    }
}

如果是这样的话，你可以调用方法b中的方法a，比如这个

class x
{
    public void a()
    {
        // a code
    }
    public void b()
    {
        a();
        // b code
    }
}

另一种情况是，两种方法都有通用代码：

class x
{
    public void a()
    {
        // common code
        // a exclusive code
    }
    public void b()
    {
        // common code
        // b exclusive code
    }
}

然后你可以将代码提取到另一种方法中，比如

class x
{
    public void a()
    {
        CommonMethod();
        // a exclusive code
    }
    public void b()
    {
        CommonMethod();
        // b exclusive code
    }
    private void CommonMethod()
    {
        // common code
    }
}

以及关于重写同一类中的方法。它被称为方法重载，但它允许您创建几个具有相同名称的方法，这些方法在输入类型方面彼此不同。

像这个

class x
{
    public string a(int i)
    {
    }
    public string a(string s)
    {
    }
}

唯一的限制是方法必须具有相同的返回类型（本例中为字符串）。

相关文章：