Adding constructor methods to the derived class

Review: What gets inherited (and what does not get inherited)

These things are inherited:
(And we have discussed them in the past few webpages)

These things are not inherited:

The Constructor methods

Fact:

The derived class must invoke a constructor method from the base class either:

(We will discussed constructor methods in this webpage)

Recall: Constructors

Why do classes has constructor methods:

A constructor method is only invoked by the new operation
(the new operation creates (allocates) the instance variables of an object)
A constructor method is used for:

Why are constructors (in the base class) not inherited by the derived class ?

Facts:

A derived class contains 2 kinds of variables:
Both kinds of variables should be initialized

Common sense/human nature:

Inheriting the constructors from the base class does not guarantee that the programmer will actaully call a constructor methods in the base class !

What we really want to enforce is:

Whenever the user creates an object of the derived class, the user must:

Better solution than "simply inheriting constructor method"

Java programming language will enforce the following rule:

The derived class must invoke a constructor method from the base class either:

Java's constructor invocation rule

Constructor invocation rule:

To invoke (call) a constructor in the base class, use the following syntax:
Which constructor method from the base class is selected will depend on the number and type of parameters
The first statement of a constructor of the derived class must be:
(In this case, the constructor of the base class is invoked (called) explicitly)

IF a constructor of the derived class does not contains a super( ... ) statement, THEN:

The Java compiler will automatically insert the following statement as the first statement in the constructor method:

(In this case, the constructor of the base class is invoked (called) implicitly !!!)

Example: explicit constructor invocation

I will expose the invocation of the constructors by adding a print statement in each constructor in the GeometricObject class:

public class GeometricObject { public String color; public boolean isFilled; public GeometricObject( ) // Constructor 1 { System.out.println("Calling: GeometricObject( )"); // Print announcement color = "BLANK"; isFilled = false; } public GeometricObject( String c, boolean f) // Constructor 2 { System.out.println("Calling: GeometricObject("+c+","+f+")"); color = c; isFilled = f; } ... (Other methods omitted for brevity) }

(Now we can tell when and which constructor method has been called !!!)

The following is an example of invoking a constructor method explicitly:

public class Circle extends GeometricObject { .... public Circle( String c, boolean f, double r ) { super(c,f); // Invokes a constructor method in super class // Will invoke GeometricObject(String, boolean) // NOTE: Must be FIRST statement !!! radius = r; } ... }

Comment:

Circle( String c, boolean f, double r ) in the derived class Circle makes an explicit call to the constructor GeometricObject( String c, boolean f) in the base class GeometricObject

Test program that shows that super(c,f) calls GeometricObject(String s, boolean f) in the base class:

public class testProg { public static void main(String[] args) { Circle x = new Circle ("red", false, 3); // Create a Circle object ... } }

The new Circle ("red", false, 3) statement will print out:

Calling: GeometricObject(red,false)

Explanation:

new Circle ("red", false, 3) will invoke the constructor: | | +-----> public Circle( String c, boolean f, double r ) { super(c,f) will invoke the constructor: | | +---> public GeometricObject( String c, boolean f) { print: Calling: GeometricObject(red,false) } ^ | | That's why you see "Calling: GeometricObject(red,false)"

Example Program: (Demo above code)
- The GeometricObject Prog file: click here
- The Circle Prog file: click here
- The test Prog file: click here
How to run the program:

Example: implicit constructor invocation

We can also expose the implicit invocation of the constructors by adding a print statement in each constructor in the GeometricObject class:

(Now we can tell when and which constructor method has been called !!!)

The following is an example of invoking a constructor method implicitly:

public class Circle extends GeometricObject { .... public Circle( double r ) { radius = r; // Note: no super() call !!! } ... }

Comment:

Because the constructor Circle( double r ) does not has a super( ... ) call, the Java compiler will change the constructor by inserting "super( )" as the first statement:

public Circle( double r ) { super(); // Inserted by the Java compiler !!!! radius = r; // Note: no super() call !!! }

The constructor Circle( double r ) in the derived class Circle makes an implicit call to the constructor GeometricObject( ) in the base class GeometricObject

Test program that shows that the implicit call super() was inserted into Circle(double r):

public class testProg { public static void main(String[] args) { Circle x = new Circle (3); // Create a Circle object ... } }

The new Circle (3) statement will print out:

Calling: GeometricObject( )

Explanation:

new Circle ( 3 ) will invoke the constructor: | | +-----> public Circle( String c, boolean f, double r ) { // Inserted by Java compiler ! super( ) will invoke the constructor: | | +---> public GeometricObject( ) { print: Calling: GeometricObject( ) } ^ | | That's why you see "Calling: GeometricObject( )"

Example Program: (Demo above code)
- The GeometricObject Prog file: click here
- The Circle Prog file: click here
- The test Prog file: click here
How to run the program:

Common error with constructors

Fact:

Common error 1:

A constructor in the derived class using mismatched number/type of parameters

Example:

public class Circle extends GeometricObject { .... public Circle( String c, boolean f, double r ) { super( c ); // There is no constructor: // GeometricObject( String color ) // defined inside the base class !!! radius = r; } ... }

Result: compiler error

>> javac Circle.java Circle.java:7: cannot find symbol symbol : constructor GeometricObject(java.lang.String) location: class GeometricObject super( c );

Example Program: (Demo above code)
- The GeometricObject Prog file: click here
- The Circle Prog file: click here
- The test Prog file: click here
How to run the program:

Common error 2:

The default constructor in the base class is undefined
and it is called implicitly by a constructor in the derived class

Example:

public class GeometricObject { public String color; public boolean isFilled; // NO: public GeometricObject( ) !!!! public GeometricObject( String c, boolean f) { System.out.println("Calling: GeometricObject("+c+","+f+")"); color = c; isFilled = f; } .... }
public class Circle extends GeometricObject { .... public Circle( double r ) { // Circle(r) calls super() implicitly !!! radius = r; } ... }

Result: compiler error

Java 1.6 compiler: >> javac Circle.java Circle.java:13: cannot find symbol symbol : constructor GeometricObject() location: class GeometricObject
Java 1.7 compiler: Circle.java:13: error: constructor GeometricObject in class GeometricObject cannot be applied to given types; { ^ required: String,boolean found: no arguments reason: actual and formal argument lists differ in length

Example Program: (Demo above code)
- The GeometricObject Prog file: click here
- The Circle Prog file: click here
- The test Prog file: click here
How to run the program: