Constructor in Java

Constructors are essential in Java programming because they initialize objects and prepare them for use. You can create well-designed and flexible classes in your Java applications if you grasp the principles of the types of constructors, constructor overloading, and constructor chaining.

Constructors play a fundamental role in initializing objects of a class. You can expect to see it when working with popular programming languages like Java or JavaScript. This post covers constructors in Java and its uses.

What are Constructors?

Constructors are specialized methods you can use to initialize the object of a class in Java programming. However, you require the creation of an object using the ‘new’ keyword before automatically initializing the object’s state.

Characteristics of Constructors

Java contains rules that govern the use of constructors. The rules offer an insight into the characteristics of constructors, and below is the summary.

The primary use of constructors is initializing the new objects of a class. They ensure the objects start with a valid state by setting initial values to instance variables.
Constructors should have the same name as the class they correspond to. It is a standard practice because it enables Java to identify and invoke appropriate constructors when creating an object.
Constructors are similar to methods, but the former does not have a return type, not even ‘’void’. Constructors are usually responsible for initializing new objects rather than returning values.
Automatic invocation is another characteristic of constructors because you can trigger it using the ‘new’ keyword during the object creation.

Types of Constructors

Constructors can fit into two broad categories: default or parameter constructors. The section below covers the uses and how to differentiate between the two types of constrictors.

Default Constructors

Default constructors are those constructors with no parameters defined explicitly in the class. The name is self-explanatory because Java automatically provides a ‘default’ constructor if you don’t expressly delineate a constructor in a class.

It is essential to note that a default constructor takes no arguments and initializes instance variables to their default values. You can implicitly call the default constructor using the ‘new’ keyword without specifying arguments. Below is a sample code to better illustrate the use of default constructors.

`public class DefaultConstructorExample {
// Instance variable
private String message;

// Default constructor
public DefaultConstructorExample() {
    // Constructor body
    message = "Hello, World!"; // Initialize instance variable with default message
}

// Method to display message
public void displayMessage() {
    System.out.println(message); // Print the message
}

public static void main(String[] args) {
    // Creating an object of DefaultConstructorExample class
    DefaultConstructorExample obj = new DefaultConstructorExample();

    // Displaying the message using the object
    obj.displayMessage(); // Output: Hello, World!
}}

The DefaultConstructorExample class contains a default constructor with no parameters explicitly defined. The message instance variable initialization (Hello, World!) occurs inside the constructor. Creating an object of the class using the new keyword will automatically invoke the default constructor and trigger the message initialization. Finally, the displayMessage() method is called on the object to print the message.

Parameterized Constructor

Parameter constructors accept parameters during object creation to initialize the object's state. The parameter allows custom initialization of objects by passing arguments specific to the object's requirements.

Unlike default constructors, parameter constructors accommodate one or more arguments. They initialize instance variables with values provided as arguments during object creation. Parameters provide flexibility in object initialization by allowing different sets of values to qualify as arguments. However, you must explicitly define parameter constructors based on the requirements of the class.

`public class Person {
// Instance variables
private String name;
private int age;

// Parameterized constructor
public Person(String name, int age) {
    // Constructor body
    this.name = name; // Initialize name
    this.age = age;   // Initialize age
}

// Method to display person's information
public void displayInfo() {
    System.out.println("Name: " + name);
    System.out.println("Age: " + age);
}

public static void main(String[] args) {
    // Creating an object of Person class using parameterized constructor
    Person person = new Person("John Doe", 30);

    // Displaying person's information
    person.displayInfo();
}

}
`

The Person class contains a parameter constructor that accepts two parameters: name and age. The instance variables initialize with the values as arguments inside the constructor. The provided values will initialize the object's state when creating an object of the Person class using the parameter constructor. The displayInfo() method is called on the object to print the person's information.

Constructor Overloading

Overloading constructors is when you define multiple constructors within a class, each with a different parameter list. The constructors share the same name but differ in the number or types of parameters they accept. They provide flexibility during object initialization by allowing multiple ways to create objects with different sets of initial values.

Constructor overloading relies on rules and regulations to function efficiently. For example, they follow the same rules as method overloading. Constructors must also have different parameter lists (number or types of parameters). It is also essential to note return types of constructors are not considered for overloading because they do not have return types, not even void.

`public class MyClass {
private int value;

// Default constructor
public MyClass() {
    value = 0;
}

// Parameterized constructor
public MyClass(int v) {
    value = v;
}

// Method to get value
public int getValue() {
    return value;
}

public static void main(String[] args) {
    // Creating objects using different constructors
    MyClass obj1 = new MyClass();      // Default constructor
    MyClass obj2 = new MyClass(10);    // Parameterized constructor

    System.out.println(obj1.getValue()); // Output: 0
    System.out.println(obj2.getValue()); // Output: 10
}

}
`

In the above example, MyClass has two constructors: a default constructor that initializes the value to 0 and a parameterized constructor that initializes the value with the provided argument. You can create objects using either constructor to provide flexibility in object initialization.

Constructor Chaining

Constructor chaining refers to one constructor calling another within the same class or in the superclass. The process allows for the reusability of initialization logic and helps avoid code duplication.

You can use the ‘this()’ and ‘super()’ keywords in the constructor chaining process. The ‘this()’ keyword calls another constructor within the same class, whereas the ‘super()’ keyword calls a constructor from the superclass. The keywords also ensure the called constructor executes before the caller constructor.

``public class Vehicle {
private String type;
private int year;

// Constructor chaining using 'this()'
public Vehicle() {
    this("Car", 2020); // Calls parameterized constructor with default values
}

// Parameterized constructor
public Vehicle(String type, int year) {
    this.type = type;
    this.year = year;
}

public static void main(String[] args) {
    // Creating an object of Vehicle class
    Vehicle vehicle = new Vehicle();
    System.out.println("Type: " + vehicle.type); // Output: Type: Car
    System.out.println("Year: " + vehicle.year); // Output: Year: 2020
}

}

The default constructor of the Vehicle class calls the parameterized constructor using this(), which initializes the type and year variables with default values. The sample code demonstrates constructor chaining using the this() keyword.

Best Practices and Tips

Choose meaningful parameter names for your constructors to improve the code readability of your projects.
Endeavor to follow constructor naming conventions, such as using camelCase and starting with a lowercase letter.
You should avoid executing complex logic or computations within constructors to enhance the initialization of tasks.
Keep constructors simple and concise, following the principle of single responsibility.
You should always document your constructors using comments or JavaDoc to provide clear documentation for users of your classes.

Blog

Nickey Bricks