Hi. In this video, we're going to think about functions, or methods, ways of adding extra functionality to our classes, and that functionality can act on the data within the instances of our classes.

So, in this particular set of examples, which we'll build on over a sequence of videos, we're starting off with a bank account class.

The bank account class has three properties, an account number, the name of the account holder, and the balance, the sum of money associated with that particular account.

We've got a constructor that takes three parameters that map to the three properties, one of which has got a default value, the balance, which defaults to 0 if a balance isn't passed.

But, when we think about bank accounts, there's things that we typically do to those bank accounts.

We take money out of those accounts, and we add money to the accounts.

Technically, we withdraw money, and we deposit money.

So, I've created a couple of functions.

These functions are known as methods.

Because we're working in the land of object orientation, we should be using the word method now, rather than the word function.

People use the term interchangeably.

If you hear the word function or the word method, they are exactly the same thing.

But, technicaly, we're dealing with methods, and we have two methods, one called withdraw money, one called deposit money.

They both take a decimal parameter.

And in this example, they both return void.

They could return something, there's nothing special about methods in classes, they are just functions.

Let's look at deposit money, first of all, because it's slightly simpler.

All we want to do with the sum of money that we get given is add it to the current balance.

So, we have a single line of code here that says balance += amount.

And just to give some feedback, when the program’s running, not necessarily do this in the real world, we're writing to the console with a confirmatory message that the amount has been successfully deposited into the account, whatever the account number is.

When it coming comes to withdrawing money, we do a very similar thing, in that we decrement, or we take the amount away from the balance.

But, before we do that, we have an additional check to make sure that we are not going overdrawn, because, in this particular world — and watch this space because things might change — but in this particular world, you can't go overdrawn with this particular bank account.

So, we look at what the balance is, we subtract the amount from it, and check to see if that is less than 0.

We're not actually physically taking that sum away yet.

We're just doing a calculation on the fly, as it were, to see what the answer would be.

And if the answer is that we would get a value less than 0, we'll write a message to the console saying, oh, we've got insufficient funds to carry out that withdrawal, and we will return from the method now rather than going on to actually physically decrement the amount from the balance.

So, just standard functions really.

We have some client code to talk you through, which is effectively testing those different scenarios.

So, we've got account one, where we are depositing £100.80 and then withdrawing £60.80, and then we're writing out what the final balance will be, which presumably will be something like £40 when you do the maths.

That should succeed, so, let's run that code to the break point and see what happens.

One thing I should point out to you is that the default start up project is another project inside the solution.

And because I'm trying to work with the first project, number one, I either need to make that the start up project or I can choose to debug that from this point here.

So, I'll just start a new instance, and it should run that underlying program.

And we can see the response coming back here.

And the balance is indeed £40 as we thought it would be.

Let's keep that program running and just see what happens next.

So, we're creating a second bank account for Ginger Rogers.

We are depositing, we are specifying a starting balance here of £200.

We're depositing £100.80, but we're trying to withdraw £360.80, which would take us overdrawn, or take Ginger overdrawn.

And so, we'd expect an error message to get written to the console and the balance to not be affected by that withdrawal.

So, the balance should end up being £300.80.

Again, we can run to this break point and confirm that outcome.

And, lo and behold, the balance is £300.80.

The withdrawal was unsuccessful.

There's the error message saying that was the case.

Next thing, which is just an observation in readiness for the next video, we can set the balance directly.

So, I could just arbitrarily come along here and say, “I'd like to put a huge sum of money into my balance. Would I be allowed to do that?”

Well, of course I can.

I'm just setting that property to that particular value.

I hover the mouse over the balance of account two, and we see there's a lot of money in the account and we're overwriting, by the way, what was already in there, which is also kind of dangerous.

Practical example of defining and using methods

About