接口：接口是指定了一组函数成员，但却没有实现它们的一种引用类型。
如何定义和使用接口：
- interface关键字修饰 接口类型名以大写I开头(如：IList)
- 接口侧重"我能干什么...",微软给我们预定义的接口就多以xxxable结尾。
namespace InterfaceDemo
{
class Program
{
static void Main(string[] args)
{
IPrintable blackPrinter = new BlackPrinter();//接口和抽象类一样也不能new哦
blackPrinter.Print();
IPrintable multiColorPrinter = new MultiColourPrinter();
multiColorPrinter.Print();
Console.ReadLine();
}
}
interface IPrintable
{
void Print();//不能用public修饰、也不能用abstract修饰
}
class BlackPrinter : IPrintable
{
//不要用override修饰
public void Print()
{
Console.WriteLine("打印出黑白的文档");
}
}
class MultiColourPrinter : IPrintable
{
public void Print()
{
Console.WriteLine("打印出彩色的文档");
}
}
}
/**输出：
打印出黑白的文档
打印出彩色的文档
**/
以上我们演示了如何定义接口；如何定义类类型来实现接口；并且演示了如何使用接口。
使用接口的时候需要注意：
- 接口中的函数成员默认是公开的；且不能被public修饰
- 接口中的函数成员也不可以被abstract修饰；因为接口中成员是"完全抽象的"，它只是定义了某种能力或行为；而具体的能力或行为就交给子类去实现；
- 若普通类型继承了接口，那么接口中的所有成员，都要被实现；但是在子类中这些被实现的函数成员不需要加override关键修饰；
- 若抽象类继承了接口，则函数成员可以不被实现；如果在抽象类类中不实现该函数成员，则函数成员必须被标记为 public abstract类型--public是因为该函数成员从接口中继承过来，在子类中无法修改访问修饰符；abstract是因为，只有abstract才能使函数成员有"延迟到子类实现"的功能。
根据接口的以上特点，我们演示一下以抽象类继承接口：
interface IPrintable
{
void Print();//不能用public修饰、也不能用abstract修饰
}
abstract class AbstractPrinter : IPrintable
{
public abstract void Print();
}
class MordenPrinter : AbstractPrinter
{
public override void Print()
{
Console.WriteLine("激光打印，全业务支持");
}
}
下面将展示如何用接口解决实际问题：
问题：借助Array类型的Sort()方法，我们可以对数组中方便地进行排序(如下代码所示:)
class Program
{
static void Main(string[] args)
{
int[] intArr = new int[] { 2, 5, 1, 3, 4, 9 };
Array.Sort(intArr);
foreach (var item in intArr)
{
Console.WriteLine(item);
}
Console.ReadLine();
}
}
/*输出：
1
2
3
4
5
9*/
但是，如果数组中的元素是我们自定义的类型时，Sort()方法就不那么好使了：
class Program
{
static void Main(string[] args)
{
Student tangsan = new Student() { StuName = "唐三", StuNumber = 003 };
Student xiaowu = new Student() { StuName = "小舞", StuNumber = 004 };
Student pangzi = new Student() { StuName = "胖子", StuNumber = 002 };
Student daimubai = new Student() { StuName = "戴沐白", StuNumber = 001 };
Student[] students = new Student[] { tangsan, xiaowu, pangzi, daimubai };
Array.Sort(students);
foreach (var item in students)
{
Console.WriteLine(item.StuNumber+"--"+item.StuName);
}
Console.ReadLine();
}
}
class Student
{
public int StuNumber { get; set; }
public string StuName { get; set; }
}
/*运行报错--未经处理的异常：System.InvalidOperationException:“未能比较数组中的两个元素。”*/
打开错误详细信息得知，原来是因为：我们自定义的类型没有实现ICompare接口，所以数组中元素之间不具有可比性。
我们要实现这个接口，首先得了解这个接口吧？
查找Icompare接口的定义可知：
Icopmare接口中只定义了一个函数成员；该函数接受一个object类型的引用；若当前实例和obj比较结果小于零 则当前实例排在obj之前；大于零 则当前实例排在obj之后...
public interface IComparable
{
int CompareTo(object obj);
}
知道了接口的定义，我们就可以动手了：继承ICompare接口，实现CompareTo方法：
class Student:IComparable
{
public int StuNumber { get; set; }
public string StuName { get; set; }
public int CompareTo(object obj)
{
Student student = obj as Student;
if (this.StuNumber>student.StuNumber)
{
return 1;
}
if (this.StuNumber<student.StuNumber)
{
return -1;
}
return 0;
}
}
/*运行结果：
1--戴沐白
2--胖子
3--唐三
4--小舞
*/
通过将我们自定义的类型实现ICompare接口，并在CompareTo方法中自定义了比较规则，便可以是我们自定义的类型可以排序。
//当然你也可以通过稍微改变规则，得到降序结果
class Student : IComparable
{
public int StuNumber { get; set; }
public string StuName { get; set; }
public int CompareTo(object obj)
{
Student student = obj as Student;
if (this.StuNumber > student.StuNumber)
{
//一改常态，当前实例大于obj时，返回一个大于0的值，这样可以让当前实例排在前面~~~
return -1;
}
if (this.StuNumber < student.StuNumber)
{
return 1;
}
return 0;
}
}
/*输出结果：
4--小舞
3--唐三
2--胖子
1--戴沐白
*/
倒过来想一下，为什么一开始的时候int[] 数组就可以支持Sort()方法？通过查看int类型的定义，就明白了：
原来C#给我们提供的Int32结构体类型，已然实现了ICompare接口，并且重写了CompareTo方法。
在此之前我们有一个默认共识：每种类型(除object外)都只有一个基类--即类的继承具有单根性；但是对于接口而言，一个类却可以实现多个接口。
比如：有一天你在做一道计算题，这道计算题需要计算器；但是你手边没有计算器，同桌莉哥借给你一个MAC笔记本电脑，并告诉你：用这个，它也可以当计算器还可以上网看我直播呢！！！
我们将上面的场景 转化成下面的代码：
namespace InterfaceDemo
{
class Program
{
static void Main(string[] args)
{
//当你有计算器时
ICaculatable caculator = new CaculatorMachine();
caculator.Caculator();
//当你没有计算器，同桌借给你一个苹果笔记本
IComputer macBook = new MacBook();
macBook.Caculator();
Console.ReadLine();
}
}
interface ICaculatable
{
void Caculator();//计算题
}
class CaculatorMachine : ICaculatable
{
public void Caculator()
{
Console.WriteLine("做计算题...");
}
}
interface IComputer
{
void Caculator();//计算题
void SeeLive();//看直播
void PalyGame();//玩游戏
}
class MacBook : IComputer
{
public void Caculator()
{
Console.WriteLine("用苹果笔记本，做计算题...");
}
public void PalyGame()
{
Console.WriteLine("玩CSGO.....");
}
public void SeeLive()
{
Console.WriteLine("看莉哥直播.....");
}
}
}
/*输出结果：
做计算题...
用苹果笔记本，做计算题...
*/
看到用上了苹果笔记本，你会不会大呼奢侈~~~；回到正题，我们不是要讲一个类继承多个接口嘛？
通过观察上面的代码，我们发现；在IComputer、ICaculator中都声明了Caculator()；假设我们现在买电脑都是为了追剧、看直播、玩吃鸡。。。那么对于IComputer接口来说，Caculator()就显得多余；我们说这样的现象：其实是接口定义的过"胖"了；
- 将接口IComputer中的Caculator()成员移除、留下"更有意义"的成员(如：玩游戏、看直播等等...)
- 让我们MacBook类既实现ICaculator接口、也实现IComputer 接口
- 这样 MacBook 既可以计算又不耽误玩游戏、看直播
namespace InterfaceDemo
{
class Program
{
static void Main(string[] args)
{
//用同桌借给你的苹果笔记本 做计算题
ICaculatable macCaculator = new MacBook();
macCaculator.Caculator();
//用同桌借给你的苹果笔记本 玩游戏 看直播
IComputer macBook = new MacBook();
macBook.PalyGame();
macBook.SeeLive();
Console.ReadLine();
}
}
interface ICaculatable
{
void Caculator();//计算题
}
class CaculatorMachine : ICaculatable
{
public void Caculator()
{
Console.WriteLine("做计算题...");
}
}
interface IComputer
{
void SeeLive();//看直播
void PalyGame();//玩游戏
}
class MacBook : IComputer, ICaculatable
{
public void Caculator()
{
Console.WriteLine("用苹果笔记本，做计算题...");
}
public void PalyGame()
{
Console.WriteLine("玩CSGO.....");
}
public void SeeLive()
{
Console.WriteLine("看莉哥直播.....");
}
}
}
/*输出结果：
用苹果笔记本，做计算题...
玩CSGO.....
看莉哥直播.....
*/
通过以上例子，我们得知：
- 类可以实现多个接口;
- 通过将接口的功能细化，避免设计出胖接口，可以使我们功能设计更合理--这其实就是设计模式六大原则(SOLID)中的接口隔离原则(ISP)。
以上便是对接口类型的总结，记录下来以便以后查阅。