Objective-C Tutorial - Lesson 33: Inheritance Video Lecture | Learn and Understand: Objective C (English) - Web Development

what's up guys Jorn here with
objective-c tutorials a lesson 33
inheritance and inheritance is the first
of the three I guess you could say
pillars of object-oriented programming
the other two being encapsulation and
polymorphism now there is a problem with
our program I pointed out at the end of
last lesson the problem of having
multiple transactions yes we eliminated
the complex switch but we now have to
maintain all these different
transactions and I know technically we
haven't actually switched out the switch
statement but theoretically we have we
just haven't gone into code quite yet
and switched it out but if we want to
add generic functionality we actually
have to modify each and every class so
the cash and credit card transactions as
well as any others that we may have so
you can see where this is going to start
to become quite a bit of a problem now
the solution fortunately objective-c
like many other languages or
object-oriented programming languages
have a feature called inheritance and
what is inheritance well inheritance
allows you to base a new class off of a
previously created class so this allows
us to have one class with the generic
information for all the transactions and
then we have a class for the specific
type of transaction such as cash credit
and any others that we may have that
inherit from that one class with the
generic info and then they put all the
and they have their own specific
information for each one if you've ever
made any websites and I don't mean
making them with like I would I mean if
you actually made any websites using
HTML and you've actually done some
website coding this you can kind of
relate to inheritance with how you would
place the generic page design in one
file so that all the stuff this is the
same on every page so like the banner
the menu bar the side bar all the links
at the bottom of the page you'd put all
that into one file and then in the
individual web files for each web page
you would put the content that's
completely different for each web page
all the stuff that's the same you put in
one file because then if you want to
modify let's say one link or if you want
to add a new link on the menu bar you
just changes in that one file and it
changes it on all your web pages
throughout the website so that's kind of
one way that we can use inheritance now
some of the basics of inheritance you
need to know what a superclass and a
subclass are now a superclass is the
original class that you're basing the
new class off of and the subclass is the
new class that's based off of the
original class and a subclass is just an
extension of the superclass and I'll get
into exactly what all that means a
little bit later now how you can
remember which one is a superclass and
which one is a subclass I can kind of
tell them apart well the best way is to
just think of what super and sub really
mean so super means above moreover and
then think about that with that diagram
down there below so you see the
superclass over top or above the
subclass and then you have the sub
classes and sub means it lower less
below and then think about that with the
diagram and how they are lower or below
the superclass and so if you just think
about super class and subclass and kind
of this top-down hierarchy way it makes
it very logical and it's very easy to
remember which one is which and remember
that subclass inherits from the
superclass
now how are we going to use inheritance
well I already touched on this a little
bit what we're going to do in this
situation and in most is create a
superclass with the common functionality
between the in our case two classes and
we will create a transaction superclass
with the generic information for all the
transactions and then we will create a
cash and charge in any other
transactions that we might need sub
classes with the unique functionality
and now I'm going to go over a model of
our program and of the transaction and
the cash transaction charge transaction
and I'm gonna show this diagram remodel
of the program using the UML which is
the unified modeling language and this
is a very common way for programmers to
show models of their program and how
everything works together especially how
all the classes work together so with
this you have a box for each class you
name the class at the top then you have
the I bars in that box in the middle and
then you have methods in that bottom box
now here is the model of our program at
the top of course you see nsobject and
that is there because that is the root
of all classes that has lots of I bars
lots of methods it has lots of
functionality now we have transaction
and transaction of course inherits from
an object and then transaction declares
the Aybar's budget and amount and it
also declares the method spent and then
you can see that cash transaction and
charged transaction then they just
inherit those two I bars they don't
declare any new ones and then you can
see that they also have spent and you
may be wondering well why are they
declaring spend if transaction already
declared spent well there's actually
common functionality between cash
transaction charged transaction that is
in spent functionality that that is in
both of those methods so you put that
common functionality you do first you
declare the method spend and then you
put that common functionality in the
superclass and then both of these
transaction types so charged transaction
and cash transaction both inherit that
common functionality and then they also
specify their specific functionality
that is different from each other in
their own methods and cash transaction
in charge transaction classes now the
arrows aren't part of the UML the
unified modeling language they just show
the hierarchy of the class so you can
see transaction is a superclass and
charge transaction and cash transaction
are the
now a little bit more on inheritance you
can see the cash and charge inherit
everything I've ours and methods from
its superclass transaction it's just
like every Ivar and method from the
superclass is actually implemented in
the subclasses and every class except
pennis object which is the root of all
classes is really just another step to
increasing specialization because you
have and its object which has a lot of
power but is very kind of generic in
general and then you have transaction
which inherits from Annis object and it
specifies a lot more it has some
specific functionality and then you go
down even more to charge and cash
transaction and they make transaction
even more specific site as you can see
as you go down the hierarchy you just
get more and more specific now the
subclass defines only what's needed to
turn the superclass into the subclass so
to think of this in the terms of our
program cash transaction only defines
what's needed to turn transaction into a
cash transaction and the same thing goes
for charge transaction it defines only
what's needed to turn the general
generic transaction into a charged
transaction and that's why the subclass
isn't a copy that's just an extension of
the superclass now multiple inheritance
in objective-c every class has just one
superclass but can have an unlimited
amount of subclasses this may sound like
an odd limitation but think about it in
this way every person only has two
parents but can have an unlimited amount
of children but just an objective-c you
can have I guess only one parent
I'm buddy you gonna have an unlimited
amount of children or subclasses anyways
some languages do support multiple
subclasses which is called multiple
inheritance and although multiple
inheritance isn't supported by
objective-c it does give us some of the
features not found in other languages
that give us most of the benefits of
multiple inheritance with
that disadvantages now what inheritance
enables we've already gone over a little
bit about what inheritance enables us to
do but we're gonna go a little bit more
in the next few slides it allows various
things that make your program more
extendable and enhance a bowl with a
subclass you can make three different
changes to what you inherit from the
superclass and the next slides we'll be
going over these three types of changes
the first one that we'll be going over
is adding new methods and Aybar's and
this is one of the most common reasons
for creating a subclass so let's say you
have this superclass and in one
situation some part of your program
needs a little bit more functionality so
you can create a subclass with that
needed functionality and then whatever
that part of your program that needs
that needed functionality uses that
subclass well the rest the program that
doesn't need that extra functionality
still works with the superclass you can
also extend the behavior of a method we
do this by adding a new version of the
method we're going to extend but we
still use the code in the old method so
you add a new method and the new method
overrides the inherited version and then
we send a message to the new method that
we just created with the same name as an
old method from a superclass to execute
the inherited version so we have this
method and that has the same name as a
method in the superclass and we have
added some new functionality but then we
also send a message to run let's run the
functionality in the method from the
superclass so you're running the
original functionality and then the new
functionality so all in all the
inherited functionality will run along
with the newly added functionality and
when you use I mean when you see the
stuffing code it makes a whole lot more
sense than me explain this in bullet
points on a key note obviously and
implementing a method with the same name
as an inherited version is known as
overriding a method now you can also
change the behavior of a method we do
by completely replacing the previous
method by overriding it but this time we
don't send a message to run the
inherited version so you're just running
the new functionality and the old
methods are still available are so
available for any classes that use them
but any class that inherits from your
subclasses uses your new method and
overriding methods isn't unusual but it
does make your code hard to follow and
it really makes it hard to follow if
you're doing this a lot and if you are
doing this constantly you really should
question the design of your program
because this method over here in this
class does this but the same method over
here in that class does that and you're
not just enhancing functionality if you
could be completely changing the
functionality and it could be a whole
different type of functionality so
depending on how much you're changing it
can really make your program very very
confusing because like I said this
method over here does this type of
functionality but you're not sure with
what class is using it to which
functionality is actually being executed
it's just very confusing if you're using
this a lot and a little bit more about
changing the behavior of a method even
if we override a method in a class
subclasses still actually have access to
the original method and obviously this
isn't a great idea to use this
functionality and again you should
question the design of your program if
you find yourself using this feature
often because not only is it just like
this method over here in this class does
this thing while that method in that
class does that it could be this method
over here still does that sometimes but
not all the time it just becomes very
confusing and if you find yourself if
you find yourself using these
functionalities a lot you should really
just question the design of your program
and the best way to avoid lots of
headaches and confusing program is just
to have a good program design from the
very beginning and changing subjects a
little bit even if even though you can
override
methods you can't override Aybar's if
you try to create a new I bar with the
same name has an inherited one you'll
get compiler errors now creating a
protocol well what is a protocol a
protocol is a list of methods in the
superclass that these subclasses are
expected to implement now the superclass
might have empty or just partially
implemented versions of the method it
might have an empty version of the
method if the these two methods or in
our case you know there's two methods
because there's these two subclasses if
there's no common functionality we could
still create a protocol by having that
spend method in that transaction class
but if there's no common functionality
it would just be empty because there's
nothing in there there's nothing common
between the two that they would both
need to inherit and it might be a
partially implemented version and the
example of our program where there is
common functionality in that spend
method that they both need that they
would both be implementing into the
method anyway so you may as well just
implement it into that superclass so you
don't have to implement it twice but
whichever way though it defines a
protocol that all its subclasses must
follow now an abstract class creating a
protocol goes right along with an
abstract class an abstract class is a
class that is designed to have other
classes inherit from it an abstract
class brings together aivars and methods
that will be used by its subclasses and
by doing this an abstract class defines
the program structure and subclasses fit
seamlessly into the program's design now
a quick little review of inheritance
inheritance allows us and enables us to
do the following thing things it allows
us to save time save typing and allows
us to have a better laid out programming
by placing common functionality between
classes into one superclass and then
implementing the specific functionality
in the subclasses it also allows us to
add functionality to a class by adding
methods like
went over and also allows us to modify
functionality by modifying the methods
but just be careful when you're changing
around things and if you're modifying
them a lot just be careful when you're
doing that but that is it for this
lesson going over inheritance I know it
was a big lesson pretty long but there
was just a lot of really vital important
stuff that we needed to go over now
don't go and Xcode just yet because we
still have to talk about one more thing
before we can actually make changes in
our code we'll be going over in less
than 30 for next lesson
polymorphism that's only about five or
so slides it's not nearly as long as
this lesson but there's some vital
important stuff that I need to teach you
guys and go over in that lesson and then
in lesson 35 will actually it will just
be a coding lesson it'll be a huge
coding lesson when we coding up we'll be
taking off the switch statement and
we'll be coding up inheritance and
polymorphism or we'll be coding up the
new design of our program using
inheritance and polymorphism really big
lessons coming up so be sure to
subscribe up there the top say be
notified when I upload those lessons
also be sure to leave any comments
questions or suggestions down and below
and be sure to LIKE and favor this video
if you this video helps you out and
these programming general and these
programming lessons in general have been
helping you guys out but anyways guys
thanks so much for watching be sure to
check out some of my lessons that you
may not have seen already and hopefully
I'll see you in my next lesson real soon
later