What's the difference between Abstract classes and Interfaces?

Garegin Gulyan

What's de advantage ov Interfaces and vice versa the advantage of the Abstract Classes

Thanks

Geert Verhoeven

An abstract class is a class that can not be instantiated but that can contain code.
An interface only contains method definitions but does not contain any code. With an interface, you need to implement all the methods defined in the interface.

If you have logic that will be the same for all the derived classes, it is best to go for a abstract class in stead of an interface.

You can implement multiple interfaces but only inherit from one class.

Greetz,

Geert

 

Geert Verhoeven
Consultant @ Ausy Belgium

My Personal Blog

Ernst Kuschke

A good way to distinguish between a case for the one or the other for me has always been the following:

1. Are there many classes that can be "grouped together" and described by one noun If so, have an abstract class by the name of this noun, and inherit the classes from it. (A key decider is that these classes share functionality, and you would never instantiate just an Animal... you would always instantiate a certain kind of Animal: an implementation of your Animal base class)
Example: Cat and Dog can both inherit from abstract class Animal, and this abstract base class will implement a method void Breathe() which all animals will thus do in exactly the same fashion. (I might make this method virtual so that I can override it for certain animals, like Fish, which does not breath the same as most animals).

2. What kinds of verbs can be applied to my class, that might in general also be applied to others Create an interface for each of these verbs.
Example: All animals can be fed, so I will create an interface called IFeedable and have Animal implement that. Only Dog and Horse are nice enough though to implement ILikeable - I will not implement this on the base class, since this does not apply to Cat.

As said by someone else's reply: the main difference is where you want your implementation. By creating an interface, you can move your implementation to any class that implements your interface.
By creating an abstract class, you can share implementation for all derived classes in one central place, and avoid lots of bad things like code duplication.

Figo Fei - MSFT

Hi, Garegin

An abstract class can contain internal member variables, and can contain basic behaviour in the form of methods that have been coded.

An interface can have neither of the two.

Since it is a frequently asked question, you can see the following answers by others:

http://en.csharp-online.net/Interfaces_and_Abstract_Classes

http://www.codeproject.com/csharp/abstractsvsinterfaces.asp

http://forums.microsoft.com/MSDN/ShowPost.aspx PostID=1118027&SiteID=1

If you have further questions, pls feel free to let us know. Thank you.

Jim Tomasko

Good question... interfaces and abstract classes have so much in common it's hard to make a desision at times.

Here's a quote from "The Complete Reference C# 2.0" by Herbert Schildt that I like:

"When you can fully describe the concept in terms of "what it does" without needing to specify any of "how it does it", then you should use an interface. If you need to include some implementation details, then you will need to represent your concept in an abstract class."

Happy designing,

Jim Tomasko

Garegin Gulyan

Thanks for such a good example!

Hope we'll learn many things from each other.

Garegin Gulyan

Thank You.

Garegin Gulyan

Thanks for such good links.

Matthew Watson

There are three fundamental difference between interfaces and abstract base classes, two of which have already been described in this thread:

1) Abstract base classes can include code (methods).
2) Abstract base classes can include data (fields).
3) You can multiply-inherit from interfaces, but you cannot multiply-inherit from abstract base classes.

Ernst Kuschke

I prefer not to use the term "inherit" when talking about interfaces - an interface is implemented

An interface describes in which ways a class can be "interfaced" (or interacted) with at runtime; you can interact with the same object in multiple ways. When my class implements both IEnumerable and IDisposable, it does not inherit from multiple supers, but I can interact with this object in the ways described by the interfaces it implements (without knowledge of the actual type of the class!)

Matthew Watson

Maybe so, but the terms tend to be used interchangably even within the official documentation:

http://msdn.microsoft.com/library/default.asp url=/library/en-us/csref/html/vcreftheinterfacetype.asp

SeanV

I think Ernst meant that a class that implements an interface doesn't "inherit" from the interface. (Although interfaces can inherit from other interfaces, which I believe is what the link is talking about.)

Ernst Kuschke

Hey Sean, that's exactly what I meant
Even though these terms are 'officially' interchangable, I prefer to differentiate between them. Just personal opinion.