0 
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 类中只实现一个接口，那么我可以在该接口的每个方法中给出一个访问修饰符。但是，当我尝试在同一个类（在本例中：Demo 类）中实现包含相同方法的两个接口（在本例中：A 和 B）时，我不允许放置公共访问修饰符。为什么会发生？

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

4

2 回答 2

1

区别不在于“1 个接口与 2 个接口”，而在于“隐式与显式接口实现”。关于问题的“为什么禁止可见性修饰符”部分的解释，我将参考问题为什么在 C# 中需要提及访问修饰符来实现接口属性？.

（显式接口实现是隐式公开的。是的，你没看错。）

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

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();
  }
}
于 2021-12-09T06:42:52.760 回答
0

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

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

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

假设您隐式实现 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
于 2021-12-09T06:48:11.187 回答