[MUSIC]

In the first part of this course we wrote a class that models a point.

It has x and y fields and

even has a method that calculates how far it is from another point.

The Treehouse defense game uses this class to identify locations on the map.

But it could be used for a lot more than that.

Lots of software applications use x and y coordinates to identify a location.

Perhaps the next game we write will also need a point class.

Software that displays charts and graphs also needs points.

If we keep our implementation of the point class as general purpose as possible,

we can reuse it in all those different applications.

What if we need to add something to the point class that's specific

to Treehouse defense?

For example what if we wanted to make it impossible to create a point that

isn't on the map?

Making a change like that to the point class would make it unusable to

all other applications that don't have maps.

We don't want to add code to a general purpose class that we're

fairly certain won't be useful to other users of the class.

We also don't want to create a new class that's specific to Treehouse defense and

rewrite everything we wrote for the point class.

What we want is to create a new class that has our new functionality, but

also reuses the point class.

The principles of object-oriented programming

provide lots of ways to reuse and extend existing classes.

One of them is called inheritance.

There are four core principles of object-oriented programming.

Encapsulation, inheritance, polymorphism and abstraction.

By saying that C# is an object-oriented programming language, we're really saying

that C# has features built into the language to support these four principles.

As you can see, inheritance is one of the four core principles.

Don't worry about these other three principles right now.

We'll discuss them later.

The principle we want to focus on right now is inheritance.

You see,

many objects in the real world often share many of the same attributes and behaviors.

A classic example is an animal, all animals have similar characteristics.

For example, a defining characteristic of all animals is the ability to move.

There are two types of animals, vertebrates and invertebrates.

Vertebrates have backbones and invertebrates don't.

But they're both still animals, so they can both move.

Mammals and birds are types of vertebrates.

By saying that a creature is a mammal we're

also saying that it has a backbone and it can move.

You might say,

that it inherits these characteristics from the larger categories,

or classifications, of vertebrates and animals of which it's a member.

You can see now that the C# key word class is short for classification.

C# classes define what it means to be in a particular classification.

As we saw with the animal example, classes of animals

can have more refined classifications within them, we call these subclasses.

Subclasses inherit the attributes and behaviors of the more general classes.

So if we wanted a new type of point that inherited

all of the features of the point class, but

was more specific to our application, we just need to create a subclass of point.

Let's look at how we do that in code.