Java Programming Tutorial - 55 - Introduction to Polymorphism Video Lecture

what is going on guys welcome to your
55th java tutorial and in this story
we're going to be getting into
polymorphism a little bit and also
talking about or building something
called a polymorphic array to a
demonstrate why polymorphism is actually
useful and it's a pretty confusing topic
and trust me they're going to be a lot
of tutorials on this so if you're not
quite sure what's going on by the end of
this tutorial then I promise you in a
couple of tutorials you'll be a pro on
polymorphism so in order to demonstrate
polymorphism we first need to build a
computer program that uses inheritance
in one way or another so what I did is I
set up and you can probably tell this if
you watch my last tutorial I'm going to
have a superclass called food in this
tuna class in Popeye class since they're
both types of food they're going to
inherit all the methods and variables in
this food class so the food is a
superclass in the tuna and Popeye or sub
classes I already put extends food in
what extends food does is using a
heritance to inherit everything for food
but you should know that already if you
all watch my other tutorials just for
the people who just started that's what
I'm doing so now let's go ahead and
build a basic method called eat in food
so void eat won't take any parameters
and what it will do is pretty much go
system print online pretty much
system.out.print line and it's going to
say take it there exists some out print
line um this food is great and now what
tuna and Popeye does anytime you call
the eat method it would say this food is
great now that's nice and all but
another thing about polymorphism and I'm
just going to do this for demonstration
purposes we can over ate the eat method
that if we put it in the tuna class and
called it it'll say this tuna is great
now and let's just do that one more time
with Popeye this Popeye is great so even
though it's inheriting the eat method
from the food class we overwritten it
or overrode it with putting a new eat
method inside the tuna and potpie class
so now when you call the eat method in
tuna it says this tuna is great and now
when you call the eat method in Popeye
it says this potpie is great so now
let's get into polymorphism now that we
have a program that uses inheritance
what polymorphism is is pretty well
first let me describe to you how we
built on reference variables and objects
before we did something like tuna
Bucky equals new tuna and we didn't
really think about what we were doing we
just did it because that's how we were
taught but if you're wondering ah right
why do I need to put tuna right here and
tuna right here is well shouldn't I only
have to put it once to know that I'm
talking about that class well the thing
is well first let me go over what these
are this right here Bucky is the
reference variable that means whenever
you refer to the variable Bucky you're
fairly you are referring to controlling
the stuff in this class or object which
is tuna and this pretty much is the data
type so it can control the tuna data
type and this object is of type tuna but
another cool thing is you can do this
and this pretty much is the intro to pot
pull look look chicka-boom chicka-boom
pond sorry this pretty much is the intro
to polymorphism not only is tuna of the
tuna type but tuna is also of the food
type so what you can do is some pretty
cool things anything that inherits from
the super class which is tuna or excuse
me the super class is food can be
assigned to Bucky for example tuna since
this inherits from food can be assigned
to Bucky Popeye sense it inherits from
food can be assigned to Bucky interests
A&R a that's nice to know I can assign
this that and the other thing but why
actually would this be useful in any
kind of way well the answer that I will
do one thing which you guys probably
need and that's an example
the quickest example in the most clear
thing I can do is build something called
a polymorphic array and this stores
objects of different classes in pretty
much the superclass type so let's go
ahead and say we have food and that's
the type and let's go ahead and make an
array object named Bucky and we'll set
this equal to new food to so now we have
an array and it's called Bucky and it's
of the food type and remember like I
said since we have something of the food
type it can hold objects of tuna and
potpie so for example Bucky zero can
hold objects of new potpie just like
that and we'll set Bucky 1 which is a
reference variable and we'll set this
equal to the object of new tuna and
you're saying all right well that's
still great you have one variable that
can hold an object and another very
variable that can hold an object yeah
these variables might be of the food
class but I don't see why this is useful
still well just wait a minute and trust
me you'll see why in a little bit one
reason for using polymorphism is to use
polymorphic arrays and that would be
something like this you loop through
this array and in essence what it does
is it calls each method of this class
right here so let's go ahead and type
for int x equals zero and just put
something like X is less than 2 you can
also put array length but you know you
don't want to and do plus plus X and now
what we can do is say something like
this Bucky X Y dot eat and what this is
going to do is loop through each one of
these objects and call the eat method so
it's going to loop through the first
object which was assigned Bucky zero
Popeye and it's going to call Popeye dot
eat which is say this Popeye is great
the next thing it's going to do is loop
through the tuna object which is tuna D
and then then it says this tuna is good
so then you save yourself the trouble of
making a new object called tuna tuna
object then you go tuna e and then you
have to make an object and you have to
call each method and I just got rid of
my curly brace right there so what this
pretty much does is loop through each of
your objects and calls the eat method
for each one don't believe me I'll run
it right here it says this Popeye is
great this tuna is great BAM
how easy is that so that is pretty much
your basics the polymorphic polymorphic
array you can assign different objects
to variables as long as this reference
variable is of the superclass type in
that way instead of having to build a
new object for each one of your you know
having to build a new object every time
you want to use a method from that thing
you can build one um reference variable
of the superclass and assign it to
objects of the subclasses and just loop
the room with a polymorphic array so how
cool is that and I know it's really
confusing at first but once I show you
some other examples aside from
polymorphic arrays you're going to
understand exactly how to use this how
it works and you'll be a pro at it so
for now thank you guys for watching
don't forget to subscribe and if you
have any questions just leave me a
comment and I'll try to answer them so
thank you guys for watching again and
I'll see you next time