标签：sage mem ace 第一行代码 new 接口实现 return public 技术
接口是指定一组函数成员而不实现它们的引用类型。所以只能类和结构来实现接口。
这种描述比较抽象，直接来看个示例。
下例中，Main方法创建并初始化了一个CA类的对象，并将该对象传递给PrintInfo方法。
class CA { public string Name; public int Age; } class CB { public string First; public string Last; public double PersonsAge; } class Program { static void PrintInfo(CA item) { Console.WriteLine("Name: {0},Age {1}",item.Name,item.Age); } static void Main() { CA a=new CA(){Name="John Doe",Age=35}; PrintInfo(a); } }
只要传入的是CA类型的对象，PrintInfo就能正常工作。但如果传入的是CB，就不行了。
现在的代码不能满足上面的需求，原因有很多。
接口解决了这一问题。
interface IInfo //声明接口 { string GetName(); string GetAge(); } class CA:IInfo //声明了实现接口的CA类 { public string Name; public int Age; public string GetName(){return Name;} public string GetAge(){return Age.ToString();} } class CB:IInfo //声明了实现接口的CB类 { public string First; public string Last; public double PersonsAge; public string GetName(){return First+""+Last;} public string GetAge(){return PersonsAge.ToString();} } class Program { static void PrintInfo(IInfo item) { Console.WriteLine("Name: {0},Age {1}",item.GetName(),item.GetAge()); } static void Main() { var a=new CA(){Name="John Doe",Age=35}; var b=new CB(){First="Jane",Last="Doe",PersonsAge=33}; PrintInfo(a); PrintInfo(b); } }
var myInt=new[]{20,4,16,9,2}; Array.Sort(myInt); foreach(var i in myInt) { Console.WriteLine("{0}",i); }
Sort方法在int数组上工作良好，但如果我们尝试在自己的类上使用会发生什么呢？
class MyClass { public int TheValue; } ... MyClass[] mc=new MyClass[5]; ... Array.Sort(mc);
运行上面的代码，将会得到一个异常。Sort并不能对MyClass对象数组排序，因为它不知道如何比较自定义的对象。Array类的Sort方法其实依赖于一个叫做IComparable的接口，它声明在BCL中，包含唯一的方法CompareTo。
public interface IComparable { int CompareTo(object obj); }
尽管接口声明中没有为CompareTo方法提供实现，但IComparable接口的.NET文档中描述了该方法应该做的事情，可以在创建实现该接口的类或结构时参考。
文档中写到，在调用CompareTo方法时，它应该返回以下几个值：
我们可以通过让类实现IComparable来使Sort方法可以用于MyClass对象。要实现一个接口，类或结构必须做两件事情：
例：MyClass中实现了IComparable接口
class MyClass:IComparable { public int TheValue; public int CompareTo(object obj) { var mc=(MyClass)obj; if(this.TheValue<mc.TheValue)return -1; if(this.TheValue>mc.TheValue)return 1; return 0; } }
例：完整示例代码
class MyClass:IComparable { public int TheValue; public int CompareTo(object obj) { var mc=(MyClass)obj; if(this.TheValue<mc.TheValue)return -1; if(this.TheValue>mc.TheValue)return 1; return 0; } } class Program { static void PrintInfo(string s,MyClass[] mc) { Console.WriteLine(s); foreach(var m in mc) { Console.WriteLine("{0}",m.TheValue); } Console.WriteLine(""); } static void Main() { var myInt=new[] {20,4,16,9,2}; MyClass[] mcArr=new MyClass[5]; for(int i=0;i<5;i++) { mcArr[i]=new MyClass(); mcArr[i].TheValue=myInt[i]; } PrintOut("Initial Order: ",mcArr); Array.Sort(mcArr); PrintOut("Sorted Order: ",mcArr); } }
上一节使用的是BCL中已有的接口。现在我们来看看如何声明接口。
关于声明接口，需要知道的重要事项如下：
例：两个方法成员接口的声明
关键字 接口名称 ↓ ↓ interface IMyInterface1 { int DoStuff(int nVar1,long lVar2); //分号替代了主体 double DoOtherStuff(string s,long x); }
接口的访问性和接口成员的访问性之间有一些重要区别
接口允许访问修饰符 ↓ public interface IMyInterface2 { private int Method1(int nVar1); //错误 ↑ 接口成员不允许访问修饰符 }
只有类和结构才能实现接口。
例：MyClass实现IMyInterface1接口
class MyClass:IMyInterface1 { int DoStuff(int nVar1,long lVar2) {...} //实现代码 double DoOtherStuff(string s,long x) {...} //实现代码 }
关于实现接口，需要了解以下重要事项：
基类必须放在最前面 接口名 ↓ ↓ class Derived:MyBaseClass,IIfc1,IEnumerable,IComparable
interface IIfc1 { void PrintOut(string s); } class MyClass:IIfc1 { public void PrintOut(string s) { Console.WriteLine("Calling through: {0}",s); } } class Program { static void Main() { var mc=new MyClass(); mc.PrintOut("object"); } }
接口不仅是类或结构要实现的成员列表。它是一个引用类型。
我们不能直接通过类对象的成员访问接口。然而，我们可以通过把类对象引用强制转换为接口类型来获取指向接口的引用。一旦有了接口引用，我们就可以使用点号来调用接口方法。
例：从类对象引用获取接口引用
IIfc1 ifc=(IIfc1)mc; //转换为接口，获取接口引用 ifc.PrintOut("interface"); //使用接口的引用调用方法
例：类和接口的引用
interface IIfc1 { void PrintOut(string s); } class MyClass:IIfc1 { public void PrintOut(string s) { Console.WriteLine("Calling through: {0}",s); } } class Program { static void Main() { var mc=new MyClass(); mc.PrintOut("object"); //调用类对象的实现方法 IIfc1 ifc=(IIfc1)mc; ifc.PrintOut("interface"); //调用引用方法 } }
上一节，我们已经知道可以使用强制转换运算符来获取对象接口引用，另一个更好的方式是使用as运算符。
如果我们尝试将类对象引用强制转换为类未实现的接口的引用，强制转换操作会抛出异常。我们可以通过as运算符来避免该问题。
ILiveBirth b=a as ILiveBirth; if(b!=null) { Console.WriteLine("Baby is called: {0}",b.BabyCalled()); }
interface IDataRetrieve{int GetData();} interface IDataStore{void SetData(int x);} class MyData:IDataRetrieve,IDataStore { int Mem1; public int GetData(){return Mem1;} public void SetData(int x){Mem1=x;} } class Program { static void Main() { var data=new MyData(); data.SetData(5); Console.WriteLine("Value = {0}",data.GetData()); } }
由于接口可以多实现，有可能多个接口有相同的签名和返回类型。编译器如何处理这种情况呢？
例：IIfc1和IIfc2具有相同签名
interface IIfc1 { void PrintOut(string s); } interface IIfc2 { void PrintOut(string t); }
答案是：如果一个类实现了多接口，并且其中有些接口有相同签名和返回类型，那么类可以实现单个成员来满足所有包含重复成员的接口。
例：MyClass 类实现了IIfc1和IIfc2.PrintOut满足了两个接口的需求。
class MyClass：IIfc1,IIfc2 { public void PrintOut(string s)//两个接口单一实现 { Console.WriteLine("Calling through: {0}",s); } } class Program { static void Main() { var mc=new MyClass(); mc.PrintOut("object"); } }
如果类实现了多接口，我们可以获取每个接口的独立引用。
例：下面类实现了两个具有当PrintOut方法的接口，Main中以3种方式调用了PrintOut。
interface IIfc1 { void PrintOut(string s); } interface IIfc2 { void PrintOut(string t); } class MyClass：IIfc1,IIfc2 { public void PrintOut(string s) { Console.WriteLine("Calling through: {0}",s); } } class Program { static void Main() { var mc=new MyClass(); IIfc1 ifc1=(IIfc1)mc; IIfc2 ifc2=(IIfc2)mc; mc.PrintOut("object"); ifc1.PrintOut("interface 1"); ifc2.PrintOut("interface 2"); } }
实现接口的类可以从它的基类继承实现的代码。
例：演示 类从基类代码继承了实现
interface IIfc1 { void PrintOut(string s); } class MyBaseClass { public void PrintOut(string s) { Console.WriteLine("Calling through: {0}",s); } } class Derived:MyBaseClass,IIfc1 { } class Program { static void Main() { var d=new Derived(); d.PrintOut("object"); } }
上面，我们已经看到了单个类可以实现多个接口需要的所有成员。
但是，如果我们希望为每个接口分离实现该怎么做呢？这种情况下，我们可以创建显式接口成员实现。
class MyClass:IIfc1,IIfc2 { void IIfc1.PrintOut(string s) {...} void IIfc2.PrintOut(string s) {...} }
例：MyClass为两个解耦的成员声明了显式接口成员实现。
interface IIfc1 { void PrintOut(string s); } interface IIfc2 { void PrintOut(string t); } class MyClass：IIfc1,IIfc2 { void IIfc1.PrintOut(string s) { Console.WriteLine("IIfc1: {0}",s); } void IIfc2.PrintOut(string s) { Console.WriteLine("IIfc2: {0}",s); } } class Program { static void Main() { var mc=new MyClass(); IIfc1 ifc1=(IIfc1)mc; ifc1.PrintOut("interface 1"); IIfc2 ifc2=(IIfc2)mc; ifc2.PrintOut("interface 2"); } }
如果有显式接口成员实现，类级别的实现是允许的，但不是必需的。显式实现满足了类或结构必须实现的方法。因此，我们可以有如下3种实现场景。
显式接口成员实现只可以通过指向接口的引用来访问。即其他的类成员都不可以直接访问它们。
例：如下MyClass显式实现了IIfc1接口。注意，即使是MyClass的另一成员Method1，也不可以直接访问显式实现。
class MyClass:IIfc1 { void IIfc1.PrintOut(string s) { Console.WriteLine("IIfc1"); } public void Method1() { PrintOut("..."); //编译错误 this.PrintOut("..."); //编译错误 ((IIfc1)this).PrintOut("..."); ↑ 转换为接口引用 } }
这个限制对继承产生了重要影响。由于其他类成员不能直接访问显式接口成员实现，衍生类的成员也不能直接访问它们。它们必须总是通过接口的引用来访问。
之前我们已经知道接口实现可以从基类继承，而接口本身也可以从一个或多个接口继承。
interface IDataIO:IDataRetrieve,IDataStore { ... }
例：IDataIO接口继承了两个接口
interface IDataRetrieve { int GetData(); } interface IDataStore { void SetData(int x); } interface IDaTaIO：IDataRetrieve,IDataStore { } class MyData:IDataIO { int nPrivateData; public int GetData() { return nPrivateData; } public void SetData(int x) { nPrivateData=x; } } class Program { static void Main() { var data=new MyData(); data.SetData(5); Console.WriteLine("{0}",data.GetData()); } }
interface ILiveBirth //声明接口 { string BabyCalled(); } class Animal{} //基类Animal class Cat:Animal,ILiveBirth //声明Cat类 { string ILiveBirth.BabyCalled() { return "kitten"; } } class Dog:Animal,ILiveBirth //声明DOg类 { string ILiveBirth.BabyCalled() { return "puppy"; } } class Bird:Animal //声明Bird类 { } class Program { static void Main() { Animal[] animalArray=new Animal[3]; animalArray[0]=new Cat(); animalArray[1]=new Bird(); animalArray[2]=new Dog(); foreach(Animal a in animalArray) { ILiveBirth b= a as ILiveBirth;//如果实现ILiveBirth if(b!=null) { Console.WriteLine("Baby is called: {0}",b.BabyCalled()); } } } }
标签：sage mem ace 第一行代码 new 接口实现 return public 技术
原文地址：http://www.cnblogs.com/moonache/p/6346424.html
