Using constructors of the base class

Problem: Initializing private instance variables base class

Problem: suppose the base class contains private access variables:

We saw in the previous webpage that an derived class cannot access the private variables in the base class:

public class CheckingAccount extends BankAccount { // Inherits: // Variables: accNum, name, balance (private !!!) // Methods: deposit(amount), withdraw(amount) /* ---------------------------------------------- Constructor: CheckingAccount(a, n, amount) ---------------------------------------------- */ public CheckingAccount(int a, String n, double amount) { accNum = a; // Error ! name = n; balance = amount; } /* ------------------------------------- transfer(toAccount, amount) ------------------------------------- */ public void transfer( BankAccount toAccount, double amount ) { this.withdraw(amount); // deduct amount from this account; toAccount.deposit(amount); // add amount to "toAccount"; } }

Note:

Solution: Initializing private instance variables

The solution is quite straightforward:

In other words, we do something like this:

public class CheckingAccount extends BankAccount { // Inherits: // Variables: accNum, name, balance (private !!!) // Methods: deposit(amount), withdraw(amount) /* ---------------------------------------------- Constructor of the derived class ---------------------------------------------- */ public CheckingAccount(int a, String n, double amount) { /* -------------------------------------- What we want to do: Initialize accNum with a Initialize name with n Initialize balance with amount -------------------------------------- */ "BankAccount( a, n, amount );" // Invoke a constructor in BankAccount class !!! } /* ------------------------------------- transfer(toAccount, amount) ------------------------------------- */ public void transfer( BankAccount toAccount, double amount ) { this.withdraw(amount); // deduct amount from this account; toAccount.deposit(amount); // add amount to "toAccount"; } }

The correct syntax to invoke a constructor inside the base class:

super ( parameters );

Notes:

You must use the keyword super(...) to invoke a constructor inside the base class
The "super( ... );" statement must the first statement in the constructor of the derived class

Example:

public class CheckingAccount extends BankAccount { // Inherits: // Variables: accNum, name, balance (private !!!) // Methods: deposit(amount), withdraw(amount) /* ---------------------------------------------- Constructor of the derived class ---------------------------------------------- */ public CheckingAccount(int a, String n, double amount) { /* -------------------------------------- What we want to do: Initialize accNum with a Initialize name with n Initialize balance with amount -------------------------------------- */ super( a, n, amount ); // Invoke a constructor in BankAccount class !!! } /* ------------------------------------- transfer(toAccount, amount) ------------------------------------- */ public void transfer( BankAccount toAccount, double amount ) { this.withdraw(amount); // deduct amount from this account; toAccount.deposit(amount); // add amount to "toAccount"; } }

Test program:

public class TestChecking { public static void main( String[] args ) { CheckingAccount acc1 = new CheckingAccount(123, "John", 1000.0); CheckingAccount acc2 = new CheckingAccount(789, "Mary", 5000.0); System.out.println( "acc1: " + acc1 ); // Uses toString() inherited System.out.println( "acc2: " + acc2 ); // from BankAccount } }

Output:

acc1: Account number: 123, Name: John, Balance: 1000.0 acc2: Account number: 789, Name: Mary, Balance: 5000.0

Example Program: (Demo above code)

The Test Prog file: click here
The BankAccount Prog file: click here
The CheckingAccount Prog file: click here

How to run the program:

Right click on links and save in a scratch directory
To compile: javac TestChecking.java
To run: java TestChecking

Experiment:

Add a print statement to the constructor in BankAccount:

/* ==================================================== Constructor 1: initialize all 3 instance variables ==================================================== */ public BankAccount(int a, String n, double amount) { System.out.println("You are using Constructor 1 in BankAccount"); accNum = a; name = n; balance = amount; }

and run the program. You will see the added message printed out.

This experiment shows you that the constructor CheckingAccount() did indeed invoke the constructor BankAccount() inside the BankAccount class !

Java rules concerning constructors

Recall that: (see click here)

Object creation rule in the Java:
Consequently:

Mechanism in the Java compiler to make sure that there is at least one constructor method in every class:

If the user has defined a constructor in his class:
If the user has not defined any constructor in his class:

Further rules concerning constructors:

Every constructor method in a derived class must invoke a (one) constructor method of the base class

Mechanism in the Java compiler to make sure that a constructor method in a derived class invoke a (one) constructor method of the base class

If a constructor in the derived class contains a super(...); statement:
If a constructor in the derived class does not contains a super(...); statement:

Example:

Consider this BankAccount base class:

public class BankAccount { private int accNum; // Private access private String name; // -- accessible ONLY inside private double balance; // -- the class "BankAccount" /* ==================================================== Constructor 1: initialize all 3 instance variables ==================================================== */ public BankAccount(int a, String n, double amount) { System.out.println("You are using Constructor 1 in BankAccount"); accNum = a; name = n; balance = amount; } /* ==================================================== Default Constructor ==================================================== */ public BankAccount( ) { System.out.println("You are using DEFAULT Constructor in BankAccount"); accNum = -1; name = "Nobody"; balance = 0.0; } .... (Other methods omitted for brevity) }

Here is a derived class CheckingAccount:

public class CheckingAccount extends BankAccount { // Inherits: // (Private) Variables: accNum, name, balance // Methods: deposit(amount), withdraw(amount) /* ---------------------------------------------- Constructor: CheckingAccount(a, n, amount) ---------------------------------------------- */ public CheckingAccount(int a, String n, double amount) { super( a, n, amount ); // Java does nothing here... } /* ---------------------------------------------- DEFAULT Constructor: ---------------------------------------------- */ public CheckingAccount( ) { // Nothing !!! (Java will insert: "super();" ) } /* ------------------------------------- transfer(toAccount, amount) ------------------------------------- */ public void transfer( BankAccount toAccount, double amount ) { this.withdraw(amount); // deduct amount from this account; toAccount.deposit(amount); // add amount to "toAccount"; } }

Test Program:

public class TestChecking { public static void main( String[] args ) { CheckingAccount acc1 = new CheckingAccount(123, "John", 1000.0); CheckingAccount acc2 = new CheckingAccount(); System.out.println( "acc1: " + acc1 ); // Uses toString() inherited System.out.println( "acc2: " + acc2 ); // from BankAccount } }

Output:

You are using Constructor 1 in BankAccount You are using DEFAULT Constructor in BankAccount acc1: Account number: 123, Name: John, Balance: 1000.0 acc2: Account number: -1, Name: Nobody, Balance: 0.0

Notice that:

new CheckingAccount() will invoke:
Although, the constructor CheckingAccount() contains no invocation super(), the Java compiler will insert one !!!

Example Program: (Demo above code)
- The TestChecking.java Prog file: click here
- The BankAccount.java Prog file: click here
- The CheckingAccount.java Prog file with the empty constructor CheckingAccount( ): click here
How to run the program: