This tutorial is intended to demonstrate how inheritance works in OO COBOL. It uses the example of different types of bank account, and shows how they can inherit common behavior from a single class, while adding new behavior or changing as necessary for individual types of account.
This tutorial uses Micro Focus alternatives and extensions to the ISO 2002 OO COBOL syntax.
This tutorial consists of the following sessions:
This section introduces the Account classes used in this tutorial. In the next session you will use Animator to see how they work together.
There are four account classes altogether:
Subclass of Account which adds behavior for checking accounts (checks overdraft limit on withdrawals)
Subclass of Account which adds behavior for savings accounts (pays interest)
Subclass of SavingsAccount which adds a method for checking for a minimum starting balance to open an account
CheckAccount and SavingsAccount both inherit from Account, and HighRateAccount inherits from SavingsAccount. This hierarchy view shows that the Account class is the superclass of all other account types. The Account class implements the behavior common to all the different types of bank account.
Look at the source code for the Account and SavingsAccount classes. The Account class implements methods for constructing new accounts "openAccount", and for debiting ("withdraw") and crediting ("deposit") accounts. The SavingsAccount class has far fewer methods, and inherits most of its behavior from Account.
All the classes (except Account) have a method "printStatement". Each type of account prints a different type of statement, but does it when sent the message "printStatement". This is an example of polymorphism.
These classes also contain methods that are not used at all in this tutorial. The reason is that these classes are also used in the GUI bank examples available on Windows platforms.
In the next session, you will use the Bank program to see how inheritance works in these classes. This is a simple program which creates accounts and sends messages to them.
In this session you will animate bank1.cbl, to see some simple account transactions and how inheritance works in practice.
To animate bank1:
This compiles bank1.cbl and the account classes.
anim bank1
Animator starts with the statement below tag B001 is highlighted ready for execution.
When
you step invoke CheckAccount, execution switches to the "initializeClass" method of the Account
class. The method is used in this case to execute some code for setting up
error handling. For more information about class initialization see the section
Class
Initialization in the chapter Classes.
This code is the subject of another tutorial, so we execute it without animating through it.
invoke super "new".
This sends the "new" message to this object, but tells the run-time system to start looking for methods in the code for the superclass of Account (class Base). It returns an instance of CheckAccount.
invoke statement below tag A002.
This takes you to the "setNextAccountNumber" method of Account.
if nextAccountNumber = 0).
Data item nextAccountNumber is declared with a value clause of 0. When the account class or any of
its subclasses is initially loaded this data item is set to 0. The method
"setNextAccountNumber" tests this value, and if it is zero, sets an initial
value. This is the first time the CheckAccount class has received the
"openAccount" message, so nextAccountNumber needs initializing.
invoke self "getFirstAccountNumber").
Execution switches to the "getFirstAccountNumber" method of
CheckAccount. In this case, self refers to the CheckAccount class object; although we were executing
code implemented by the Account class, the original "openAccount" message was
sent to the CheckAccount class object, which inherited its "openAccount" method
from Account.
This method returns a value for the "openAccount" method to start numbering accounts. Each of the subclasses of Account starts account numbers from a different value, and they all implement "getFirstAccountNumber" to return the starting value.
exit method.
This takes you back to the exit method statement of "setNextAccountNumber".
exit method statement.
This returns you to the "openAccount" method.
invoke lsAccount "initAccount"
...).
The object handle to the newly created account object is in lsAccount, which we are going to initialize with name, balance and account
number.
exit method.
This takes you back to the exit method statement of "openAccount".
exit method statement.
Execution returns to Bank1, which now has an object handle to an instance of the CheckAccount class.
This deposits $1000 in the CheckAccount instance. Again, the code for this is all in the Account class.
These withdraw $50 from the CheckAccount instance. This time the invoke switches execution to code inside CheckAccount. This is because the
CheckAccount class implements its own "withdraw" method, which checks the
withdrawal against the value allowed for the overdraft.
If the withdrawal were to exceed the overdraft set for this instance of CheckAccount, the object would raise an exception (error condition). In this case, the withdrawal amount is OK, so execution proceeds as normal.
The application in this case has not registered an exception handler to deal with account exceptions, so the error would get trapped at the system level which would display the error number and halt application execution. Example applications used in some of the other OO COBOL tutorials also use these account classes, but register an exception handler to deal with this type of error.
Each time you open a type of account which Bank1 hasn't used before, you have to step through the code to get an initial account number. Also, each time you open a type of account which Bank1 hasn't used before, the class initialization code is executed, because it is impossible to know whether other types of account have been opened since the application started running, and therefore whether the class initialization code has already been run.
As you execute the code, you will see that most of the code for the different types of bank account is inherited from the Account class, with only some methods being implemented in the subclasses.
The subclasses all inherit from the Account class with data (see the
class-idstatements at the top of each program). This means that as well as
inheriting the methods of Account, they also have direct access to the data
items declared in account. All the different account types can access variables
balance,aName and accountNumber.
Without the with data clause in the class-id of the Account subclasses, they could not access this data directly.
Instead, they would have to send messages to the superclass (invoke super...) to access this data. The programmer of the Account class would have to
implement methods which respond to these messages.
super.
This code demonstrates the use of polymorphism between objects descended from a common class. All account types implement the "printStatement" method in order to print out a statement suitable for the different account types.
This concludes the tutorial on inheritance. In this tutorial you learned:
Copyright © 2004 Micro Focus International Limited. All rights reserved.