For much of our journey so far, we focused on the things or the nouns of programming.

That is to say, things like integers and strings or arrays and

dictionaries, classes and objects.

These data types are critical to writing code and

in our woodworking analogy from long ago, they would represent the wood nails and

screws that might be used to construct a bird house.

We also spent quite a bit of time learning about operators such as addition or

subtraction, ifs and ors.

Those can be thought of as hammers and saws.

They're are simple tools that allow us to introduce verbs, or

do things to our nouns.

They allowed us to drive in nails and

to cut wood that was certainly a jump in capability, but quickly we started linking

those operators together to create greater functionality like calculating a discount.

As you might guess, doing things like calculating a single discount

are great for learning the ropes, and they do embody many real life coding tasks, but

very often the processes we create are more complicated or have more steps.

For instance let's say instead we want to tally the entire bill,

create a PDF of the receipt, and then email that receipt to the customer.

In this case what we're really saying is that we don't just want to cut wood or

drive in a nail.

But we want to build the whole bird house ideally simply by saying build me a bird

house that command, build me a birdhouse, may trigger more complicated

functionality behind the scenes but from the outside, it's a simple command.

For this we'll call upon the fearless function and

the mighty method, now functions, and methods are very similar.

They're both reusable chunks of code that perform actions.

The difference is, methods belong to classes.

Say with me, the difference between methods and

functions is that methods belong to classes.

Now that you know that, which do you think will use more often in Objective-C,

methods or functions?

Well since we've been programming in an object oriented language and

objects are just instances of classes

It seems that methods will be the overwhelming choice.

With that in mind, we'll spend the vast majority of time working with methods, but

almost everything you learn will be applicable to functions as well.

So, I mentioned that methods are the doers of programming.

They allow us to manipulate our objects and

variables, like verbs manipulate nouns.

They provide the functionality we need to give our code real power.

If we create a car object the methods allow us to start our car turn left brake

and depending on where you live honk your horn incessantly.

It's important to note that when we tell our car to stop or

go we don't need to know what's happening under our foot or under the hood.

We just press the pedal and the method handles the rest.

This is a critical thing to grasp because often you'll need to use classes that were

created by another developer, or perhaps included within an apple framework, and

you should feel comfortable calling methods on those classes

without understanding the inner workings of the methods themselves.

But let's not get ahead of ourselves.

Let's look at some examples that might help us better understand what

methods can do and different shapes methods can take

speaking of which let's start with something simpler than a car drive.

Yes I see the cliff.

All right let's pretend our object is something simpler than a car,

namely a coffee maker.

Now a coffee maker can perform a number of actions which are analogous to methods.

In the simplest case, we can turn our coffee maker on.

In code we'd write this something like (void)turnOn coffeeMakerIsOn

= Yes; If we translate that, we'll see we have a method called turnOn.

When we call that method the bool coffeeMakerIsOn will be set to yes, and

yes this assumes our coffee maker is already plugged in.

Now let's talk about two other parts of the method syntax.

First the void, what you see inside those parentheses is the return type, the reason

that it is void, in our case, is that this method doesn't return anything.

Now it still does something really important, it turns our coffee maker on.

But it doesn't actually spit anything out, it simply changes the state of the coffee

maker object from coffeeMakerIsOn = NO to coffeeMakerIsOn = YES.

Now, thankfully, a coffee maker can do a lot more than just turn on.

Specifically, it can make precious, precious coffee, to do this,

a coffee maker takes three inputs, coffee grounds, water and electricity.

With those it produces one output, piping hot, delicious, blessed coffee.

Which, by the way, is about as essential to software development as methods,

variables, functions and

classes all put together but that's a lesson for another time.

Anyway, when we make a pot of coffee, we explicitly feed it the coffee grounds and

the water, but the electricity, the machine knows how to get on its own,

assuming it's already plugged in, of course.

In pseudocode, we could say that

the method makeCoffee takes the input grinds of type CoffeeGrinds and

freshWater of type water the body that's everything inside

the curly braces says that we can create delicious coffee of type coffee and

set that equal to the sum of grinds plus water, plus electricity.

Lastly we return delicious coffee which is of course of type coffee,

just as specified in our return type.

By the way, all I have shown you is how we define a method.

We haven't actually shown how to call the method but

don't worry, that's actually significantly simpler.

Now in programming we use the words parameter

to describe the name of the variable we'll be passing in.

So in our case the grinds and freshwater are our parameters.

Later when we call the method the values that we

actually pass into the method will be called arguments.

A trick to help remember that difference is that arguments are actual.

So here we see a method which has an explicit return type and

several explicit parameters.

The syntax may look a bit confusing, but

as we work through some examples that will become more familiar.

We just took a deep theoretical look at what methods are, what they can do and

what shapes they might take in terms of inputs and

return types, this is a big idea.

So I don't expect you've internalized it all just yet, with that in mind,

please join me for some hands on experience in creating methods.