C#接口(Interface)小结(超详细,你值得拥有!!!)

红太狼 2023-02-19 06:25 2阅读 0赞

**前言：通过阅读本篇文章能够深入的理解C\#中的接口以及接口的实现，推荐刚入门的小伙伴收藏嗷！！！**

### 目录： ###

*   *  一、接口的概念
     *  二、接口的作用
     *  三、接口的特性
     *  四、接口的声明
     *  五、接口的两种实现方式
     *   *  1.隐式实现和显式实现的区别
         *  2.隐式实现
         *  3.显式实现
         *  4.两种实现方式的使用场合
     *  六、接口中多态的实现
     *   *  1.多个类继承一个接口
         *  2.一个类继承多个接口
         *  3.一个接口继承多个接口

## 一、接口的概念 ##

接口可以理解为对一组方法声明进行的统一命名，但这些方法没有提供任何实现，也就是说，把一组方法声明在一个接口中，然后继承于该接口的类都需要实现这些方法。接口是一种用来定义程序的协议，它描述可属于任何类或结构的一组相关行为。也就是说接口定义了语法合同 “是什么” 部分，派生类定义了语法合同 “怎么做” 部分。

--------------------

## 二、接口的作用 ##

1.  面向接口编程利用面向对象(OOP)的一个基本性质–多态，相同方法不同表现。
2.  面向接口编程反映OO的另一个方面–封装，接口将具体实现封装了起来，可以不影响客户的情况下切换实现。
3.  如果一个类继承了一个接口，我们知道接口中有什么方法、属性等，那我们在使用这个类的时候不用担心这个类到底有没有实现接口中的方法、属性，大胆的去用就OK了。
4.  现在让两个程序员来分别编写狗类和猫类，两个程序员都继承动物接口（包含动物的共同特征），实现接口中所有的成员，这样不会落下动物共有的属性或方法。如果不继承动物接口，在编写时会落下某些共有的属性或方法。等于说接口定义了一个行为规范，类继承它就必须实现它的规范。

--------------------

## 三、接口的特性 ##

1.  接口类似于抽象基类：继承接口的任何非抽象类都必须实现接口的所有成员。
2.  不能直接实例化接口。
3.  接口可以包含事件、索引器、方法和属性。
4.  接口不包含方法的实现。
5.  类和接口都可以从多个接口继承。
6.  接口自身可以继承多个接口。

--------------------

## 四、接口的声明 ##

接口的声明与类的声明非常相似，只是使用的关键字不一样而已，类的声明是用`class`关键字，接口的声明是用`interface`关键字。

[访问修饰符] interface 接口名称
    {
        
    	接口成员;
    }

**访问修饰符：**  
默认为`internal`，可使用`new`、`public`、`protected`、`intenal`和`private`等修饰符实现接口

**接口名称：**

通常是以 I 开头，再加上其他的单词构成。例如创建一个计算的接口，可以命名为 ICompute。

**接口成员：**

接口中定义的成员与类中定义的成员类似。

在接口中除了可以定义方法外，还可以包含属性、事件、索引器。

在接口中定义方法不能添加任何修饰符，因为接口中的方法默认为`public`，如果显示的指定了修饰符，则会出现编译时的错误。

在接口中的成员变量默认都是`public static final`。  
`public`：使接口的实现类可以用这个变量。  
`static`：`static`修饰就表示它属于类的，随着类的加载而存在的，如果是非static的话，就表示属于对象的，只有建立对象时才有它，而接口是不能建立对象的，所以接口的变量必须定义为`static`。  
`final`：`final`修饰就是保证接口定义的常量不能被实现类去修改，如果没有final的话，由子类随意去修改的话，接口建立这个常量就没有意义了。

接口中定义的成员必须满足：

1.  接口中的成员不允许使用`public`、`private`、`protected`、`internal`访问修饰符。
2.  接口中的成员不允许使用`static`、`virtual`、`abstract`、`sealed`修饰符。
3.  接口中不能定义字段。
4.  接口中不能包含运算符重载、实例构造函数、析构函数。
5.  在接口中定义的方法不能包含方法体。

--------------------

## 五、接口的两种实现方式 ##

### 1.隐式实现和显式实现的区别 ###

*  隐式接口没有具体指明实现的的是哪个接口中的方法;而显式接口，它在实现的过程中明确地指出了是哪个接口中的哪个方法，当一个类中实现多个接口；而且这些接口中包含相同返回值，方法名称和参数类型时，隐式接口的实现就会出现命名冲突的问题。
 *  显式接口的实现则能解决类似于上述中实现多个接口中方式时，命名冲突的问题。

### 2.隐式实现 ###

public interface IA
        {
        
            void Welcome();
        }
        public class FirstStudent:IA
        {
        
            public void Welcome()
            {
        
                Console.WriteLine("你好");
            }
        }
        class Program
        {
        
            static void Main(string[] args)
            {
        
                FirstStudent stu = new FirstStudent();
                stu.Welcome();
                IA a = stu;
                a.Welcome();
                Console.ReadLine();
            }
        }

![在这里插入图片描述][20200619173405792.png]  
由此可得出，隐式实现接口可以通过类对象进行访问，也可以通过接口进行访问。

### 3.显式实现 ###

显式接口的实现需要注意以下几个问题：

*  若显式实现接口，方法不能使用任何访问修饰符，显式实现的成员默认为私有的(`private`)；
 *  显式实现的成员默认是私有的，所以这些成员是不能通过类的对象进行访问的，只能通过类对象实例化接口，用接口进行访问。

public class SecondStudent:IA
        {
        
            void IA.Welcome()
            {
        
                Console.WriteLine("你好");
            }
        }
        class Program
        {
        
            static void Main(string[] args)
            {
        
                SecondStudent stu2 = new SecondStudent();
                IA b=stu2;
                b.Welcome();
                Console.ReadLine();
            }
        }

![在这里插入图片描述][20200619175610642.png]

### 4.两种实现方式的使用场合 ###

*  若采用隐式接口实现时，类和接口都可以访问接口中的方法；而要是采用显式接口实现方式，接口方法只能通过接口来完成访问，因为此时接口方法默认是私有的。
 *  当类实现单个接口时，通常使用隐式接口实现方式，这样类的对象可直接访问接口方法。
 *  当类实现多个接口，并且接口中包含相同的方法名称、参数和返回类型时，则应该使用显式接口实现方式。即使没有相同的方法签名，所以在实现多个接口时，推荐使用显式的方式，这样可以很明确地标识出哪个方法属于哪个接口

--------------------

## 六、接口中多态的实现 ##

使用接口实现多态 需要满足以下两个条件：

1.  定义接口并使用类实现接口中所有的成员。
2.  创建接口的实例指向不同的实现类对象。

### 1.多个类继承一个接口 ###

使用隐式实现接口成员

interface IPeople
        {
         
            int ID {
         get; set; }
            string Name {
         get; set; }
            /// <summary>
            /// 输出信息方法
            /// </summary>
            void Getreturn();
        }
        class Man : IPeople
        {
        
        	/// <summary>
            /// 隐式实现接口中的ID属性
            /// </summary>
            public int ID {
         get; set; }
            /// <summary>
            /// 隐式实现接口中的Name属性
            /// </summary>
            public string Name {
         get; set; }
            /// <summary>
            /// 隐式实现接口中的输出信息方法
            /// </summary>
            public void Getreturn()
            {
        
                Console.WriteLine($"编号:{ID}---姓名:{Name}");
            }
        }
        class WoMan : IPeople
        {
        
            public int ID {
         get; set; }
            public string Name {
         get; set; }
            /// <summary>
            /// 隐式实现接口中的输出信息方法
            /// </summary>
            public void Getreturn()
            {
        
                Console.WriteLine($"编号:{ID}---姓名:{Name}");
            }
        }
        class Program
        {
        
            static void Main(string[] args)
            {
        
                //多个类继承一个接口
                IPeople people1 = new Man(); //创建接口的实例people1指向实现类Man的对象
                people1.ID = 01;
                people1.Name = "张三";
                people1.Getreturn();
                IPeople people2 = new WoMan();//创建接口的实例people2指向实现类WoMan的对象
                people2.ID = 02;
                people2.Name = "萌萌";
                people2.Getreturn();
                Console.ReadLine();
            }
        }

![在这里插入图片描述][20200619192140910.png]

### 2.一个类继承多个接口 ###

使用显式实现接口成员

/// <summary>
        /// 猫接口
        /// </summary>
        interface ICat
        {
         
            string Name {
         get; set; }
            void Getname();
        }
        /// <summary>
        /// 狗接口
        /// </summary>
        interface IDog
        {
         
            string Name {
         get; set; }
            void Getname();
        }
        /// <summary>
        /// 实现类Animal继承两个接口
        /// </summary>
        class Animal:ICat,IDog
        {
         
            /// <summary>
            /// 显式实现接口ICat中的Name属性
            /// </summary>
            string ICat.Name {
         get; set; }
            /// <summary>
            /// 显式实现接口IDog中的Name属性
            /// </summary>
            string IDog.Name {
         get; set; }
            /// <summary>
            /// 显式实现接口ICat中的Getname方法
            /// </summary>
            void ICat.Getname()
            {
        
                Console.WriteLine("ICat接口中的Getname方法");
            }
            /// <summary>
            /// 显式实现接口IDog中的Getname方法
            /// </summary>
            void IDog.Getname()
            {
        
                Console.WriteLine("IDog接口中的Getname方法");
            }
        }
        class Program
        {
        
            static void Main(string[] args)
            {
        
                //一个类继承多个接口
                ICat cat = new Animal();//创建接口ICat的实例cat指向实现类Animal的对象
                cat.Name = "布鲁";
                Console.WriteLine($"名字:{cat.Name}");
                cat.Getname();
                IDog dog = new Animal();//创建接口IDog的实例dog指向实现类Animal的对象
                dog.Name = "二哈";
                Console.WriteLine($"名字:{dog.Name}");
                dog.Getname();
                Console.ReadLine();
            }
        }

![在这里插入图片描述][20200619201415731.png]  
由此可得，一个类继承多个接口时，必须将所继承的所有接口的成员全部实现。否则编译器会报错。

### 3.一个接口继承多个接口 ###

interface IB
        {
        
            void Say();
        }
        interface IC
        {
        
            void Run();
        }
        interface ID:IB,IC
        {
        
            void Stay();
        }
        class Person : ID
        {
        
            void IB.Say()
            {
        
                Console.WriteLine("实现接口IB中的Say方法");
            }
            void IC.Run()
            {
        
                Console.WriteLine("实现接口IC中的Run方法");
            }
            void ID.Stay()
            {
        
                Console.WriteLine("实现接口ID中的Stay方法");
            }
        }
        class Program
        {
        
            static void Main(string[] args)
            {
        
            	//一个接口继承多个接口
                ID d = new Person();//创建接口ID的实例d指向实现类Person的对象
                d.Say();
                d.Run();
                d.Stay();
            }
        }

![在这里插入图片描述][20200619202139352.png]  
由此可得，当一个接口继承多个接口时，在实现类中必须将这个接口所继承的接口的所有成员全部实现。否则编译器会报错。

--------------------

# 通过阅读本篇文章你掌握了多少呢?快来评论区抢沙发!!! #

[20200619173405792.png]: https://img-blog.csdnimg.cn/20200619173405792.png
[20200619175610642.png]: https://img-blog.csdnimg.cn/20200619175610642.png
[20200619192140910.png]: https://img-blog.csdnimg.cn/20200619192140910.png
[20200619201415731.png]: https://img-blog.csdnimg.cn/20200619201415731.png
[20200619202139352.png]: https://img-blog.csdnimg.cn/20200619202139352.png