“程序接口，而非实现”是什么意思？
Posted
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了“程序接口，而非实现”是什么意思？相关的知识，希望对你有一定的参考价值。
在阅读有关设计模式时，人们会发现这句话。
但是我不明白，有人可以帮我解释一下吗？
接口只是合同或签名，他们对实现一无所知。
对接口进行编码意味着，客户端代码始终保存由工厂提供的Interface对象。工厂返回的任何实例都是Interface类型，任何工厂候选类必须已实现。这样客户端程序就不会担心实现，接口签名决定了所有操作都可以完成。这可用于在运行时更改程序的行为。从维护的角度来看，它还可以帮助您编写更好的程序。
这是一个基本的例子。
public enum Language
{
English, German, Spanish
}
public class SpeakerFactory
{
public static ISpeaker CreateSpeaker(Language language)
{
switch (language)
{
case Language.English:
return new EnglishSpeaker();
case Language.German:
return new GermanSpeaker();
case Language.Spanish:
return new SpanishSpeaker();
default:
throw new ApplicationException("No speaker can speak such language");
}
}
}
[STAThread]
static void Main()
{
//This is your client code.
ISpeaker speaker = SpeakerFactory.CreateSpeaker(Language.English);
speaker.Speak();
Console.ReadLine();
}
public interface ISpeaker
{
void Speak();
}
public class EnglishSpeaker : ISpeaker
{
public EnglishSpeaker() { }
#region ISpeaker Members
public void Speak()
{
Console.WriteLine("I speak English.");
}
#endregion
}
public class GermanSpeaker : ISpeaker
{
public GermanSpeaker() { }
#region ISpeaker Members
public void Speak()
{
Console.WriteLine("I speak German.");
}
#endregion
}
public class SpanishSpeaker : ISpeaker
{
public SpanishSpeaker() { }
#region ISpeaker Members
public void Speak()
{
Console.WriteLine("I speak Spanish.");
}
#endregion
}
这只是一个基本的例子，对该原理的实际解释超出了本答案的范围。
EDIT
我已经更新了上面的示例，并添加了一个抽象的Speaker基类。在此更新中，我向所有Spakers添加了一个功能“SayHello”。所有发言者都说“Hello World”。这是具有类似功能的常见功能。请参阅类图，您会发现Speaker抽象类实现了ISpeaker接口并将Speak（）标记为抽象，这意味着每个Speaker实现负责实现Speak方法，因为它因Speaker而异。但是所有发言者都一致地说“你好”。因此，在抽象的Speaker类中，我们定义了一个表示“Hello World”的方法，每个Speaker实现都将派生出SayHello方法。
考虑一个案例，其中SpanishSpeaker不能说你好，所以在这种情况下你可以覆盖西班牙语说话者的SayHello方法并引发适当的异常。
请注意，我们尚未对Interface ISpeaker进行任何更改。并且客户端代码和SpeakerFactory也不受影响。这就是我们通过Programming-to-Interface实现的。
我们可以通过简单地添加一个基本抽象类Speaker和每个实现中的一些小修改来实现这种行为，从而保持原始程序不变。这是任何应用程序的理想功能，它使您的应用程序易于维护。
public enum Language
{
English, German, Spanish
}
public class SpeakerFactory
{
public static ISpeaker CreateSpeaker(Language language)
{
switch (language)
{
case Language.English:
return new EnglishSpeaker();
case Language.German:
return new GermanSpeaker();
case Language.Spanish:
return new SpanishSpeaker();
default:
throw new ApplicationException("No speaker can speak such language");
}
}
}
class Program
{
[STAThread]
static void Main()
{
//This is your client code.
ISpeaker speaker = SpeakerFactory.CreateSpeaker(Language.English);
speaker.Speak();
Console.ReadLine();
}
}
public interface ISpeaker
{
void Speak();
}
public abstract class Speaker : ISpeaker
{
#region ISpeaker Members
public abstract void Speak();
public virtual void SayHello()
{
Console.WriteLine("Hello world.");
}
#endregion
}
public class EnglishSpeaker : Speaker
{
public EnglishSpeaker() { }
#region ISpeaker Members
public override void Speak()
{
this.SayHello();
Console.WriteLine("I speak English.");
}
#endregion
}
public class GermanSpeaker : Speaker
{
public GermanSpeaker() { }
#region ISpeaker Members
public override void Speak()
{
Console.WriteLine("I speak German.");
this.SayHello();
}
#endregion
}
public class SpanishSpeaker : Speaker
{
public SpanishSpeaker() { }
#region ISpeaker Members
public override void Speak()
{
Console.WriteLine("I speak Spanish.");
}
public override void SayHello()
{
throw new ApplicationException("I cannot say Hello World.");
}
#endregion
}
将接口视为对象与其客户之间的契约。也就是说，接口指定了对象可以执行的操作，以及用于访问这些内容的签名。
实现是实际行为。比方说，你有一个方法sort（）。您可以实现QuickSort或MergeSort。只要接口没有改变，这对调用排序的客户端代码无关紧要。
像Java API和.NET Framework这样的库大量使用接口，因为数百万程序员使用提供的对象。这些库的创建者必须非常小心，他们不会更改这些库中的类的接口，因为它会影响使用该库的所有程序员。另一方面，他们可以根据自己的喜好改变实施方式。
如果作为程序员，您对代码进行编码，那么一旦它发生更改，代码就会停止工作。所以以这种方式考虑接口的好处：
- 它隐藏了你不需要知道的东西，使对象更容易使用。
- 它提供了对象如何表现的契约，因此你可以依赖它
这意味着您应该尝试编写代码，以便它使用抽象（抽象类或接口）而不是直接实现。
通常，实现通过构造函数或方法调用注入到代码中。因此，您的代码知道接口或抽象类，并可以调用此合同上定义的任何内容。作为实际对象（接口/抽象类的实现），使用对象进行调用。
这是Liskov Substitution Principle（LSP）的一个子集，SOLID原则的L。
.NET中的一个例子是使用IList而不是List或Dictionary进行编码，因此您可以在代码中使用任何可互换地实现IList的类：
// myList can be _any_ object that implements IList
public int GetListCount(IList myList)
{
// Do anything that IList supports
return myList.Count();
}
来自基类库（BCL）的另一个例子是ProviderBase抽象类 - 这提供了一些基础结构，并且重要的是意味着如果您对它进行编码，所有提供程序实现可以互换使用。
这个陈述是关于耦合的。使用面向对象编程的一个潜在原因是重用。因此，例如，您可以在两个协作对象A和B之间拆分算法。这可能对以后创建另一个算法很有用，该算法可能会重用两个对象中的一个或另一个。但是，当这些对象进行通信（发送消息 - 调用方法）时，它们会在彼此之间创建依赖关系。但是如果你想使用一个没有另一个，你需要指定如果我们替换B，其他对象C应该为对象A做什么。这些描述称为接口。这允许对象A在不改变的情况下与依赖于接口的不同对象进行通信。您提到的声明说，如果您计划重用算法的某些部分（或更一般地说是程序），您应该创建接口并依赖它们，这样您可以随时更改具体实现而不更改其他对象如果您使用声明的接口。
如果你要在Combustion-Car时代写一个汽车类，那么你很有可能将oilChange（）作为这个类的一部分来实现。但是，当电动汽车推出时，你会遇到麻烦，因为这些汽车没有换油，也没有实施。
该问题的解决方案是在Car类中使用performMaintenance（）接口，并在适当的实现中隐藏详细信息。每种Car类型都会为performMaintenance（）提供自己的实现。作为汽车的拥有者，你必须处理的是performMaintenance（），而不用担心在有变化时进行调整。
class MaintenanceSpecialist {
public:
virtual int performMaintenance() = 0;
};
class CombustionEnginedMaintenance : public MaintenanceSpecialist {
int performMaintenance() {
printf("combustionEnginedMaintenance: We specialize in maintenance of Combustion engines
");
return 0;
}
};
class ElectricMaintenance : public MaintenanceSpecialist {
int performMaintenance() {
printf("electricMaintenance: We specialize in maintenance of Electric Cars
");
return 0;
}
};
class Car {
public:
MaintenanceSpecialist *mSpecialist;
virtual int maintenance() {
printf("Just wash the car
");
return 0;
};
};
class GasolineCar : public Car {
public:
GasolineCar() {
mSpecialist = new CombustionEnginedMaintenance();
}
int maintenance() {
mSpecialist->performMaintenance();
return 0;
}
};
class ElectricCar : public Car {
public:
ElectricCar() {
mSpecialist = new ElectricMaintenance();
}
int maintenance(){
mSpecialist->performMaintenance();
return 0;
}
};
int _tmain(int argc, _TCHAR* argv[]) {
Car *myCar;
myCar = new GasolineCar();
myCar->maintenance(); /* I dont know what is involved in maintenance. But, I do know the maintenance has to be performed */
myCar = new ElectricCar();
myCar->maintenance();
return 0;
}
以上是关于“程序接口，而非实现”是什么意思？的主要内容，如果未能解决你的问题，请参考以下文章