Hi, in this video, we're going to talk about one of the core concepts of object orientation, and that's inheritance and the ability to override underlying functionality. We're continuing to build on the program that we were looking at in the previous video. I've got a new version of the project and that's what we'll be working through now.

So, I've got another version of the project, and I've got inside there a bank account class, and the only difference between this and the previous example was I've added the word 'virtual' to these two methods.

The withdraw money method, and the deposit money method. Making a method virtual means that it can be overridden when we do inheritance, so just keep a watch of that when we look at other bank accounts.

The bank account class here is what we would call the base class in that it's the top of the heap, or the bottom of the heap, depending on which way you look at it, that every other account is going to base itself upon.

So, all accounts, no matter what kind of account they are, you would be able to withdraw money and deposit money. A classic example of that would be a savings account.

So, I've added, here, a code module called 'savings account', and I've declared a class called 'savings account', but I've specified colon bank account, and that colon symbol means 'inherits'.

So, inheritance is all about getting something for nothing. Something that you don't have to work for. So, because I've declared the savings account as a bank account, it will automatically be given a deposit method and a withdrawal method.

And I don't have to define that insight here, I can just the base class versions. The ones that I've inherited for free. So, we need to look at these savings account classes constructed, because they are not inherited.

So, here's the constructor for savings account, and we see it takes an account number, an account holder name, and a balance, but in addition to the base class, it gets passed an interest rate, which in this case is half a percent.

If I look at the underlying bank account class, we see that it has a constructor that takes these first three parameters, but no interest rate. Because we're using inheritance, what we really want to do is pass on the stuff that's the base class' responsibility to the base class, and we do that by extending the signature of the constructor by using a colon, which essentially says, 'Take some of the parameters that I've received and pass them on to somewhere else.'

In this case, to the base class and pass it-, pass its constructor account number, account holder name, and balance. We haven't dealt with the interest rate, so we've got to worry about that locally in the savings account class.

We've given ourselves a method, 'add interest', which we could call at any point from the client, and that will take the current balance and multiply it by the interest rate and add that to the existing balance to add that year's interest. We have other classes that will also inherit from a bank account.

I've got a current account. Now, the interesting thing about a current account is that when we withdraw money, we can go overdrawn, because current accounts may well be given an overdraft limit. So, this class has a constructor, because you don't inherit constructors, and it gets passed an additional parameter to the base class of overdraft limit.

So, we do the same thing as we did with the savings account. We pass the stuff on to the base class constructor that we can get away with. Account number, account holder name, and balance, but we deal with the overdraft limit locally, which we put into a public property called overdraft limit.

What we need to do now, though, is replace the base classes withdraw method with this specialised version, because we need to worry about the overdraft limit. Something that we have to do with current accounts, but standard accounts, it's not an issue.

So, we override what was declared in the base class as the virtual withdrawal money method, and inside here, have a slightly different calculation to the base class version.

We are comparing the balance take-away amount to see if it's less than zero take away the overdraft limit. If it is, then we are going beyond the account overdraft limit, and we won't be allowed to withdraw that sum of money.

So, although we don't have any money in the account, we do have a negative balance, because we subtract the amount from the balance and we're going into the overdraft range of funding.

We write to the console that the, the subtraction was successful. So, we could then look at some underlying code and work through those two, kind of, examples. The first couple of blocks of code are dealing with just ordinary bank accounts, but now we're instantiating a current account.

In this example, we are passing an account number and an account name, but we're leaving the other two fields to default to, to their-, the default values.

We can specify the overdraft limit explicitly. We haven't restricted that ability. We call the withdraw money method-, if the overdraft limit is £100 and we haven't specified the balance at the start, the balance will be zero with a limit of £100 added to it.

So, if we try and withdraw £50, that should work. If we then try and withdraw £51, we'll be going outside the overdraft limit and this withdrawal should fail.

If I set a break point here and run to that break point, we should be able to see the outcome. Okay, and we see, absolutely, that we manage to withdraw £50, but then we tried to £51 more, and we weren't allowed to do that. That failed because of our check in the withdraw money method.

We have another example where we are explicitly passing all four parameters to the new current account object and we are trying to withdraw £150, followed by a further £51.

Again, this will take us over the overdraft limit, and we will get an error message at the time we attempt to do that thing. So, I'll run to that point. Again, we should be seeing similar messages saying I failed to withdraw that sum of money from the account.

So, in this video, we've seen how we can override base class behavior by creating specialized versions of virtual methods.

Practical example of inheritance and virtual methods/overriding

About