Constructors

Constructor is used to create objects. It is a function that executes when object is created.

There are different types of constructors.

Default Constructor

Default constructor can be used without defining it.

If defined it sets default values to class members.

Syntax of default constructor:

Syntax of creating object using default constructor:

Example of default constructor usage without defining it:

Output:

An object is created via default constructor at line 22

The name member has pretty weird value even for default one. For this reason we can define default constructor to set default values.

Example of defining and using default constructor:

Output:

There are couple of things to notice:

The default constructor is defined at 19 - 25 lines .
At line 32 an object is created via the default constructor. The code of the default constructor executes and "Object creation." is printed.
The printed name and age (lines 34 and 35) are the same as the ones set in the default constructor (lines 23 and 24).

Parameterized Constructor

The parameterized constructor accepts parameters which usually are used to set value for the object's members.

Also one class may have more than one parameterized constructors.

Syntax for parameterized constructor:

Syntax of creating objects using parameterized constructor:

Example of class using parameterized constructors:

class Person
{
    private
    // default value for members:
    String name = "Unknown";
    int age = 0;

public
    String getName()
    {
        return this.name;
    }

int getAge()
    {
        return this.age;
    }

void setName(String nameNewValue)
    {
        this.name = nameNewValue;
    }

void setAge(int ageNewValue)
    {
        this.age = ageNewValue;
    }

// Parameterized constructor - 1 argument
    Person(int ageValue)
    {
        System.out.println("Constructor with 1 parameter.");

this.setAge(ageValue);
    }

// Parameterized constructor - 2 arguments
    Person(String nameValue, int ageValue)
    {
        System.out.println("Constructor with 2 parameters.");

this.setName(nameValue);
        this.setAge(ageValue);
    }

void printData()
    {
        System.out.println("Name: " + this.getName());
        System.out.println("Age: " + this.getAge());
    }
}

public class Main {

public static void main(String[] args) {
        // creating object via
        // parameterized constructors:
        Person person_1 = new Person(17);
        Person person_2 =  new Person("Alex" ,21);

person_1.printData();
        System.out.println("------");
        person_2.printData();
    }
}

Output:

There are a couple of things to notice:

At lines 30 - 35 there is a constructor accepting only one parameter. At lines 38 - 44 there is a constructor accepting two parameters.
The constructor with one parameter is used at line 58 and thus "Constructor with 1 parameter." is printed (due to line 32).
The constructor with two parameters is used at line 59 and thus "Constructor with 2 parameters." is printed (due to line 40).

Copy Constructor

Copy constructor is used to create a duplicate of an object. It accepts an object to duplicate as a parameter.

Syntax of defining a copy instructor:

Syntax of using copy constructor:

Example of copy constructor usage:

class Person
{
    private
    // default value for members:
    String name = "Unknown";
    int age = 0;

public
    String getName()
    {
        return this.name;
    }

int getAge()
    {
        return this.age;
    }

void setName(String nameNewValue)
    {
        this.name = nameNewValue;
    }

void setAge(int ageNewValue)
    {
        this.age = ageNewValue;
    }

// Parameterized constructor:
    Person(String nameValue, int ageValue)
    {
        System.out.println("Parameter constructor.");

this.setName(nameValue);
        this.setAge(ageValue);
    }

// Copy constructor:
    Person(Person personObj)
    {
        System.out.println("Copy constructor.");

this.setAge(personObj.getAge());
        this. setName(personObj.getName());
    }

void printData()
    {
        System.out.println("Name: " + this.getName());
        System.out.println("Age: " + this.getAge());
    }
}

public class Main {

public static void main(String[] args) {
        // creating object via
        // parameterized constructor:
        Person person_1 = new Person("Alex", 21);

// creating object via
        // copy constructor:
        Person person_2 = new Person(person_1);

person_1.printData();
        System.out.println("------");
        person_2.printData();
    }
}

Output:

Explanation:

At line 59 an object named person_1 is created via parameterized constructor.
At line 63 an object named person_2 is created via copy constructor. This triggers the code at lines 39 - 45. It duplicates the passed as parameter person_1 object.