Question

我最近做过的关于C＃MTA考试的问题引起了大量讨论：

您有一个名为Glass的类，它继承自名为Window的基类。 Window类包含一个名为break（）的受保护方法。

你应该如何调用break（）方法的Glass类实现？

一个。 Window.break（）;
B. Glass.break（）;
C. this.break（）;
D. base.break（）;

有人能给我一个坚实的答案和合理的理由吗？

Answer 1

我只需调用Break();即可，只要Break()方法未声明为virtual（这样就可以覆盖它）。使用this或base进行呼叫简直是多余的。

但是，假设Break()将被声明为虚拟，那么如果您想要在Window类（Break()）上调用base.Break()的实现，那么就是这个问题。在Glass类（Break() / this.Break()）上。

考虑以下代码

public class Window
{
    public virtual void Break()
    {
        Console.WriteLine("Break in window called");
    }
}

public class Glass : Window
{
    public override void Break()
    {
        Console.WriteLine("Break in Glass called");
    }

    public void DoSomething()
    {
        Break();
        this.Break(); // Same as above line
        base.Break();
    }
}

在DoSomething()的实例上调用Glass时的输出将是

Break in Glass called
Break in Glass called
Break in window called

Answer 2

<强>问题：

你应该如何调用break（）方法的Glass类实现？

示例

在此示例中，他们有一个名为Glass的类。此类有一个名为Break()的方法，它来自基类Window。

他们希望您在Glass class ＆＃34;中调用已实现的方法调用break（）方法的Glass类实现＆＃34;

要创建自己版本的基类方法，您需要使其成为可写的。为此，将虚拟添加到基类方法，并在派生类Glass中添加覆盖以覆盖该基类方法。]

接下来，您可以调用派生方法和基本方法的不同版本的方法。有关详细信息，请参阅示例

此示例如下所示：

class Window { public virtual void Break() { // break method from the window class } } class Glass : Window { public override void Break() { // This method comes from the base class Window. You want to override this one. They ask you to call this method. //To call the Break() mehod from Window: base.Break(); // Call the Break() method from the current instance this.Break() Break(); } }

<强>答案：

这个答案是正确的，因为这个答案从Glass class Break() method（参见示例）
调用当前实例
C：this.break（）;

其他答案：

Break()不是静态的，因为这没有任何意义，在这个问题上不能保持静态。他们希望Glass继承Window并想要调用Glass类的Break()版本。您需要覆盖Glass类中的Break()以创建该方法的自有版本，因此您需要添加虚拟和覆盖，并且不能使虚拟/覆盖方法成为静态。因为前两个答案是不正确的

一个Window.Break（）

这将从Window类调用静态Break（）方法。（在这个例子中没有使用静态，这不是答案）

B Glass.Break（）

这将从类中调用静态Break（）方法。（在这个例子中不使用static，这不是anwer）

C this.Break（）

这将调用当前实例Break（）方法（参见示例）。

D base.Break（）

这将从基类Window的当前实例调用Break（）方法。

Answer 3

B。 Glass.break（）;

在任务的调用位置未指定它，因此，由于应该只有1个正确的解决方案，因此唯一的逻辑方法是假定可以从任何地方调用它。因此，如果我们将 break（）实现为 public static 方法，则可以从任何地方调用它，并且 B 是唯一的逻辑和可能的答案。

using System;
public class Window{
    protected void break1() {Console.Write("1");}
    public Window(){
        Glass.break1();
    }
}
public class Glass : Window{
    public static void break1() {Console.Write("2");}
    public Glass() {
        Glass.break1();
    }
}
public class Dijete : Glass{
    public Dijete() {
        Glass.break1();
    }
}
public class Program
{
    public static void Main()
    {
        Glass.break1();
    }
}

如果我错了，请更正我的逻辑，但是在转储中我也发现B是正确答案。

PS：我将其称为break1，因为将其命名为break（）无效，这实际上使整个任务变得毫无意义。

来自MTA的C＃继承讨论

3 个答案: