Interfaces: when to use and why?

[CJ]

G'day folks,

I still can't figure out when to use interfaces in class and component diagrams.

If an interface is used to describe the operations that one or more classifiers implement, then why not create an abstract class that the same classifiers can generalize?

Would that not give the same result?  I don't understand (actually, I think I can, but it's "on the tip of my tongue" ... almost have my finger on it) what advantage an interface (realized by classifiers) would have over an abstract class (generalized by classifiers).

Help?

[sargasso]

A couple of points.

1) Interface elements as a design component that are added "late" in the design process.

Interfaces can resolve multiple inheritence designs when the implmentation language doesn't support mulitple inheritence - e.g. c#.

These become physical implementation items - used by the compilers to enforce compliance of classes to the interface "contract".

2) Interfaces as analysis elements in deployment structuring (aka "component based systems")

In these types of models we can use interface elements to specify behavioral compliance of (interchageable) components.  The interfaces are not implementation items but allow compliance checking at the model level.



I am sure there are other more compelling reasons for implementation level interface elements but I'll leave that to those who know more than I.

hth
Bruce

[KP]

What a great question for a Friday afternoon!

An abstract class describes the core essence of the sub-classes derived from it; an interface describes what can/must be done. A car is a vehicle that can be steered left or right: define vehicle as an abstract class, steerable as an interface. Then when you want to steer a herd of cattle...

If you are given a class that somebody else has created, you can bolt on an interface without touching any of their code. With an abstract class, you would have to perform a major re-design to bolt on the inheritance after the fact.

An abstract class can provide default code, an interface can't. So if you want to add a new method to an interface you will have to track down every implementor in existence and give it some extra code. If you add a new method to an abstract class, all you need to do is re-compile (and hope).

I'm sure there are other issues to take into account, e.g. interfaces possibly have a speed overhead from the extra level of indirection. I'll leave that to others...