我仍在努力更好地理解接口。我知道它们是什么以及如何在类中实现它们。
我不明白的是，当您创建一个属于您的接口类型之一的变量时：
IMyInterface somevariable;
你为什么要这样做？我不明白如何像类一样使用 IMyInterface...例如调用方法，所以：
somevariable.CallSomeMethod();
为什么要使用 IMyInterface 变量来执行此操作？
【问题讨论】：
标签： c#
您不是在创建接口的实例 - 您是在创建实现接口的实例。
接口的关键在于它保证实现它的任何东西都将提供其中声明的方法。
所以现在，使用您的示例，您可以：
MyNiftyClass : IMyInterface
{
public void CallSomeMethod()
{
//Do something nifty
}
}
MyOddClass : IMyInterface
{
public void CallSomeMethod()
{
//Do something odd
}
}
现在你有：
IMyInterface nifty = new MyNiftyClass()
IMyInterface odd = new MyOddClass()
现在调用 CallSomeMethod 方法会做一些漂亮或奇怪的事情，当您使用 IMyInterface 作为类型传入时，这将变得特别有用。
public void ThisMethodShowsHowItWorks(IMyInterface someObject)
{
someObject.CallSomeMethod();
}
现在，根据你是用漂亮的类还是奇怪的类调用上述方法，你会得到不同的行为。
public void AnotherClass()
{
IMyInterface nifty = new MyNiftyClass()
IMyInterface odd = new MyOddClass()
// Pass in the nifty class to do something nifty
this.ThisMethodShowsHowItWorks(nifty);
// Pass in the odd class to do something odd
this.ThisMethodShowsHowItWorks(odd);
}
编辑
这解决了我认为您的预期问题 - 为什么要将变量声明为接口类型？
也就是说，为什么要使用：
IMyInterface foo = new MyConcreteClass();
优先于：
MyConcreteClass foo = new MyConcreteClass();
希望在声明方法签名时使用接口的原因很清楚，但这留下了关于局部范围变量的问题：
public void AMethod()
{
// Why use this?
IMyInterface foo = new MyConcreteClass();
// Why not use this?
MyConcreteClass bar = new MyConcreteClass();
}
通常没有技术原因为什么首选该界面。我通常使用界面，因为：
技术上需要接口的一个地方是使用多态性的地方，例如使用工厂创建变量或（如上所述）使用依赖注入。
从 itowlson 借用一个例子，使用具体声明你不能这样做：
public void AMethod(string input)
{
IMyInterface foo;
if (input == "nifty")
{
foo = new MyNiftyClass();
}
else
{
foo = new MyOddClass();
}
foo.CallSomeMethod();
}
【讨论】：
IMyInterface nifty = new MyNiftyClass() 是人为的：你通常不会费心去写它。但是考虑一下，比如说IMyInterface imi = oddness > 0 ? new OddClass() : new NiftyClass()。我们在编译时不知道我们会得到一个 Odd 还是 Nifty 对象，我们不在乎：我们只关心我们可以将它传递给 TMSHIW，即它是一个IMyInterface。
使用了接口，因此您无需担心哪个类实现了该接口。一个有用的例子是当你有一个工厂方法返回一个具体的实现，具体实现可能会根据你运行的环境而有所不同。它还允许 API 设计者定义 API，同时允许第 3 方在他们认为合适的任何方式。 Sun 使用它的 Java 加密 API 来做到这一点。
public interface Foo {
}
public class FooFactory {
public static Foo getInstance() {
if(os == 'Windows') return new WinFoo();
else if(os == 'OS X') return new MacFoo();
else return new GenricFoo();
}
}
您使用工厂的代码只需要了解 Foo，而不需要了解任何具体的实现。
【讨论】：
我也处于同样的位置，花了几天时间才弄清楚为什么我们必须使用接口变量。
IDepartments rep = new DepartmentsImpl();
为什么不
DepartmentsImpl rep = new DepartmentsImpl();
想象一下，如果一个类实现了两个包含具有相同签名的成员的接口，那么在该类上实现该成员将导致两个接口都使用该成员作为它们的实现。
class Test
{
static void Main()
{
SampleClass sc = new SampleClass();
IControl ctrl = (IControl)sc;
ISurface srfc = (ISurface)sc;
// The following lines all call the same method.
sc.Paint();
ctrl.Paint();
srfc.Paint();
}
}
interface IControl
{
void Paint();
}
interface ISurface
{
void Paint();
}
class SampleClass : IControl, ISurface
{
// Both ISurface.Paint and IControl.Paint call this method.
public void Paint()
{
Console.WriteLine("Paint method in SampleClass");
}
}
// Output:
// Paint method in SampleClass
// Paint method in SampleClass
// Paint method in SampleClass
但是，如果两个接口成员不执行相同的功能，则可能导致其中一个或两个接口的实现不正确。
public class SampleClass : IControl, ISurface
{
void IControl.Paint()
{
System.Console.WriteLine("IControl.Paint");
}
void ISurface.Paint()
{
System.Console.WriteLine("ISurface.Paint");
}
}
类成员 IControl.Paint 只能通过 IControl 接口使用，ISurface.Paint 只能通过 ISurface 使用。两种方法实现都是独立的，并且都不能直接在类上使用。例如：
IControl c = new SampleClass();
ISurface s = new SampleClass();
s.Paint();
如果我错了，请纠正我，因为我还在学习这个接口概念。
【讨论】：
因为：
public void ReadItemsList(List<string> items);
public void ReadItemsArray(string[] items);
可以变成这样：
public void ReadItems(IEnumerable<string> items);
编辑
这样想：
你必须能够做到这一点。
而不是：
你必须是这样。
本质上这是方法和调用者之间的契约。
【讨论】：
假设您有 Boat、Car、Truck、Plane 类。
这些都有一个共同的方法 TakeMeThere(string destination)
你会有一个界面：
public interface ITransportation
{
public void TakeMeThere(string destination);
}
那么你的班级：
public class Boat : ITransportation
{
public void TakeMeThere(string destination) // From ITransportation
{
Console.WriteLine("Going to " + destination);
}
}
你在这里的意思是，我的班级 Boat 也会完成 ITransportation 告诉我的所有事情。
然后当您想为运输公司制作软件时。你可以有一个方法
Void ProvideServiceForClient(ITransportation transportationMethod, string whereTheyWantToGo)
{
transportationMethod.TakeMeThere(whereTheyWantToGo); // Cause ITransportation has this method
}
所以他们想要哪种交通工具并不重要，因为我们知道它可以TakeMeThere
【讨论】：
使用接口变量是允许编写处理程序方法的唯一方法，处理程序方法可以接受来自具有不同基类的对象的数据。
这是任何人都会明白的。
【讨论】：
这不是 C# 特有的，所以我建议移到其他标志。 对于你的问题， 我们选择接口的主要原因是提供两个组件之间的协议（可以是 dll、jar 或任何其他组件）。 请参考下文
public class TestClass
{
static void Main()
{
IMyInterface ob1, obj2;
ob1 = getIMyInterfaceObj();
obj2 = getIMyInterfaceObj();
Console.WriteLine(ob1.CallSomeMethod());
Console.WriteLine(obj2.CallSomeMethod());
Console.ReadLine();
}
private static bool isfirstTime = true;
private static IMyInterface getIMyInterfaceObj()
{
if (isfirstTime)
{
isfirstTime = false;
return new ImplementingClass1();
}
else
{
return new ImplementingClass2();
}
}
}
public class ImplementingClass1 : IMyInterface
{
public ImplementingClass1()
{
}
#region IMyInterface Members
public bool CallSomeMethod()
{
return true;
}
#endregion
}
public class ImplementingClass2 : IMyInterface
{
public ImplementingClass2()
{
}
#region IMyInterface Members
public bool CallSomeMethod()
{
return false;
}
#endregion
}
public interface IMyInterface
{
bool CallSomeMethod();
}
这里的 main 方法不知道类仍然能够使用接口获得不同的行为。
【讨论】：
接口的目的是定义几个对象之间的契约，独立于具体实现。
所以当你有一个 Intrace ISomething 和一个特定的实现时，你通常会使用它
class Something : ISomething
所以当你实例化一个合约时，Interface 变量会被使用：
ISomething myObj = new Something();
myObj.SomeFunc();
您还应该阅读interface C#
更新：
我将通过一个（现实生活中的）示例来解释对变量使用接口而不是类本身的逻辑：
我有一个通用的存储库接口：
Interface IRepository {
void Create();
void Update();
}
我有 2 个单独的实现：
class RepositoryFile : interface IRepository {}
class RepositoryDB : interface IRepository {}
每个类都有完全不同的内部实现。
现在我有另一个对象，一个 Logger，它使用一个已经实例化的存储库来进行他的写作。这个对象，不关心Repository是怎么实现的，所以他就实现了：
void WriteLog(string Log, IRepository oRep);
顺便说一句，这也可以通过使用标准类继承来实现。但是使用接口和类继承之间的区别是另一个讨论。
有关抽象类和接口之间区别的更详细讨论，请参阅here。
【讨论】：
例如，假设您有两个类：Book 和 Newspaper。您可以阅读其中的每一个，但是这两个从一个公共超类继承是没有意义的。所以他们都会实现IReadable接口：
public interface IReadable
{
public void Read();
}
现在假设您正在编写一个为用户阅读书籍和报纸的应用程序。用户可以从列表中选择一本书或报纸，然后该项目将被阅读给用户。
应用程序中读取给用户的方法会将此Book 或Newspaper 作为参数。这在代码中可能如下所示：
public static void ReadItem(IReadable item)
{
item.Read();
}
由于参数是IReadable，我们知道该对象有Read()方法，因此我们调用它来读取它给用户。这是Book、Newspaper 还是其他任何实现IReadable 的东西都没有关系。各个类通过实现Read() 方法准确地实现了每个项目的读取方式，因为不同的类很可能会有所不同。
Book 的Read() 可能如下所示：
public void Read()
{
this.Open();
this.TurnToPage(1);
while(!this.AtLastPage)
{
ReadText(this.CurrentPage.Text);
this.TurnPage();
}
this.Close();
}
Newspaper 的Read() 可能会有点不同：
public void Read()
{
while(!this.OnBackPage)
{
foreach(Article article in this.CurrentPage.Articles)
{
ReadText(article.Text);
}
}
}
关键是，接口类型的变量包含的对象保证有一组特定的方法，即使对象的可能类没有以任何其他方式相关。这使您可以编写适用于各种类的代码，这些类具有可以对其执行的通用操作。
【讨论】：
不，这是不可能的。设计者没有提供方法。当然，这也是常识。因为接口只包含抽象方法，而抽象方法没有（实现代码的）主体，我们无法创建对象..
假设即使允许，又有什么用。使用对象调用抽象方法不会产生任何目的，因为没有输出。没有抽象方法的功能。 那么，接口在Java设计和编码中的用途是什么。它们可以用作原型，您可以从中轻松开发新类。它们就像其他类的模板一样实现接口，就像构建建筑物的蓝图一样。
【讨论】：
我相信每个人都在回答使用接口的多态性原因，David Hall 部分地谈到了为什么您会将其作为接口而不是实际的对象名称来引用。当然，仅限于接口成员等是有帮助的，但另一个答案是依赖注入/实例化。
在设计应用程序时，如果使用依赖注入，它通常会更简洁、更易于管理且更灵活。如果您从未做过，一开始会感觉倒退，但当您开始回溯时，您会希望自己曾经这样做过。
依赖注入通常通过允许类实例化和控制依赖关系来工作，您只需依赖所需对象的接口即可。
例子：
首先对应用程序进行分层。第 1 层逻辑，第 2 层接口，第 3 层依赖注入。 （每个人都有自己的方式，这里只是作秀）。
在逻辑层你引用接口和依赖层，最后你只基于外部对象的接口创建逻辑。
我们开始吧：
public IEmployee GetEmployee(string id)
{
IEmployee emp = di.GetInstance<List<IEmployee>>().Where(e => e.Id == id).FirstOrDefault();
emp?.LastAccessTimeStamp = DateTime.Now;
return emp;
}
请注意上面我们如何使用 di.GetInstance 从依赖项中获取对象。我们在该层的代码永远不会知道或关心 Employee 对象。事实上，如果它在其他代码中发生变化，它永远不会影响我们这里。如果 IEmployee 的接口发生变化，那么我们可能需要进行代码更改。
关键是，IEmployee emp = 从不真正知道实际对象是什么，但知道接口以及如何使用它。考虑到这一点，这是您想要使用接口而不是对象的时候，因为我们永远不知道或无法访问该对象。
这是总结..希望对您有所帮助。
【讨论】：
【讨论】：