Constructor Program in Java

Posted on

Constructor Program in Java

In Java, a constructor is a piece of code that is used to create an object. A constructor is called implicitly when an object is created in Java using the new keyword. A constructor looks like an instance method. However, a constructor and an instance method are two different things. A Java constructor is often regarded as a special type of method in Java. Constructor program in Java tells about how to use constructors in a program. Constructors always have the same name as the name of the class. Whenever a new object is created in Java, the constructor initializes that object. A class may or may not contain more than one constructor. The following rules must be followed to define a constructor in Java

1) Constructor name and class name should always match.

2) No return type should be given to a Java constructor.

3) Keywords like synchronized, static, native, final, and abstract should not be used with a Java constructor. However, access specifiers like private, protected, public can be used with a constructor.

Constructor Program in Java

The following program demonstrates how to create an array and display its elements on the console.

FileName: ConstructorExample.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

public class ConstructorExample

{

// Constructor

ConstructorExample()

{

    // print statement

    System.out.println(“Inside the constructor of the class ConstructorExample. “);

}

public static void main(String argvs[])

{

    // creating two objects obj of the class ConstructorExample

    ConstructorExample obj1 = new ConstructorExample();

    ConstructorExample obj2 = new ConstructorExample();

}

}

Output:

Inside the constructor of the class ConstructorExample.

Inside the constructor of the class ConstructorExample.

Explanation: We see that there are two statements in the output but only one print statement in the code. This is because the calling of a constructor is dependent upon the number of times the objects are created. In the code, we have used the keyword new twice. Thus, two times the constructor is called, and two objects of the class ConstructorExample is created. ConstructorExample() written after the new keyword is responsible for the constructor invoking. Note that a constructor always returns the reference of the object created. obj1 and obj2 holds the reference returned by the constructor ConstructorExample().

Types of Constructor in Java

There are three types of constructor in Java

1) Default constructor

2) No argument constructor

3) Parameterized constructor

Default Constructor

Let’s see what happens if we remove the code of constructor in the above example.

FileName: ConstructorExample.java

public class ConstructorExample

{

public static void main(String argvs[])

{

    // creating two objects obj of the class ConstructorExample

    ConstructorExample obj1 = new ConstructorExample();

    ConstructorExample obj2 = new ConstructorExample();

}

}

Explanation:

When we compile and run the above program, it does not show the output because there is no print statement in the program. However, the code is compiled and executed perfectly. Because the Java compiler implicitly inserts a default constructor in the code during the compilation of the program. It is not visible to user. Therefore, when ConstructorExample(), written after the new keyword, the default constructor is called. Hence, there is no error while executing the code.

For example, the default constructor inserted by the Java compiler is:

Note: The Java compiler never inserts the default constructor when a constructor is defined in the code. Thedefault constructors always get the access specifier of the class for which they are defined. In the above code, the class ConstructorExample is public. Hence, the default constructor gets the access specifier public.

No argument Constructor

Consider the following program.

FileName: NoArgConstructor.java

public class NoArgConstructor

{

// no argument constructor

NoArgConstructor()

{

System.out.println(“Inside the no argument constructor. “);

}

public static void main(String argvs[])

{

    // creating an object of the class NoArgConstructor

    // and invoking the no argument constructor

    NoArgConstructor obj1 = new NoArgConstructor();

}

}

Output:

Inside the no argument constructor.

Explanation: Since, we have provided a no-argument constructor, the default constructor is absent. This no-argument constructor is getting called we create an object of the class NoArgConstructor.

Parameterized Constructor

A constructor with one or more parameters is called a parameterized constructor.

FileName: Employee.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

public class Employee

{

String empName; // contains employee name

int empId; // stores employee id

// a parameterized constructor with two parameters

Employee(String name, int id)

{

    // initializing the fields

    empName = name;

    empId = id;

}

// A method printing the information of an employee

void printInfo()

{

    System.out.println(“Employee name is: “ + empName + “, and his id is: “ + empId);

}

public static void main(String argvs[])

{  

    // creating two objects of the class Employee

    // invoking paramterized constructor to initialize the  fields

    Employee e1 = new Employee(“Amit”, 12345);

    Employee e2 = new Employee(“Sumit”, 26789);

    // printing the information of employee e1

    e1.printInfo();

    // printing the information of employee e2

    e2.printInfo();

}

}

Output:

Employee name is: Amit, and his id is: 12345

Employee name is: Sumit, and his id is: 26789

Explanation: The parameterized constructor is used to initialize fields of the class. In the code, the constructor has two parameters: one for the employee name and another for the employee id. Therefore, while creating the object of the class, we have to pass the mentioned parameters in the same order; otherwise, the Java compiler punishes with the compilation error. Note that the above code does not contain any zero-parameter constructor. Therefore, a statement like new Employee(); must be avoided. Because the compiler tries to find Employee() in the code, which is absent. Since we have given a parameterized constructor, the existence of the default constructor is also ruled out.

Constructor Chaining Program

When a constructor of a class invokes another constructor of the same class, called constructor chaining. Let’s understand the constructor chaining through the following Java program.

FileName: Employee.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

public class Employee

{

// zero-parameter constructor

Employee()

{  

    // calling the paramterized consturctor that takes

    // one parameter

    this(“Amritesh”);

    System.out.println(“Inside the zero-parameter constructor.”);

}

// parameterized constructor that takes one argument

Employee(String name)

{

    // calling another constructor that takes

    // two parameters

    this(name, 78901);

    System.out.println(“Inside the one-parameter constructor.”);

}

// parameterized constructor that takes two parameters

Employee(String name, int id)

{

    // displaying the employee information

    System.out.print(“The name of the employee is “);

    System.out.println(name + “, and his id is “ + id);

    System.out.println(“Inside the two-parameters constructor.”);

}

public static void main(String argvs[])

{

    // creating an object of the class Employee and

    // calling no argument constructor

    Employee e1 = new Employee();

}

}

Output:

The name of the employee is Amritesh, and his id is 78901

Inside the twoparameters constructor.

Inside the oneparameter constructor.

Inside the zeroparameter constructor.

Explanation: When the statement new Employee() gets executed, the zero-parameter constructor is called. Inside the zero-parameter constructor, there is a statement this(“Amristesh”);, which does the construction chaining by calling the constructor having one string argument. Thus, the statements that are written after this(“Amritesh”); statement goes in the stack.  Similarly, the single parameter constructor calls the constructor having two parameters. This time also, the statements after this(name, 78901); goes in the stack. The two parameters constructor executes the print statements written inside it. In the end, stack unwinding occurs, and whatever statements that are present in the stack get executed. The last two statements in the output are due to stack unwinding.

Constructor Overloading Program

Constructor overloading means having more than one constructor in a class that has different parameters. Here different parameters mean:

1) Number of parameters of the given constructors is different.

public class ABC

{

               ABC()

               {

                

                

               }

               ABC(int i)

               {

                

                

               }

}

Class ABC has two constructors: one has no parameter, while another has one parameter.

2) Number of parameters is the same, but the order/ type of parameters is different.

public class ABC

{

               ABC(int i, String str)

               {

                

                

               }

               ABC(String str, int i)

               {

                

                

               }

}

Class ABC has two constructors. Each constructor accepts two parameters. In the first constructor, the first parameter is of type int, and the second parameter is of type string, whereas in the second constructor, the first parameter is of type string, whereas the second parameter is of type int. These two constructors can be assigned different responsibilities as per the requirement.

Copy Constructor Program in Java

A copy constructor is used to copying the values of one object to another object of the same class. Like C++, there is no copy constructor in Java. We have to create the copy constructor explicitly. The following program illustrates the same.

FileName: CopyConst.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

public class CopyConst

{

// class fields   

int ab;

String str;

// parameterless constructor

CopyConst()

{

    ab = 9;

    str = “ABC”;

}

// It is a copy constructor that copies the values of one object

// to that object, which calls this copy constructor.

// This constructor takes the class object as the argument, whose values

// is going to be copied

CopyConst(CopyConst ob)

{

    // copying the values of the object

    ab = ob.ab;

    str = ob.str;

}

// printing values of different fields of the objects of the class

void printInfo()

{

    System.out.print(” Value of the integer field is “ + ab + ” “);

    System.out.println(“Value of the string field is “ + str);   

}

// driver method

public static void main(String argvs[])

{

    // creating an object, and calling the parameterless constructor

    CopyConst obj1 = new CopyConst();

    // creating another object, and calling the copy constructor

    CopyConst obj2 = new CopyConst(obj1);

    // displaying fields of the given object

    obj1.printInfo();

    obj2.printInfo();

}

}

Output:

Value of the integer field is 9 Value of the string field is ABC

Value of the integer field is 9 Value of the string field is ABC

Explanation: The one-parameter constructor is doing the job of the copy constructor in the code. The rest of the code is very straightforward to comprehend.