We just saw how we can group together different objects

by using an array with a common base class.

Now let's see how to use a cast so we can call makeSound on our dog object.

First, since we got rid of our dog variable, let's make a new one.

Let's add a new line after our object array and type dog.

And we'll name it dog, and set it equal to the first item in our array.

So list at position 0, which gives us an incompatible types error.

This is where the cast comes in.

A cast, or type casting, is when you tell Java that an object

is a more specific descendant of that object.

Essentially moving the object up its family tree.

For example, if we were storing a car as a vehicle object and

needed to turn it back to a car object, we would use a cast.

To use a cast, you just write the name of the class between parentheses.

So right after the equal sign,

let's add a cast to change list 0 to a dog object.

So parenthesis and inside them we write the class, Dog.

Nice, it doesn't look like we have any errors.

And if we run it, We get the right output.

But before we move on,

let's see what happens if we try to merge these two lines.

Let's hide the run panel, and then delete line seven,

and change dog to list at position zero.

Then let's add the cast, and it doesn't work.

It turns out that the call to makeSound happens before the cast.

So to make sure that the cast happens first,

we just need to use some parentheses.

Okay, we've got an array of objects and

seen how we can use casts to move an object up its family tree.

But this only works because we know exactly where our dog is in the array.

If we accidentally tried to cast our dog food object to a dog,

we'd crash the program.

And just to make sure, Yep, we get a class cast exception.

Cmd or Ctrl+Z to undo, and we're back to working code.

So instead of just picking out the dog object,

let's loop through our list array and only call makeSound if the object

actually has a makeSound method, meaning the object is an animal.

Let's delete line 7 again, and let's use a for each loop to loop through our array.

For object, we'll call it object, and,

which is represented by a colon,

our list array, and add the brackets.

And inside the for loop, we need to determine if this object is an animal.

Luckily, there's a keyword for this.

Let's write an if statement.

And for the condition, let's check that object, instance of.

Animal.

And notice that instanceof is all one word and all lowercase.

Using the instanceof operator allows us to check if one object

is an instance of another.

So inside the if statement,

after we add our brackets, object is guaranteed to be an animal.

However, even though it's guaranteed to be an animal, we'll still need to cast it.

Let's type object., and choose makeSound

to have IntelliJ automatically add the cast and call the method.

Awesome, now let's run the app.

And perfect, we're still getting the same output.

Using casts and the instance of operator

gives us a lot more freedom with how we handle our objects.

Why don't you get a little more practice, and

in the next video, we'll take a deeper look at the object class.