In C# objects, we learned that inheritance can be used to create an is

a relationship between two types.

For example, map location is a type of point.

We subclass the point class to create a new type of

point which we called map location.

Map location, by virtue that it inherits from point, also has fields for

X and Y coordinates.

Objects often share many of the same attributes and

behaviors as other types of objects.

A classic example is an animal.

All animals have similar characteristics and behaviors.

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.

But, not all animals move in the same way.

Mammals and

birds are both types of vertebrates, but they move quite differently.

In object oriented programming, we also need the ability for

objects to behave differently based on the type of object that they are.

This is called polymorphism.

And it's one of the core principles of object oriented programming.

Let's see what this looks like in code.

Let's create a new type of invader.

First let's create a new file.

We will call our new invader type shielded invader.

So we'll name this file shielded invader.cs.

We'll copy the namespace and class name from invader paste

it in shielded invader and add the closing curly braces.

Instead of invader, we want our class to be named shielded invader.

And we want it to inherit from invader.

We'll add a constructor that takes a path parameter and all this constructor will do

is pass the path parameter up to the constructor of the base class like so.

Now we have a new type of invader.

As the code stands right now,

shielded invader behaves exactly like the original invader class.

That's because it inherits all of the attributes and behaviors from invader.

Let's make it so that when a shielded invader is hit,

there's a chance that it won't sustain any damage.

For that we need to change the way decrease health method works.

But wait, the decrease health method is in the invader class definition.

We don't have it here in ShieldedInvader.

Let's take a look at the decrease health method in invader.

When the decrease health method is called,

it will decrease the health of the invader by the factor passed in.

This is exactly how we want it to work for most invaders.

But if the invader is a shielded invader,

we don't always want to decrease the health every time the method is called.

One way we could implement this is to check if the current object

is an instance of shielded invader.

We can type, if(this is ShieldedInvader),

then do something here.

Else decrease health by the factor passed in.

There are many problems with writing code like this.

For one, it requires the invader class to know about the other classes that

inherit from it.

This is not an extendable way to add new types of invaders because

we have to change the invader class each time we want to add a new type of invader.

Also, our elegant single line method would end up being polluted

by code that doesn't directly have to do with this specific type of invader.

We could eventually end up with a lot of these if this is statements here.

The is operator is C#'s way of checking to see if an object is of a certain type.

When I find myself tempted to write a bunch of type checks like this,

it's a tell tale sign that I should make the class polymorphic.

This means, making it so that subclasses of this class can provide

their own implementations of decreased health.

The word polymorphic means to have many forms.

Just like how birds move differently,

shielded invaders should have a different way to decrease help.

We can make it possible for subclasses to provide their own implementation of

decreased health by adding the keyword virtual to the method here.

Adding virtual is telling C# that this is just one possible implementation of

the decrease health method and

subclasses can provide their own implementations of this method.

Let's copy the declaration and paste it in ShieldedInvader.

And we'll add the curly braces here.

Because this is a subclass, we need to change the virtual here to override to

show that ShieldedInvader is overriding the virtual method of the invader class.

In C# objects, we learned about the random class and it can help us out here as well.

Let's create a static random instance in the shielded invader and call it random.

Then in DecreaseHealth, we'll say, if(random.Nextdouble

Is less than .5, Then call

the base classes DecreaseHealthMethod and pass in the factor.

Next double returns a random number between zero and one.

Because it is uniformly random, half of the time,

this number will be less than 0.5.

So the body of this if statement will only be executed 50% of the time.

Here we just call the base classes,

that is the normal invaders, decrease health method.

We do this by typing base.

It's not enough to just type decrease health,

because now there are two decrease health methods that can be called.

We need to specify which one we want called.

You should know that overridden methods don't have to call the base classes

method.

We could have done something other than call base.decrease health.

It just so happens that what we want to do here is what is already done

in the base classes decrease health method.

Now when towers attempt to decrease the health of a shielded invader,

they will be successful only half of the time on average.

Other than its implementation of decrease health,

a shielded invader is exactly like a normal invader.

We would not have wanted to write an entirely new shielded invader class that

was just a copy of most of the code of the invader class.

Instead we're reusing most of the functionality of the Invader class and

making one small alteration to make the shielded Invader class.

The really neat thing about this is that all of the code that is

already designed to work with the based Invader type

will also work with the shielded Invader type without making any changes.

A shielded invader is still an invader, it's just been enhanced a bit.

So we can go to Game.cs and change one of these invaders here to ShieldedInvader.

Notice that this is still an array of invaders.

We don't have to change anything else.

These invaders get past the level which knows about the base invader type.

There is no reference to ShieldedInvader in here.

In the play method, these invaders get passed through the towers

FireOnInvaders method.

See here again, there is no reference to a shielded invader yet, but

all this code will still work.

When decrease health is called on an invader,

that is a normal invader, its health will be decreased.

However, if decreased health is called on an invader that is actually

of type shielded invader, it may or may not suffer damage.

To really see what's going on, let's move this console output.

We'll reprint shot at and hit an invader to the invaders decrease health method.

We could add a using system directive to the top of the file, but

instead we'll just add the namespace name here.

Now in ShieldedInvader's DecreaseHealthMethod,

let's add some output here too.

If the shield block the shot,

we'll say System.Console.Writeline and

print (Shot at a shielded invader but

it sustained no damage.") Let's compile this

to make sure that we didn't introduce any compilation errors.

We'll say msc- out:TreeHouseDefense, *.cs.

Now let's run it to see what we get.

As you can see,

even though fire on invaders accepts an array of the base invader type, we still

get different behavior when decreased health is called on a shielded invader.

That's because the DecreaseHealth method is

overridden in the shielded invader class.