Question

我没有完全理解使用Interfaces，所以我不得不问： - ）

我使用BaseClass，它实现了IBaseClass接口。这个接口只包含一个声明：

public interface IBaseClass
{
    void Refresh ();
}

所以我在我的Baseclass中实现了一个Refresh方法：

    public void Refresh ()
    {
        Console.WriteLine("Refresh");
    }

现在我想使用从这些Baseclass扩展并实现IBaseClass接口的一些类：

    public class ChildClass : BaseClass,IBaseClass
    {
    }

但是在我的BaseClass中实现“刷新”的原因我不必再次实现该方法。我应该怎么做，强制将“刷新”实现到BaseClass的所有子节点以及子类的所有子类中。

谢谢kooki

Answer 1

您不能强制派生类以您指定的方式重新实现该方法。您有三种选择：

不要在基类中定义refresh。该接口将强制子类实现它。
如果接口的唯一目的是强制实现并将基类声明为abstract以及refresh，则不要提供实现。>
将基类中的refresh定义为virtual。这允许覆盖但不会强制它们。这就是ToString()的工作原理。

这是假设您的基类大于单个方法。如果您的代码确实是您发布的内容，那么Oded的答案是最佳选择。

Answer 2

简单。不提供基类实现，您必须在每个继承类中实现该方法。

实现这一目标的一种方法是制作BaseClass abstract：

public abstract BaseClass : IBaseClass
{
    public abstract void Refresh();
}

Answer 3

我该怎么办，强制将“刷新”实施到BaseClass的所有子节点以及子类的所有子类中。

像这样：

interface IBase
{
    void Refresh();
}

abstract class BaseClass : IBase
{
    public abstract void Refresh();
}

class ChildClass : BaseClass
{
    public override void Refresh()
    {
        // Your code
    }
}

你甚至可以省略界面（我的经验法则：如果一个接口只由一个类实现，则转储接口。不要依赖于interfacitis。一个抽象类代表一个接口，另见{{ 3}}）。

如果确实需要基类中的实现，请按以下方式构建：

(abstract) class BaseClass ( : IBase)
{
    public virtual void Refresh()
    {
        // Your code
    }
}

然后您可以从派生类中调用它们：

public override void Refresh()
{
    // Your code

    // optionally, to call the base implementation:
    base.Refresh();
}

Answer 4

如果要提供默认实现，请在基类中通过将其标记为虚拟来执行，因此如果需要，可以在子类中覆盖该实现。

否则在基类中将方法标记为抽象，因此您的子类必须自己实现该方法。

Answer 5

让我们一步一步看看。

1：您有一个界面，用于定义您定义的代码协定：

public interface IBase
{
    void Refresh();
}

2：您有一个实现接口的基类。（你会注意到刷新的实现是virtual。这允许你在派生类中重写这个方法。）。

class Base : IBase
{
    public virtual void Refresh()
    {
        //Implementation
    }
}

3：你有一个派生自Base的超类。（您会注意到派生类不需要显式实现IBase，因为它是在较低级别完成的。我将告诉您可以测试此的完整性。）< / p>

class Child : Base
{
    public override void Refresh()
    {
        base.Refresh(); //You can call this here if you need to perform the super objects Refresh() before yor own.
        //Add your implementation here.
    }
}

此时你可能在想; “好的，那么Child如何实施IBase？”。答案是它是通过Base间接实现的，并且因为Child继承了Base，它也获得了IBase的实现。

因此，如果你要写：

IBase instance = new Child();

这是完全合法的，因为基本上Child间接来自IBase。

如果您想对此进行测试，可以在代码中执行此操作：

bool canAssign = typeof(IBase).IsAssignableFrom(typeof(Child));
//canAssign should be true as Child can be assigned from IBase.

Answer 6

可以新关键字可以帮助你;

namespace ConsoleApplication1
{
    interface IBase
    {
        void Referesh();
    }
    public class Base1 : IBase
    {
        public void Referesh()
        {
            Console.WriteLine("Hi"); 
        }
    }
    public class Class1 : Base1, IBase
    {
        public new void Referesh()
        {
            Console.WriteLine("Bye");
        }

    }
    class Program
    {
        static void Main(string[] args)
        {
            Class1 obj = new Class1();
            obj.Referesh();

            Console.ReadKey();
        }
    }
}

重新实现继承的接口方法

6 个答案: