C#接口

今天就来简单的介绍下接口的基本概念及用法：

1、接口的概念及声明

接口是一种用来定义程序的协议，它描述可属于任何类或结构的一组相关行为。接口可有方法、属性、事件和索引器或这四种成员的任何组合类型，但不能包含字段。

那么接口具有哪些特点呢？

·接口类似于抽象基类：继承接口的任何非抽象类型都必须实现接口的所有成员(说明：如类A继承接口B，那么A中必须实现B中定义的属性，方法等)。

·不能直接实例化接口

·接口可以包含事件、索引器、方法和属性

·接口不包含方法的实现

·类和接口可以从多个接口继承

·接口自身可以继承多个接口

在声明接口时除了Interface和接口名称是必须的，其他都是可选项。另可使用new、public、protected、intenal和private等修饰符实现接口，但接口成员必须是公共的。

2、接口的实现与继承

声明实现接口的类时，需要在基类列表中包含类所实现的接口的名称。

下面举个小例子来探讨下：

using System;
using System.Collections.Generic;
using System.Text;

namespace _
{
    interface ImyInterface
    {
        /// <summary>
        /// 编号（可读可写）
        /// </summary>
        string ID
        {
            get;
            set;
        }
        /// <summary>
        /// 姓名（可读可写）
        /// </summary>
        string Name
        {
            get;
            set;
        }
        /// <summary>
        /// 显示定义的编号和姓名
        /// </summary>
        void ShowInfo();
    }
    class Program:ImyInterface//继承自接口
    {
        string id = "";
        string name = "";
        /// <summary>
        /// 编号
        /// </summary>
        public string ID
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }
        /// <summary>
        /// 姓名
        /// </summary>
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        /// <summary>
        /// 显示定义的编号和姓名
        /// </summary>
        public void ShowInfo()
        {
            Console.WriteLine("编号\t 姓名");
            Console.WriteLine(ID + "\t " + Name);
        }
        static void Main(string[] args)
        {
            Program program = new Program();               //实例化Program类对象
            ImyInterface imyinterface = program;           //使用派生类对象实例化接口ImyInterface
            imyinterface.ID = "TM";                        //为派生类中的ID属性赋值
            imyinterface.Name = "C# 2.0从入门到应用开发";  //为派生类中的Name属性赋值
            imyinterface.ShowInfo();                       //调用派生类中方法显示定义的属性值
        }
    }
}

上面的这个例子是一个简单的一个类继承一个接口，如要实现接口类中对应的成员必须是公共的、非静态的，并且与接口成员具有相同的名称和签名。并且接口的实例化不能像类那样Program program = new Program();其中上述程序中红色部分即为接口的实例化(使用派生类对象实例化接口)。

单一继承时这样的，那么多重继承呢？OK，我们来看下个例子：

using System;
using System.Collections.Generic;
using System.Text;

namespace _
{
    interface IPeople
    {
        /// <summary>
        /// 姓名
        /// </summary>
        string Name
        {
            get;
            set;
        }
        /// <summary>
        /// 性别
        /// </summary>
        string Sex
        {
            get;
            set;
        }
    }
    interface ITeacher:IPeople            //继承公共接口
    {
        /// <summary>
        /// 教学方法
        /// </summary>
        void teach();
    }
    interface IStudent:IPeople            //继承公共接口
    {
        /// <summary>
        /// 学习方法
        /// </summary>
        void study();
    }
    class Program:IPeople,ITeacher,IStudent//多接口继承
    {
        string name = "";
        string sex = "";
        /// <summary>
        /// 姓名
        /// </summary>
        public string Name
        {
            get
            {
                return name;
            }
            set
            {
                name = value;
            }
        }
        /// <summary>
        /// 性别
        /// </summary>
        public string Sex
        {
            get
            {
                return sex;
            }
            set
            {
                sex = value;
            }
        }
        /// <summary>
        /// 教学方法
        /// </summary>
        public void teach()
        {
            Console.WriteLine(Name + " " + Sex + " 教师");
        }
        /// <summary>
        /// 学习方法
        /// </summary>
        public void study()
        {
            Console.WriteLine(Name + " " + Sex + " 学生");
        }
        static void Main(string[] args)
        {
            Program program = new Program();   //实例化类对象
            ITeacher iteacher = program;       //使用派生类对象实例化接口ITeacher
            iteacher.Name = "TM";
            iteacher.Sex = "男";
            iteacher.teach();
            IStudent istudent = program;       //使用派生类对象实例化接口IStudent
            istudent.Name = "C#";
            istudent.Sex = "男";
            istudent.study();
        }
    }
}

上述的多重继承中说明了，在派生类中必须实现所继承的接口中的所有方法。OK，单一继承和多重继承都有了了解之后，是不是没有其他的需要了解的呢？试想一下，如果在一个类A继承自接口B和C，并且在B和C中包含具有相同签名的成员，那么在类中实现该成员将导致两个接口都使用该成员作为他们的实现，然而，如果两个接口成员实现不同的功能，那么将会导致一个接口的成员实现不正确或两个接口的成员实现都不正确，这个时候我们应该如何处理呢？我们可以显示的实现接口成员，即创建一个仅通过接口调用并且特定于该接口的类成员。

下面也是一个通过一个实例来说明

using System;
using System.Collections.Generic;
using System.Text;

namespace _
{
    interface ImyInterface1
    {
        /// <summary>
        /// 求和方法
        /// </summary>
        /// <returns>加法运算的和</returns>
        int Add();
    }
    interface ImyInterface2
    {
        /// <summary>
        /// 求和方法
        /// </summary>
        /// <returns>加法运算的和</returns>
        int Add();
    }
    class myClass : ImyInterface1, ImyInterface2    //继承接口
    {
        /// <summary>
        /// 求和方法
        /// </summary>
        /// <returns>加法运算的和</returns>
        int ImyInterface1.Add()                     //显式接口成员实现
        {
            int x = 3;
            int y = 5;
            return x + y;
        }
        /// <summary>
        /// 求和方法
        /// </summary>
        /// <returns>加法运算的和</returns>
        int ImyInterface2.Add()                      //显式接口成员实现
        {
            int x = 3;
            int y = 5;
            int z = 7;
            return x + y + z;
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            myClass myclass = new myClass();          //实例化接口继承类的对象
            ImyInterface1 imyinterface1 = myclass;    //使用接口继承类的对象实例化接口
            Console.WriteLine(imyinterface1.Add());   //使用接口对象调用接口中方法
            ImyInterface2 imyinterface2 = myclass;    //使用接口继承类的对象实例化接口
            Console.WriteLine(imyinterface2.Add());   //使用接口对象调用接口中方法
        }
    }
}

上面的实例中在Myclass类中，通过两个显示接口成员的方法分别实现了两个接口中的Add方法，在实例化不同的接口后，调用相应的方法实现输出结果。