Constructor Examples

A java constructor
has the same name as the name of the class to which it belongs.
Constructor’s syntax does not include a return type,
since constructors never return a value.


Constructors may include parameters of various types. When the constructor is invoked using the new operator, the types must match those that are specified in the constructor definition.


Java provides a default
constructor which takes no arguments and performs
no special actions or initializations, when
no explicit constructors are provided.


The only action taken by the implicit default constructor is to call
the superclass constructor using the super() call. Constructor arguments
provide you with a way to provide parameters for the initialization of
an object.

Below is an example of a cube class containing 2 constructors. (one default and one parameterized constructor).

public class Cube1 { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube1() { length = 10; breadth = 10; height = 10; } Cube1(int l, int b, int h) { length = l; breadth = b; height = h; } public static void main(String[] args) { Cube1 cubeObj1, cubeObj2; cubeObj1 = new Cube1(); cubeObj2 = new Cube1(10, 20, 30); System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume()); System.out.println("Volume of Cube1 is : " + cubeObj2.getVolume()); } }

Download Cube1.java


Note: If a class defines an explicit constructor, it no longer has a default constructor to set the state of the objects.

If such a class requires a default constructor, its implementation must
be provided. Any attempt to call the default constructor will be a
compile time error if an explicit default constructor is not provided in
such a case.

Java Overloaded Constructors

Like methods, constructors can also be overloaded. Since the
constructors in a class all have the same name as the class, />their
signatures are differentiated by their parameter lists. The above
example shows that the Cube1 constructor is overloaded one being the default constructor and the other being a parameterized constructor.


It is possible to use this() construct, to implement local chaining
of constructors in a class. The this() call in a constructorinvokes the
an other constructor with the corresponding parameter list within the same class. Calling the default constructor to create a Cube object results in the second and third parameterized constructors being called as well. Java requires that any this() call must occur as the first statement in a constructor.

Below is an example of a cube class containing 3 constructors which demostrates the this() method in Constructors context

public class Cube2 { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube2() { this(10, 10); System.out.println("Finished with Default Constructor"); } Cube2(int l, int b) { this(l, b, 10); System.out.println("Finished with Parameterized Constructor having 2 params"); } Cube2(int l, int b, int h) { length = l; breadth = b; height = h; System.out.println("Finished with Parameterized Constructor having 3 params"); } public static void main(String[] args) { Cube2 cubeObj1, cubeObj2; cubeObj1 = new Cube2(); cubeObj2 = new Cube2(10, 20, 30); System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume()); System.out.println("Volume of Cube2 is : " + cubeObj2.getVolume()); } } public class Cube2 { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube2() { this(10, 10); System.out.println("Finished with Default Constructor"); } Cube2(int l, int b) { this(l, b, 10); System.out.println("Finished with Parameterized Constructor having 2 params"); } Cube2(int l, int b, int h) { length = l; breadth = b; height = h; System.out.println("Finished with Parameterized Constructor having 3 params"); } public static void main(String[] args) { Cube2 cubeObj1, cubeObj2; cubeObj1 = new Cube2(); cubeObj2 = new Cube2(10, 20, 30); System.out.println("Volume of Cube1 is : " + cubeObj1.getVolume()); System.out.println("Volume of Cube2 is : " + cubeObj2.getVolume()); } }

Output


Finished with Parameterized Constructor having 3 params

Finished with Parameterized Constructor having 2 params

Finished with Default Constructor

Finished with Parameterized Constructor having 3 params

Volume of Cube1 is : 1000

Volume of Cube2 is : 6000


Download Cube2.java

Constructor Chaining

Every constructor calls its superclass constructor. An implied
super() is therefore included in each constructor which does not include
either the this() function or an explicit super() call as its first
statement. The super() statement invokes a constructor of the super
class.

The implicit super() can be replaced by an explicit super(). The super statement must be the first statement of the constructor.

The explicit super allows parameter values to be passed
to the constructor of its superclass and must have matching parameter
types A super() call in the constructor of a subclass will result in
the call of the relevant constructor from the superclass, based on the
signature of the call. This is called constructor chaining.

Below is an example of a class demonstrating constructor chaining using super() method.

class Cube { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube() { this(10, 10); System.out.println("Finished with Default Constructor of Cube"); } Cube(int l, int b) { this(l, b, 10); System.out.println("Finished with Parameterized Constructor having 2 params of Cube"); } Cube(int l, int b, int h) { length = l; breadth = b; height = h; System.out.println("Finished with Parameterized Constructor having 3 params of Cube"); } } public class SpecialCube extends Cube { int weight; SpecialCube() { super(); weight = 10; } SpecialCube(int l, int b) { this(l, b, 10); System.out.println("Finished with Parameterized Constructor having 2 params of SpecialCube"); } SpecialCube(int l, int b, int h) { super(l, b, h); weight = 20; System.out.println("Finished with Parameterized Constructor having 3 params of SpecialCube"); } public static void main(String[] args) { SpecialCube specialObj1 = new SpecialCube(); SpecialCube specialObj2 = new SpecialCube(10, 20); System.out.println("Volume of SpecialCube1 is : " + specialObj1.getVolume()); System.out.println("Weight of SpecialCube1 is : " + specialObj1.weight); System.out.println("Volume of SpecialCube2 is : " + specialObj2.getVolume()); System.out.println("Weight of SpecialCube2 is : " + specialObj2.weight); } }

Download SpecialCube.java

Output

Finished with Parameterized Constructor having 3 params of SpecialCube

Finished with Parameterized Constructor having 2 params of SpecialCube

Volume of SpecialCube1 is : 1000

Weight of SpecialCube1 is : 10

Volume of SpecialCube2 is : 2000

Weight of SpecialCube2 is : 20


The super() construct as with this() construct: if used, must occur
as the first statement in a constructor, and it can only be used in a
constructor declaration. This implies that this() and super() calls
cannot both occur in the same constructor. Just as the this() construct
leads to chaining of constructors in the same class, the super()
construct leads to chaining of subclass constructors to superclass
constructors.

if a constructor has neither a this() nor a super() construct as its
first statement, then a super() call to the
default constructor in the superclass is inserted.


Note: If a class only defines non-default
constructors, then its subclasses will not include an implicit
super() call. This will be flagged as a compile-time
error. The subclasses must then explicitly call a
superclass constructor, using the super() construct with the right
arguments to match the appropriate constructor
of the superclass.

Below is an example of a class demonstrating constructor chaining using explicit super() call.

class Cube { int length; int breadth; int height; public int getVolume() { return (length * breadth * height); } Cube(int l, int b, int h) { length = l; breadth = b; height = h; System.out.println("Finished with Parameterized Constructor having 3 params of Cube"); } } public class SpecialCube1 extends Cube { int weight; SpecialCube1() { super(10, 20, 30); //Will Give a Compilation Error without this line weight = 10; } public static void main(String[] args) { SpecialCube1 specialObj1 = new SpecialCube1(); System.out.println("Volume of SpecialCube1 is : "+ specialObj1.getVolume()); } }

Output

Finished with Parameterized Constructor having 3 params of Cube

Volume of SpecialCube1 is : 6000