为什么我们不能在 class 实现两个由相同方法组成的接口的方法中使用访问修饰符？

Question

public interface A
{
     void FirstDemo();
     void SecondDemo();
}
public interface B
{
     void FirstDemo();
     void SecondDemo();
}

 public class Demo : A, B
        {
            void A.FirstDemo()
            {
                Console.WriteLine("This is a function of first method of interface A");
            }
            void A.SecondDemo()
            {
                Console.WriteLine("This is a function of second method of interface A");
            }

            void B.FirstDemo()
            {
                Console.WriteLine("This is a function of first method of interface B");
            }
            void B.SecondDemo()
            {
                Console.WriteLine("This is a function of second method of interface B");
            }
        }

static void Main(string[] args)
        {
            A obj = new Demo();
            obj.SecondDemo();
            B obj1 = new Demo();
            obj1.FirstDemo();
        }

该程序运行正常。但我的困惑是，如果我在 Demo class 中只实现一个接口，那么我可以在该接口的每个方法中提供一个访问修饰符。但是当我尝试在相同的 class （在这种情况下： Demo class) 那么我就不允许使用 public 访问修饰符。为什么会这样？

注 : 如果我使用单个接口并在 Demo class 中实现它，那么我可以对接口中声明的所有方法使用访问修饰符。那么使用相同方法的多个接口有什么问题？

Answer 1

区别不在于“1 个接口与 2 个接口”，而是“隐式接口与显式接口实现”。关于问题的“为什么禁止可见性修饰符”部分的解释，我将参考问题 .

(显式接口实现是隐式的 public。 是的，你没看错。)

C# 允许您隐式和显式地实现单个接口，并且它们成为不同的方法。对象的static类型决定调用哪个方法：

interface IFace {
  void Method();
  void OnlyImplicit();
  void OnlyExplicit();
}

public class Obj : IFace {
  public void Method() {
    Console.WriteLine("implicit implementation");
  }

  void IFace.Method() {
    Console.WriteLine("explicit implementation");
  }

  public void OnlyImplicit() {
    Console.WriteLine("only implemented implicitly");
  }

  void IFace.OnlyExplicit() {
    Console.WriteLine("only implemented explicitly");
  }

  public void Main() {
    Obj o = new Obj(); // or: var o = new Obj();
    IFace i = o;

    o.Method(); // call of implicit impl
    i.Method(); // call of explicit impl

    o.OnlyImplicit(); // call of implicit impl
    i.OnlyImplicit(); // call of implicit impl

    i.OnlyExplicit(); // call of explicit impl

    // compile error, method is implemented explicitly,
    // can only be called when static type is interface;
    // cannot be called when static type is the class' type
    // (this is not so obvious):
    o.OnlyExplicit();
  }
}

Answer 2

为了使用一个对象，你需要一个接口:-)。

您可以隐式实现一个接口，显式实现另一个接口。

您不能提供同一接口方法的多个不同实现。否则编译器将如何选择要使用的实现？

假设您隐式实现 A 并显式实现 B：

var demo = new Demo();
demo.FirstDemo(); // it uses public implementation (Demo class interface) that is A
var demoB = (B)demo;
demoB.FirstDemo(); // it uses B interface

为什么我们不能在 class 实现两个由相同方法组成的接口的方法中使用访问修饰符？

Why we can't use access modifier in the methods of class which implements two interfaces consist of same methods?

c#

oop

interface

access-modifiers

multiple-interface-implem