我们知道接口和抽象类之间基本上有两个重要的区别。
我们可以在抽象类中定义函数。当我们想在一个类中添加一个函数而不需要跟踪它的所有实现时，这是有优势的。
我们可以有多个接口实现。
我刚了解到我们可以从耦合的角度区分它们?
您的评论...
如果您能够提供一个非常基本的链接，用于解释接口和抽象类的解耦合，那就更好了？
我们通常使用业务逻辑层，数据访问层(包含抽象函数)和DataAccess.SqlServer Layer。 对吧？尽管我们了解业务需求，但为什么我们要创建数据访问层(包含抽象函数)，而不能让业务逻辑层直接访问DataAccess.SqlServer Layer？
解耦
在编程和设计中，通常是尽可能少地依赖其他模块来创建可重用的代码。
工厂模式在这个上下文中
使用工厂模式时，您有一个集中的工厂可以创建对象，而不必自己定义它们。这将由对象的定义确定。
抽象和接口
接口
定义接口是最佳实践，因为它允许使用轻量级类型进行推断，并提供了一个蓝图，所有继承类都必须遵守。例如，IDisposable 必须实现 Dispose 方法。请注意，这与接口解耦，因为继承 IDisposable 的每个类都将定义其自己的 Dispose 方法函数。
抽象
抽象类类似于接口，因为它用于继承和推断，但它包含所有类都将继承的定义。比如每个汽车都会有一个引擎，所以汽车的一个好的抽象类可以包括一组预定义的引擎方法。
说明
这里您将看到一个使用接口和抽象类的简单继承示例。当接口被抽象类继承并自定义其方法时，解耦发生。这允许类继承抽象类并仍然具有与接口相同的类型。优势在于，继承抽象类的类可以在预期类型为原始接口时使用。
解耦
该优势允许使用符合预期接口的任何��现。因此，可以编写并传入许多不同的重载。这是一个例子。
示例
接口定义
public interface IReady
{
bool ComputeReadiness();
}
继承
public abstract class WidgetExample : IReady
{
public int WidgetCount { get; set; }
public int WidgetTarget { get; set; }
public bool WidgetsReady { get; set; }
public WidgetExample()
{
WidgetCount = 3;
WidgetTarget = 45;
}
public bool ComputeReadiness()
{
if (WidgetCount < WidgetTarget)
{
WidgetsReady = false;
}
return WidgetsReady;
}
}
public class Foo : WidgetExample
{
public Foo()
{
this.WidgetTarget = 2;
}
}
public class Bar : IReady
{
public bool ComputeReadiness()
{
return true;
}
}
脱耦
public class UsesIReady
{
public bool Start { get; set; }
public List<string> WidgetNames { get; set; }
//Here is the decoupling. Note that any object passed
//in with type IReady will be accepted in this method
public void BeginWork(IReady readiness)
{
if (readiness.ComputeReadiness())
{
Start = true;
Work();
}
}
private void Work()
{
foreach( var name in WidgetNames )
{
//todo: build name
}
}
}
多态性
public class Main
{
public Main()
{
//Notice that either one of these implementations
//is accepted by BeginWork
//Foo uses the abstract class
IReady example = new Foo();
UsesIReady workExample = new UsesIReady();
workExample.BeginWork(example);
//Bar uses the interface
IReady sample = new Bar();
UsesIReady workSample = new UsesIReady();
workSample.BeginWork(sample);
}
}
WidgetExample 类标记为抽象类。它没有公开任何应该由子类实现的抽象方法。 - mipe34仅为了解耦而进行解耦是徒劳无功的。
接口旨在用于集成，其中不需要知道具体细节即可使用（例如SendEmail()）。常见用途包括组件、服务、存储库以及作为IOC和通用实现的标记。
包含接口的泛型类型约束的扩展方法允许类似于Scala中发现的特征的功能，具有类似的可组合性。
public interface IHasQuantity { double Quantity { get; } }
public interface IHasPrice { decimal PricePerUnit { get; } }
public static class TraitExtensions
{
public static decimal CalculateTotalPrice<T>(this T instance)
where T : class, IHasPrice, IHasQuantity
{
return (decimal)instance.Quantity * instance.PricePerQuantity;
}
}
我不会讨论这两种构造的优缺点，因为已经有了足够的资源。
然而，就“解耦”一个组件与另一个组件而言，在接口继承方面比抽象类或一般类继承更好（实际上，我认为抽象或非抽象并没有在解耦方面做出太大区别，因为所有abstract所做的就是防止在没有具体实现的情况下实例化类）。
以上观点的原因是，接口可以将“依赖组件”所需的最小暴露范围缩小到绝对最小程度，如果它需要单一方法则接口可以很容易地实现，甚至可以是没有任何方法的标记接口。通过基类（抽象或具体），这可能会很困难，因为它应该为该基类实现所有“共同”功能。因此，依赖于“基本类型”的组件将自动“看到”即使它们不需要它们以用于其目的的所有通用功能。
接口还给你最大的灵活性，因为即使从没有共同之处的基类继承的类仍然可以实现一个接口，并被期望该接口的组件使用。 IDisposable接口是很好的例子。
因此，我的结论是，为了解耦所有组件都应该依赖于接口而不是基本类型，如果您发现大多数实现该接口的类具有共同的实现，则需要一个实现该接口的基类，并从该基类继承其他类。
理解和记住接口和抽象类之间的区别最好的方法是记住抽象类是一个普通类，你可以用抽象类做任何你可以用普通类做的事情，只有两个例外。
核心区别在于：
接口公开零个或多个方法签名，所有的子类都必须实现（否则代码甚至无法编译）。接口公开的方法可以隐式实现（每个从接口派生的类型都可以访问它们），也可以显式实现（只有将对象强制转换为接口类型本身才能访问方法）。更多细节和示例可以在这个问题中找到。
抽象类公开零个或多个完整的方法，后代可以使用或覆盖它们，并提供自己的实现。这种方法允许您定义可定制的“默认”行为。抽象类允许您轻松添加新方法而不会出现问题（当向抽象类添加方法时，NotImplementedException真正发挥作用），而将方法添加到接口需要修改实现它的所有类。
最后一点是，一个类可以同时实现多个接口。一些现实世界的例子可能是：
编辑1
这里是一个MSDN链接，解释如何在接口和类之间进行选择。
public interface Polymorphism{
void run();
Void Bark();
Energy getEnergy(Polymorphism test);
Public abstract class EnergySynthesis implements Polymorphism{
abstract void Energy();
Void Bark(){
getEnergy(){
}
void run(){
getEnergy();
}public EnegyGeneartion extends EnergySynthesis {
Energy getEnergy(Polymorphism test){
return new Energy( test);
}
MainClass{
EnegyGeneartion test=new EnegyGeneartion ();
test.getEnergy(test);
test.Bark()
.
.
.
.
.
//here in Energy getEnergy(Polymorphism test) any class can be passed as parameter that implemets interface