How to Invoke a Constructor in Java: Techniques and Examples

Constructor in Java is a special method that is automatically invoked when a new object is created from a class. This method is used to initialize the object with initial values. In this article, we will explore various methods to invoke a constructor in Java.

1. Invoking a Constructor with the 'new' Keyword

The most common and straightforward way to invoke a constructor in Java is through the use of the new keyword. When the new keyword is used, it allocates memory for the object and then calls the constructor to initialize it. Here's an example to illustrate this process:

Example

Let's create a class called MyClass with a constructor that takes an integer parameter:

class MyClass {
    int value
    // Constructor with one parameter
    MyClass(int val) {
        value  val
    }
}

Now, in the Main class, we can create an object and initialize it using the constructor like this:

public class Main {
    public static void main(String[] args) {
        // Invoking the constructor with a parameter
        MyClass myObject  new MyClass(10); // Here we are calling the constructor with an integer value 10
        (); // Output: 10
    }
}

2. Constructor Overloading

Constructor overloading is a feature that allows a class to have multiple constructors with different parameter lists. This allows you to create objects with different initialization parameters. Here is an example:

Consider the same MyClass with two constructors:

class MyClass {
    int value
    // Constructor with one parameter
    MyClass(int val) {
        value  val
    }
    // Constructor with no parameters (default constructor)
    MyClass() {
        value  0
    }
}

In the Main class, we can create objects using both constructors:

public class Main {
    public static void main(String[] args) {
        MyClass obj1  new MyClass(10); // Calls the first constructor
        (); // Output: 10
        MyClass obj2  new MyClass(); // Calls the second constructor, defaults to 0
        (); // Output: 0
    }
}

3. Calling a Constructor from Another Constructor (Constructor Chaining)

Constructor chaining is another technique where one constructor calls another within the same class using the this keyword. This is particularly useful for initializing objects with default values and then setting them with specific parameters in another constructor. Here's an example:

class MyClass {
    int value
    // Constructor with one parameter
    MyClass(int val) {
        value  val
    }
    // Constructor with no parameters (calls the first constructor)
    MyClass() {
        this(0); // Calls the first constructor with the default value 0
    }
}

In the Main class, we can create an object using the no-parameter constructor:

public class Main {
    public static void main(String[] args) {
        MyClass obj  new MyClass(); // Calls the no-parameter constructor
        (); // Output: 0
    }
}

Summary

new ClassName is used to invoke a constructor. Constructor overloading allows multiple constructors in a class with different parameter lists. The this keyword is used to call another constructor for constructor chaining.

Feel free to ask more questions or for further examples! If you have any specific scenarios or need more detailed explanations, please do not hesitate to ask.