Objective-C Tutorials Lesson 34: Polymorphism Video Lecture | Learn and Understand: Objective C (English) - Web Development

what is up guys Jordan here with
objective-c de toros lesson 34 we'll be
talking about poly morphism now it's
been a long time since I did one of
these but I'm super excited to get back
into doing these and to finish out the
series and continue teaching guys how to
code so without further ado let's get
into it now quick refresher last lesson
and lesson 33 you talked about
inheritance and inheritance is just like
what inheritance is in real life you
inherit traits from your parents they're
passed down to you so we talked about
how you can put common functionality in
a superclass and then you can have
different subclasses which inherit from
that superclass they take the common
functionality but then they can add
their own specific functionality so we
haven't coded anything yet because we
first need to talk about poly morphism
so what is it well it literally means
taking many forms and there is the
actual dictionary definition from
Webster Marion dictionary the quality or
state of existing in or assuming
different forms so it's very biological
science term and that's basically what
it means in programming as well it means
the ability of different types of
objects to respond to the same message
each in their own way so right here we
have two objects you see the NF string
object which is red so that is just a
string I believe we've used that if we
haven't it would just be like Hello that
would be a string and then a UI image
user interface image that's with the UI
stands for so you have a picture and a
string of letters now we send the
message detail to both of these objects
and each one of them as you can see
represented by the different shapes they
each do something different when they
receive this
this is the this is really what
polymorphism is so you send detail to
the string you get a yellow dinant you
send detail to the image and you get
believe hexagon purple hexagon
so yeah that's what polymorphism is in a
nutshell now I've learned about
polymorphism from multiple different
sources and each one seems to kind of
take its own take on it especially when
you learn about it with regards to
objective-c and then with regards to a
programming language like Java so I'm
going to tell you all the different
explanations and kind of how I learned
it because I learned it a little bit
from an objective-c than I learned it in
Java and then like I relearned it with a
with regards objective-c so I'm going to
teach you everything that I learned and
hopefully you'll have a very clear
picture just in general polymorphism not
even specific to objective-c but just
kind of what the programming community
talks about when they talk about
polymorphism so how objective-c for
dummies explained it is the ability of
different objects to respond to the same
message so like that string in that
picture each one in its own way so that
was how objective-c for dummies said it
now programming in Objective C another
book and that I've read it said the
capability to share the same method name
across different classes so that kind of
goes a little bit more in depth about
how you would achieve the statement of
above and then they also said enables
programs to be developed so that objects
from different classes can define
methods that share the same name
basically just kind of rephrasing so you
create a set of classes with the same
method names but different
implementation for each method that's
how you're able to achieve this state
where you have different objects that
respond differently because remember
everything is programmed we are
programming so
sometimes when you hear things like this
explained do you think it just kind of
like magically happens but no I mean
your your programming the different
functionality in these methods so it's
when you send like the detail method it
is programmed to do something different
but on kind of a higher level you can
think about it where no the object is
just responds differently because it's
something different but remember that
the code for that method is different so
really basically what it comes down to
is just that you can have the same
method name but different implementation
for each method so that's kind of what
it boils down to but the way I've heard
it with Objective C explained is kind of
I liked it more than how I heard it with
Java because this is how I heard it
explained from the Virginia Tech
computer science department when I was
taking a software design class and we
were learning Java so they just
described polymorphism with method
overloading and method overriding so now
that I see it here there's was focusing
on having different method names or
having the same method name and then
different functionality but just kind of
the way they explained it it didn't
really click and sync with what they
were saying so if you this flood isn't
very important I'm just doing it kind of
to be thorough and I won't teach guys as
much as I know man so if you hear these
terms and other languages you're not
like whoa that isn't polymorphism it is
but it I don't know it's a little bit
different way of thinking about it so
make sure you understand last slide and
then this slide is just kind of for your
own benefit so anyways the way they
described it was the first way was with
method overloading so you have the same
name for the method but they differ in
their parameters remember parameters are
what you pass into a function so when
you call that function you can pass in
different objects and then that object
is used in that function
so it's not supported an objective-c but
it sort of there but not really so an
objective-c those are two function
function names and Objective C the
parameters are tied into the function
name so you can't just toss in more
parameters you need specific spots in
the name so write to file and then you'd
pass in a string for the parameter path
and then you would pass in a string for
the parameter a string so you could also
have another function that says write
file to path from string and string and
then you would have to pass in path a
string B string you have passed in
different strings for all three of those
parameters
however these would be two completely
different functions so you could code it
so you sort of have method overloading
but it isn't because it's two separate
functions whereas in Java you can
actually just pass in you can just load
up parameter so you could pass in like
five strings or you could pass in one
string and it's the same method you
don't have to recode it or change the
name of the method or anything like that
so that's where polymorphism is kind of
powerful in Java personally I really
preferred the way objective-c does it
where the name and the parameters it's
all just like one big cube sentence it's
what I'm pretty comfortable with I
really enjoy it actually now the other
thing that polymorphism when I learned
it with regards to the language Java
they talked about was method overriding
and that's a different functionality of
a method so what that means is you can
have this drive method and you can
actually override what the method does
so you can call the super so you called
the implementation and this is actually
getting into inheritance here so if this
doesn't quite make sense that's fine but
inheritance ties in with polymorphism so
it's kind of it's cool how it all
connects together but so we have this
method drive
you'd call it on like a car or a vehicle
object so you call drive but let's say
in a subclass we're going to call the
superclass we're gonna re we're gonna
override what drive does so we actually
call we say drive and then we actually
call the super classes implementation of
drive so that's why you say super drive
so calling the super classes
implementation of drive so then we have
what drive does but then we can add on
to it so then we can do like an NS log
drive under the speed limit so it's
pretty cool you could also change the
implementation completely of what drive
does you could just say drive on you
could just have the NS log drive but
don't do that sort of stuff because
that's a bad way of programming where
you're changing implementation
throughout the structure of the program
it's it's difficult to follow and you
can get a lot of bugs that way but it is
it is possible so again that is how I
learned it at school with regards to the
language Java but with Objective C it's
more kind of objects can react to the
same message but in different ways but
remember that why they can do that is
because objects can be called the same
name so each explanation whether it was
in the programming bookstore at school
they all had to do with names but they
just kind of taught it and presented in
a different way and it was kind of it
was confusing for me so hopefully this
cleared it up and you kind of see the
big picture
and understand a little bit better but I
made up this little story I guess you
could say and hopefully this will really
kind of nail down what polymorphism what
it's like so we we're gonna have some
objects so we create some objects here
the first one is a mom object so it's my
mom and then me another object and then
my sister so anyways my mom is going to
send a message
to both me and my sister and that
message is pizza for supper now how
would both of us we're to gin for an
object so you could think of me as a
string and then my sister as an image
object so we're two completely different
objects and we each can react in our own
way so I'm excited and my sister is also
excited just happens that we both
respond excitedly when we get the
message pizza for supper now if my mom
were to change or update the message
that she sent me to say that there's a
mushroom pizza for supper my response
would actually change too you know
thanks because I am programmed that way
I'm programmed to not want mushroom
pizza my sister however she would still
respond excited so that's that's really
how polymorphism works remember my
sister was programmed to like mushroom
pizza I was programmed to not like it
that's why we're responding in this
different way
so with polymorphism command messages or
excuse me before polymorphism before we
kind of started using it messages used
to be just kind of like commands like
take out the trash and you just told the
object to do it and just did it but now
with polymorphism messages aren't just
commands they're more more like
statements and whoever's receiving the
statement will react accordingly so
we're having tacos for supper
either smile or you frown you're either
happy or disappointed
so polymorphism makes your programs
easier to extend since you don't have to
change the message to add or modify
functionality because each object has
its own version of the method you can
simply modify the method instead of
changing the message so polymorphism
allows you to have the code for
different responses to a message spread
out in methods of different objects so
instead of having them in a single
function with Kay
with control statements to manage all
the different possibilities so instead
of having like an if and switch so like
if this object is a cash object do this
if this is a credit object do this
instead of having all sorts of that type
of stuff you can actually combine both
inheritance and polymorphism as you see
in this slide so you have we can have
just one transaction object and we can
have a method like create transaction
and track spending so that's just common
functionality but then we can use
inheritance to create sub classes both
cash and credit and then we have their
own methods so we have spent and deposit
on both sides but each one will
implement spend and deposit in their own
unique way so when you you can just
simply say spend and the cash object
will spend and I will do everything
properly that it needs to do but when
you send that same message to a credit
object it spends in some certain way in
its own special way so that's the beauty
of this you don't have to say well like
if this is a cash object then do this if
this is a credit object do this you just
code up the class structure of your
program in this way and then it just it
just freakin works like it's pretty
sweet so as long as you understand this
concept right here on this slide and you
understand kind of why it's powerful and
kind of you you get it like it clicks
you're good to go
don't get too caught up in any of these
like you need to understand inheritance
you need to understand polymorphism and
I guess the next lesson will be coding
and then lesson after that you need to
understand encapsulation like these are
important things to understand but it's
not like when you're programming it's it
just kind of becomes like a second
nature it clicks a lot more once you're
actually doing it because when I'm
programming app I'm not like oh I need
to remember to use polymorphism it's
just something you just kind of do it's
it's hard to explain I guess that you
could I don't know there's a good
analogy but it's like walking
you you're not like okay take one step
and now the other foot now the other
foot like you just walk but you
understand like how you're walking but
it just becomes kind of second nature
that's I guess you could say sort of
like what this stuff is so don't get too
caught up in kind of these big
programming ideas but make sure you
definitely kind of understand the
general picture so just to kind of nail
it down a little bit more I'm gonna show
you guys a quick example in Xcode you
guys can cut along if you want it's not
it's I'm gonna create a complete a new
project and do that so anyways let's go
into Xcode real quick okay so here we
are on the desktop and I'm going to
create a new Xcode project and I'm
currently using Xcode 6 beta 2 and I'm
just going to create a new project here
and make sure you go to OS X application
command line tool then next and I'll
just call it driving I suppose and I'm
gonna save it to the desktop and hit
create now I guess I'll drag it out like
this I'm going to okay go into the main
dot M and so hello world
do you YouTube and then build and run
and so it succeeded and printed that out
in the console so good I'm going to take
out this odd or at least stuff okay so
here we go it works
now we're gonna create a couple files
real quickly gonna do new file or you
just you command n cocoa touch classes
and it's gonna be a subclass of nsobject
and let's call this one mmm
car and then let's call this other one
motorcycle okie-dokie and so we had this
car class and a motorcycle class so
anyways going to create a we're gonna
create a new method void let's call it
drive nice simple name and gonna create
that same method over here and the dot H
files of each so we create a yeah this
drive method now we're going to see you
add little error cuz there's no method
definition for drive but we're gonna fix
that so void drive and then what should
we say yes we do NS log plus or minus
five miles I don't know
so we have this custom and a slog for
car and then for motorcycle we're into
void drive and then I will say we're
doing s law but then we'll put even
between vehicles on the highway yeah
that's cool so now if we go to our main
file and we import car dot H and then we
import a motorcycle dot each so
everything's good and then in this mean
right here we're gonna create two new
we're gonna create a car object so we
can call car and then we're gonna call
it like the car Lotus so yeah and then
you know recall car and then we call the
new method just that I'll create a new
car method and then motorcycle let's
create a BMW motorcycle isn't
programming fun users create vehicle
and motorcycles and cars and whatever I
mean we credit Ferrari if we wanted so
anyways we get these methods messages
warnings because we're not using the
variables but we're about to fix that so
we're gonna send Lotus the drive message
and send it there then we're gonna call
BMW I'm gonna say Drive to you as well
and I take that out so anyways let's go
ahead and build and run a quick little
tip if you do command R it builds and
runs automatically so anyways BAM just
like this we called Lotus we said Drive
said BMW Drive go down here to the
console we have go the speed limit plus
or minus five miles
that's how Lotus responds to the drive
message we say BMW Drive we've in
between vehicles on the highway BAM so
that is polymorphism in action pretty
powerful stuff hopefully you enjoyed
that example and it made polymorphism
click a little bit more it's always good
to see a programmatic example we
actually see it working and functioning
in code but anyways let's go ahead and
head into Xcode we're gonna be coding up
a lot we're going to be implementing
inheritance and using polymorphism
restructuring the whole the whole code
basically so that will be lesson 35 that
we'll be going over there will just be a
massive programming lesson so that will
be out very soon anyways guys thanks so
much for watching like I said I'll be
finishing out these tutorials taking you
up through building and iOS and a knack
interface for this program and then from
there I plan to do a Swift tutorial so
anyways be sure to subscribe for the
rest of the programming videos the
objective-c tutorials and then Swift
tutorials after that and then I also
uploaded lots of temperament
can i OS videos as well anyways guys
thanks so much for your support and I'll
see you in Lesson 35 real soon later