Hi, in this video we're gonna think about abstract classes, classes that have to be inherited from. Our starting point is the code that we looked at previously. Here we have a bank account class as we left it, and there are situations where it doesn't make sense to be able to instantiate a particular class, it's too generic.

So, in the real world, you can go and create, you can go into a local bank and open up a savings account, a current account, an ISA account, but you can't just open a bank account. So, if we want the client not to be able to instantiate a particular kind of object, we can declare it as being abstract.

That means that when you go to the underlying client code, and try and instantiate a new instance of one of those, you're not allowed to, because it's abstract, you can't create instances of one of these classes. They, they, they have to be inherited from and instantiated from the specialised versions.

So, if I go back to the bank account class, something else that's, kind of, potentially the case is that when you create the specialised versions of your base class, you find yourself always overriding a particular method, or set of methods. So, it could be that we withdraw money in special ways for all the different specialised bank accounts.

And in a situation like that, we could declare that method as being abstract. And you reduce it down to a single signature, a signature that says if you're gonna be a bank account object, you have to explicitly create your own abstract method.

And so this code is clean but I can't instantiate a bank account object in its own right anymore. If we then look at the specialised classes, we notice that the current account implements a withdraw money method already.

So, it's clean, it's already overriding the base class method. If I go to the savings account, the compiler, the editor is unhappy, why? Because I haven't got a withdraw account, a withdraw balance method.

So, what I could do here is make use of the, the help prompt to say, 'Would you like me to implement that particular method?' and I go, 'Yes please,' and it gives me a specialised withdraw money method and the squigglies go away.

But of course it's actually gonna generate an exception if I don't do anything about it. Fortunately, I've got a chunk of code that I could paste into there, this is the code that I've just actually copied from the underlying bank account class.

So, the savings account now has a withdraw money method. When we look at the ISA account, it hasn't got a withdraw money method, but it inherits from savings account, that has got a withdraw money method.

So, the hierarchy is happy, every method has a withdraw money method somewhere in the inheritance hierarchy, but not the underlying base class, because that's just got this signature that has to be overwritten. You could read the word 'abstract' here as being 'must overwrite'.

That means we can go to the test logic and create instances of current accounts, instances of savings accounts, instances of ISA accounts. And we could still throw them into a collection of bank account objects, alright? So, creating these specialised objects but putting them into a collection of base class bank account objects.

Although I can't instantiate a bank account object, I can look at these objects still through those blinkers because all that the base class is saying is you have to have a withdrawal method, and all of these objects do have their own specialised withdrawal methods.

So, this code will run just as clean as it did before now, with all the underlying logic in place and the withdrawals will be successful.

So, I will run that program, and we can see that it's successfully run, doing the same withdrawals and the same balances as the previous run in the previous video.

So, everything has worked just as cleanly as before. So, in this video we've seen how we can create a class and declare it as abstract, 'must inherit' and within there create specialist methods which effectively are abstract or 'must override'.

Practical example of using abstract classes

About