On the surface abstract base classes appear to be more

flexible than interfaces.

They allow us to declare both public and

protected members, that some classes must have and they can also contain code.

Interfaces on the other hand can only declare the public members that subclasses

must have and that's it.

It's easy to see why we want to use abstract base classes, but why interfaces?

Let's explore why interfaces are so useful in C#.

You may think that interfaces are more restrictive versions of

abstract base classes, but in fact, they serve different purposes.

Abstract base classes are used to contain code that should be shared by the concrete

subclass implementations.

The implementations of all the non abstract members of the invader class

are inherited by its subclasses.

Each subclass doesn't have to create their own implementation.

This is an advantage to use in an abstract base class.

On the other hand C# only allows classes to inherit directly from one other class.

Being able to inherit directly from multiple base classes is known as multiple

inheritance.

Multiple inheritance can cause a lot of problems so it isn't allowed in C#.

Think of the case when two base classes both have methods that look identical.

Which method implementation should be inherited in the subclass?

Instead of multiple inheritance C# allows a class to Implement multiple interfaces.

A class can implement as many interfaces as needed.

An interface does nothing about the members' implementation.

So, it doesn't matter if two interfaces both have the same member with

the same signature.

The class only needs to provide one implementation of the member

to satisfy the interface.

An interface can also inherit other interfaces.

Let's break up the Iinvader interface into a couple different interfaces.

We can break the location property out Into another interface or just cut it from

here, Go up here and we'll create a new interface called IMappable.

We'll move the property here.

So now any class that implements the IMappable interface

must have a public map location property that provides at the very least a getter.

Just like how classes can implement multiple interfaces,

interfaces can also inherit from multiple interfaces.

Let's create an interface named IMovable.

So say, interface I Move able.

This one will require a single method named,

Move which will take from the IInvader interface.

There we go.

To inherit from multiple interfaces, we simply list them after the colon and

separate them with commas.

So we'll have the IInvader interface inherit the IMappable and

the IMovable interface.

This is the same way that a class can implement multiple interfaces.

We just list them here after the colon,

just like we do when we inherit from another class.

Now anything that implements the IInvader interface must also implement

the IMappable and IMovable interfaces.

That means in addition to having to have a HasScored, Health, IsNeutralized,

IsActive and DecreaseHealth members, they also have to have Move and Location.

The usefulness of interfaces isn't obvious right away, but they're important in good

object oriented design and they make extending and maintaining code easier.

The point of an interface is to only expose what is

absolutely needed by the code that is using the class.

This gives us the greatest flexibility when writing classes

the implement the interface.

We only need to match the interface.

Say for example that we had a method that only needed to call the Move method

on one of its parameters.

We could code it so that it only expected a parameter of the type IMoveable.

We could past that method any object of type IMovable,

IInvader is a type IMovable and so is IInvader.

And by extension so are all of the other invader subclasses.

In fact,

we could even pass the method a class that had nothing to do with being an invader.

Say for example, we had a class named Bird that implemented the IMovable interface,

we could also pass it to the method that expected in IMovable.

Even though bird is nothing like an invader,

they both have a Move method because they implement the IMovable interface.

Can you see how using interfaces in our code gives us the most freedom

in how we wire up our objects?

Combining new interface with an abstract base class is a common pattern.

It allows us to have the flexibility of an interface and

also provides a mechanism to share code among subclasses.

In the next video,

we'll see how we can leverage the power of the IInvader interface to create a new

type of invader that doesn't inherit from the invader base class at all