iOS 11 Developer Course Tutorial - Classes Objects Part 16 Video Lecture

moving on then from loops we're going to
look at classes and objects Swift is
what's known as an object-oriented
language which means it's built around
classes and objects so it's important to
understand what they are and how they
work and the idea is actually pretty
simple I think it's best explained
through computer games so let's say
we've got a computer game that has some
ghost characters in it and we need to be
able to create several ghosts and
destroy them as the player kills them if
you can indeed killer ghosts so then the
class becomes the general description of
the ghost and the object is a particular
instance or example of it all right
let's see what I mean
so I can create a class just two S's
called
ghosts and the convention for classes is
that they begin with a capital G unlike
variables or arrays we begin classes
with a capital letter so when I create
my class ghost inside this class I can
create various variables and functions
although a function in a class is
normally known as a method so methods
and functions are pretty much exactly
the same thing but we usually will use
the word method when we're working in an
object-oriented language so this ghost
might have various attributes so for
example we might have a variable called
is alive and that might be by default
true we might also have a variable
called strength and we might want to
have ghosts of various strength this the
default value for strength for a ghost
might be for example 9 then we could
create a new ghost using variable and
then what we normally use is ghost with
a small G to represent a particular
object
of the ghost class and to make it clear
that this is a ghost we define it like
that
so ghosts with a pair of parentheses
after it to say this is going to be a
new object from the ghost class and then
we can do things like print ghost dot is
alive so we can tell whether our ghost
is alive or not by getting that
particular value so we haven't changed
many things so the ghost is his default
value which is true then maybe we want
to take this particular ghost and set
their strength to 20 so maybe this is a
particularly strong ghost then if we
print it ghost our strength we get our
new value of 20 so hopefully this is
starting to make sense and you can see
why particularly in gaming programming
we might want to have these classes four
types of things and then create and
customize them as we need them we can
also put methods into our classes so for
example we might want to define a method
and we can do that using func which is a
little confusing we create a method
using the keyword func which is
obviously short for function but just
shows you how similar functions and
methods are and I'm going to create a
function called kill which allows us to
kill the ghost and that will simply set
is alive to be false and then we can
apply that function to how particular
ghosts so we can use ghost dot kill and
then we can print ghost dot is alive
just to check and see what's happened
and now you can see that we've got a
full svalillyz
that return a value so let's say we
wanted a method called is strong which
is true if the strength of our ghost is
greater than 10 then we can create our
method using func and we'll call it is
strong notice we start with the
lowercase I because this is a method not
a class and then pair of parentheses and
this time we're going to use an arrow
created by a dash and a greater than
sign and bool and that symbolizes that
this method is going to return a boolean
so all it does is check to see if
strength is greater than 10 return true
else
return false so now we can use print
ghost dot is strong and for our
particular ghost we should get as you
just about see at the bottom before it
decided to run it again we get a true
there we go so that's quite simply how
object-oriented programming works we
create a class which has various
variables and methods in it and then we
can create a new object which is a
particular example or instance of that
class and then we can use all the
variables and methods within that and
apply them to our object now it might
look like we could do this a lot easier
without using classes and at this scale
that's true yes we could but when you're
writing big programs or indeed a large
code base that is maintained by lots of
people it's much much easier if it's
organized in this way and we can clearly
see what's going on with each of the
lines of code so it will make your code
much more maintainable and give it a
much better structure if you use classes
and objects all right so we're nearly at
the end of this section now there is one
more thing I want to show you and this
is a top that comes up a lot in Swift
development and that is the topic of
optionals and we're going to master that
in the next video