抽象类优于接口的优点

Question

I got the following statement from an MSDN article . It says that the abstract classes have an advantage over interfaces because it is possible to alter an abstract class to add new members. Doesn't altering the abstract class really make the classes inheriting from it unstable? Or can any one please explain what is their point here?

Do favor defining classes over interfaces.

In later versions of your library, you can safely add new members to classes; you cannot add members to interfaces without breaking existing code.

Answer 1

Say you have an interface

public interface Animal 
{
     void Sleep();
}

you release your library and you find out you need to add a property to the interface.

public interface Animal 
{
     int Age{get;set;}
     void Sleep();
}

All the code that every one wrote against the first version of the interface would no longer compile forcing an upgrade. If you released the first version with this abstract class.

public abstract class Animal 
{
    public abstract  void Sleep();
} 

Now you need to add another property

public abstract class Animal
{
    public virtual int Age{get;set;}
    public abstract  void Sleep();
} 

In this case there is no need for users to change there code.

Answer 2

Assume that you writing code and use some interface ( IExample ) in a first version. In the second version of your program you understand that IExample should have a method called IExample.NewMethod . If you extend IExample with this method, automatically all code you wrote before will be broken because all classes which inherited from IExample will be not implement this interface completely - so code will not be compiled. It's correct if we talking about this case only. This problem could be fixed with using new interface ( INewExample ) inherited from IExample , or just creating new interface without inheritance

But interface have some advantages for abstract class also. Interfaces encapsulated realization of your code much better than abstract classes. Also you could use interfaces for different classes, but when you use abstract classes it should means that your class is abstract class somehow (for example Circle is a Shape so you can inherit Circle from abstract Shape ) but it really bad idea to inherit Circle from Car for example even if they have the same interface

To read complete overview of interface VS abstract classes I advice you Kent Beck's book and Code Complete for inheritance in general

Answer 3

It's not to be taken too strictly. Programming through interfaces (as contracts) is really the best way to decouple your application. For example, creating a wrapper around an interface is very easy, while a class doesn't even have to have a single virtual method.

Additionally, the article doesn't even seem to compare abstract classes to interfaces (because it only mentions them in the next "guideline"), but all classes in general over interfaces. So, it's a rather fuzzy guideline, if you ask me.

It might make sense exclusively with the problem stated: changing an interface breaks all implementations, while adding members to a class doesn't. On the other hand, if you change a method's signature, you won't be very lucky with classes either. From a security point of view, abstract classes do provide a way to make sure that your library always exposes its own functionality to callers, allowing modifications only where you want them. With interfaces, you can pass pretty much any code which satisfies the contract.

Answer 4

The biggest advantage of Abstract class is a possibility to have internal members, where Interface can not have. On other part, you can have a multiinheritance on interfaces , but on absrtact classes not.

Answer 5

the advantage of an abstract class is that you can implement common functionality. with an interface, each implementing class has to provide its own implementation of the defined operations.

Answer 6

Doesn't altering the abstract class really make the classes inheriting from it unstable?

Not necessarily. As long as you don't mark your new members as virtual , any class that currently doesn't use the new members will be able to ignore them, so there is no versioning break.

or can any one please explain what is their point here?

The point is that, if you add a new member to an interface, any class that implements that interface is immediately broken because it doesn't implement the new member. There is no such build break for adding a member to an abstract class.