[MUSIC]

Interfaces and abstract classes can accomplish many of the same goals.

They also have their own unique objectives.

If you want to guarantee that specific classes provide specific functionality,

then an interface is a great tool.

An interface defines what should happen but

doesn't define how that needs to happen.

This is extremely useful when sharing code between projects.

I don't need to worry about how someone else, or even my past self,

implements their code, I just need to be able to interact with that code.

One of the most challenging parts of writing software

is the mental load of storing all the information about how each piece of code

interacts with every other piece of code.

If I make a change in one place, what am I going to break somewhere else?

Many programming philosophies and

tools deal directly with minimizing this challenge.

The key to solving this challenge lies with encapsulation.

Encapsulation allows us to give control of specific functionalities to

individual objects, allowing us to focus on just the information needed

to leverage the functionality each object controls.

Because my own limited memory no longer has to store the inner workings of

the entire application, I can more quickly add features and bug fixes.

This also allows new developers to become productive more quickly.

Because they do not have to understand the inner workings

of the entire application all at once.

By implementing multiple interfaces, I can group functionality

into smaller parts that can be used throughout my application.

The limitation of interfaces is that they do not

actually store any implementation details themselves.

Each class that implements an interface must write their own methods.

Changing an interface requires changing every implementing class,

because there's no default implementation.

To share implementation details between classes,

you can harness the power of inheritance, creating a parent or

super-class from which any number of classes can be extended.

By declaring the parent class as abstract,

we prevent that class from being directly instantiated.

Abstract classes also give us the ability to define abstract methods

that must be implemented by any extending children.

The main limitation of an abstract class is the same as any other class.

You can only inherit from one class at a time.

I have put together a chart that lays out the similarities and

differences between these constructs.

Can it be instantiated?

Does it allow for multiple inheritance?

Can you define contractual functions?

Does it contain implementation details?

Can you make a change that is shared by everything that uses this construct?

All methods required to be public?

Can you define properties?

Can you define constants?

Can you override these constants?

Can you type check for this construct?

Check the notes associated with this video for a printable version of this chart.

By combining interfaces and

inheritance, we can make use of the best qualities of each construct.