C# 接口

C#接口

接口:使用java,asp.net等编写的API接口。让其他人通过相应的请求协议(http/https)来访问。理解成“在接口服务器上定义一个方法，在客户端上调用此方法，这样一个过程。”

C#中的接口：

接口的成员有很多：接口定义了属性，方法和事件，都是接口成员。

接口只包含了成员声明。成员的定义是派生类的责任，接口定义一套规则，其他类实现规则。规则===>锲约，合同。意思是接口提供了派生类遵循的标准结构。
接口必须实现，才能使用。
接口也是多态性的表现。

C#类只能继承一个父类（单继承），但一个类可以实现多个接口。
如果一个类，同时实现两个接口，和一个父类，顺序是:先继承类，再实现接口
C#中，接口(Interface)和抽象类(Abstract c1ass)都用于定义抽象的行为，但它们有不同的应用场景和限制。

接口使用interface关键字来定义

接口一般公开，使用public或internal
接口中可以包含类的常用成员（如：属性，方法，事件），但并不是类中的所有的成员都可以在接口中存在。
接口中的成员默认就是公开的(public)，public关键字必须省略。
建议：接口命名一般建议使用大写I。

接口规律：

1.通过类的实例访问的成员，统统在接口不能存在。原因：接口不能实现化，只能被其他类实现。
2.接口中一般不能出现静态的成员。

public interface IBank
{
    //public Interface1() { }// 接口中不能有构造函数
    //private string field1;// 接口中不能有字段

    // 规律：通过类的实例访问的成员，统统在接口不能存在。原因：接口不能实现化，只能被其他类实现。
    // 规律：接口中一般不能出现静态的成员
    //static string Property { get; set; }

    // 属性成员，默认公开
    string BankName { get; set; }

    // 方法成员，默认公开，不能实现，这点和抽象方法类似
    // 方法成员是接口出现最多一种成员
    void Pay();
}

接口在实现时有两种方式：1.隐式实现（常用）  2.显示实现

1.使用接口前必须实现接口

 static void Main(string[] args)
 {
     // 使用接口前必须实现接口
     NYBank nybank = new NYBank(); // 明确确定类型
     IBank bank = new NYBank();  // 还有切换类型可能。IBank被多个类实现
     bank = new JSBank();
     bank.Pay();
     Console.ReadKey();
 }

2.隐式实现（Implicit Implementation）：

这种方式是接口实现中更常见的形式。

在类中直接实现接口的方法或属性，不需要显式地声明它们属于哪个接口。

接口的方法和属性在实现类中作为公共成员（public）出现，可以被任何使用该类的代码访问。

例如：

public interface IBank
{
    string BankName { get; set; }
    void Pay();
}

public class NYBank : IBank
{
    public string BankName { get; set; } = "农业银行"; // 隐式实现
    public void Pay() // 隐式实现
    {
        Console.WriteLine("转账操作！");
    }
}

3.显式实现（Explicit Implementation）：

当你想要实现接口，但不希望这些实现成为类公开的成员时，可以使用显式实现。

在类中，显式实现的成员只能通过接口类型来访问，而不是通过类实例。

显式实现的成员在类定义中使用接口名称作为前缀。

例如：

public interface IBank
{
    string BankName { get; set; }
    void Pay();
}

public class NYBank : IBank
{
    // 显式实现，成员只能通过IBank接口访问
    string IBank.BankName { get { return "农业银行"; } set { /* 忽略设置操作 */ } }

    void IBank.Pay()
    {
        Console.WriteLine("农业银行转账！");
    }
}

在显式实现中，NYBank类的用户不能直接访问BankName属性或Pay方法，除非他们将NYBank的实例转换为IBank类型。这种实现方式通常用于当你想要实现一个接口，但不希望这些接口成员成为类的一部分时，或者当你想要保留类成员的默认实现，同时提供接口特定的实现。

实现接口和抽象类的快捷键：alt+enter+enter
类在实现多个接口时，接口之间是没有顺序的。多个接口之间有逗号分割。
但类在实现接口和继承父类同时存在时，先继承，再实现。

 public class JSBank : JSBankParent, IJijin, IBank// 类在实现多个接口时，接口之间是没有顺序的。多个接口之间有逗号分割。
 // 但类在实现接口和继承父类同时存在时，先继承，再实现。
 {
     public string BankName { get; set; } = "建设银行";
     public void Pay()
     {
         Console.WriteLine("建设银行转账！");
     }
     public void Sale(decimal amount)
     {
         Console.WriteLine("基金销售！");
     }
     public void Buy(decimal amount)
     {
         Console.WriteLine("基金购买！");
     }
 }

接口的继承和实现

1.接口的继承（Interface Inheritance）：

接口可以继承其他接口。这是通过使用冒号（:）后跟基接口名称来实现的。

接口继承允许创建一个接口，该接口扩展或包含另一个接口的功能。

一个接口可以继承多个其他接口，形成接口继承链。

继承的接口可以被类实现，实现类需要提供所有继承接口中定义的方法和属性的具体实现。

例如：

public interface IFirstInterface //接口A
{
    void MethodA();
}

public interface ISecondInterface : IFirstInterface //接口B继承接口A
{
    void MethodB();
}

public class MyClass : ISecondInterface
{
    public void MethodA() { /* 实现细节 */ }
    public void MethodB() { /* 实现细节 */ }
}

2.接口的实现（Interface Implementation）：

类或结构体可以实现一个或多个接口。

实现接口意味着提供接口中定义的所有方法和属性的具体实现。

类或结构体通过在类声明后使用冒号（:）后跟接口名称来实现接口。

实现接口的类或结构体必须提供接口中所有成员的实现，否则该类或结构体必须是抽象的（abstract）。

例如：

public interface IBank
{
    void Deposit();
    void Withdraw();
}

public class SavingsAccount : IBank
{
    public void Deposit() { /* 实现细节 */ }
    public void Withdraw() { /* 实现细节 */ }
}

接口的继承和实现的区别：

接口继承是接口之间的一种关系，它允许一个接口扩展另一个接口的功能。

接口实现是类或结构体与接口之间的关系，它要求类或结构体提供接口中定义的所有成员的具体实现。

接口和抽象类的区别：（防面试）

C#中，接口（Interface）和抽象类（Abstract Class）都用于定义抽象的行为，但它们有不同的应用场景和限制。

接口：
只能定义公共的抽象方法、属性、事件和索引器。
不包含任何实现。
可以被类直接实现。
支持多重继承（通过可继承接口的概念）。
主要用于定义合同，规定类必须实现的行为。

抽象类：
可以包含抽象和非抽象方法。
抽象方法不包含实现，需要在子类中实现。
抽象类不能直接实例化，只能作为基类被继承。
不支持多重继承，但可以通过继承多个接口来实现类似效果。
提供了一种实现抽象的方式，也可以提供具体实现的细节。