Interview Questions on Constructor in Java

The Java constructor is a crucial concept in object-oriented programming that allows us to initialize objects and set their initial state. It plays a vital role in creating instances of classes and is often a key topic in Java interviews. In this article, we will explore some common and advanced interview questions related to Java constructors and provide detailed explanations along with code examples to illustrate their use. Whether you are a Java developer preparing for an interview or just seeking to enhance your knowledge, this guide will help you understand constructors better and excel in interviews.

What is a Constructor?

Before delving into interview questions, let's briefly revisit the concept of constructors. In Java, a constructor is a special method that has the same name as the class it belongs to. It is used to create and initialize objects of that class. When a new object is created using the new keyword, the constructor is automatically called, ensuring that the object is in a valid state. A constructor does not have a return type and can be overloaded, meaning a class can have multiple constructors with different parameter lists. If you don't explicitly provide a constructor, Java will supply a default constructor with no arguments. However, if you define your own constructor, the default constructor is not automatically added.

1) What is the purpose of a constructor?

The primary purpose of a constructor is to initialize the state of an object. It is responsible for setting initial values to the instance variables of the object so that it is ready for use when created. The constructor is automatically called when a new object is created using the Java new keyword.

Example:

class MyClass {
    int number;
    // Constructor
    public MyClass(int num) {
        number = num;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of MyClass using the constructor
        MyClass obj = new MyClass(42);
        System.out.println("Number: " + obj.number); 
    }
}

Output:

Number: 42

2) Can a constructor be private or final?

Yes, a constructor can be private or final. When a constructor is marked as private, it means it cannot be accessed from outside the class, and therefore, objects cannot be created directly from outside the class. This technique is often used in Singleton design patterns, where only one instance of the class is allowed.

Example:

class SingletonClass {
    private static final SingletonClass instance = new SingletonClass(
    private SingletonClass() {
        // Private constructor
    }
    public static SingletonClass getInstance() {
        return instance;
    }
}
public class Main {
    public static void main(String[] args) {
        // Cannot create an object directly, instead use the getInstance() method
        // SingletonClass obj = new SingletonClass(); 
        SingletonClass obj = SingletonClass.getInstance();
    }
}

Output:

This will give an error

3) What is constructor chaining?

Constructor chaining refers to the process of calling one constructor from another within the same class or from a superclass. This allows us to reuse the code and avoid duplication when multiple constructors are present.

Example:

class Person {
    String name;
    int age;
    // Constructor with name parameter
    public Person(String name) {
        this.name = name;
    }
    // Constructor with both name and age parameters
    public Person(String name, int age) {
        this(name); // Invoking the constructor with name parameter using 'this'
        this.age = age;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of Person using the constructor
        Person person = new Person("John", 30);
        System.out.println("Name: " + person.name + ", Age: " + person.age);
        
    }
}

Output:

Name: John, Age: 30

4) How can you prevent inheritance of a class constructor?

By default, constructors in Java are not inherited. However, when a subclass is created, it implicitly calls the constructor of its superclass before executing its own constructor. If the superclass has a constructor with arguments and no default constructor, the subclass must explicitly call the appropriate superclass constructor using the super() keyword.

Example:

class Superclass {
    int number;
    public Superclass(int number) {
        this.number = number;
    }
}
class Subclass extends Superclass {
    String message;
    public Subclass(int number, String message) {
        super(number); // Calling the constructor of the superclass
        this.message = message;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of Subclass
        Subclass obj = new Subclass(10, "Hello");
        System.out.println("Number: " + obj.number + ", Message: " + obj.message);      
    }
}

Output:

Number: 10, Message: Hello

5) What is the difference between a default constructor and a parameterized constructor?

The key difference between a default constructor and a parameterized constructor lies in their argument list and their behaviour. The default constructor does not take any arguments and is provided by Java when a class does not define any constructor explicitly. On the other hand, a parameterized constructor includes parameters in its argument list and allows you to initialize instance variables with specific values during object creation.

Example:

class Car {
    String make;
    String model;
    int year;
    // Default constructor (provided by Java if not defined explicitly)
    public Car() {
        make = "Unknown";
        model = "Unknown";
        year = 0;
    }
    // Parameterized constructor
    public Car(String make, String model, int year) {
        this.make = make;
        this.model = model;
        this.year = year;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating objects of Car with both constructors
        Car defaultCar = new Car();
        Car paramCar = new Car("Toyota", "Camry", 2022);
        System.out.println("Default Car: " + defaultCar.make + " " + defaultCar.model + " " + defaultCar.year);
        // Output: Default Car: Unknown Unknown 0
        System.out.println("Parameterized Car: " + paramCar.make + " " + paramCar.model + " " + paramCar.year);
Parameterized Car: Toyota Camry 2022
    }
}

Output:

Parameterized Car: Toyota Camry 2022

6) Can a constructor call method?

Technically, constructors can call methods, but it is generally not recommended to do so. The reason is that constructors are meant to initialize the state of the object and set up its initial values. Calling methods from constructors could lead to unexpected behavior, especially if the methods rely on instance variables that have not been initialized yet. However, in certain situations, it might be acceptable to call methods from constructors, but developers should exercise caution and ensure that the method calls do not interfere with the proper initialization of the object.

Example:

class Rectangle {
    int width;
    int height;
    int area;
    public Rectangle(int width, int height) {
        this.width = width;
        this.height = height;
        calculateArea(); // Calling a method to calculate the area from constructor (for demonstration purposes)
    }
    private void calculateArea() {
        area = width * height;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of Rectangle
        Rectangle rect = new Rectangle(5, 10);
        System.out.println("Area: " + rect.area);
        // Output: Area: 50
    }
}

7) What happens if you don't provide a no-argument constructor in a class with other constructors?

When we define constructors in a class, Java does not automatically provide the default (no-argument) constructor. If you have defined one or more parameterized constructors but haven't explicitly provided a no-argument constructor, Java will not generate it for you. As a result, if you attempt to create an object without any arguments, it will lead to a compilation error.

Example:

class MyClass {
    int value;
    // No-argument constructor
    public MyClass() {
        value = 0;
    }
    public MyClass(int value) {
        this.value = value;
    }
}
public class Main {
    public static void main(String[] args) {
        // Now you can create an object of MyClass without any arguments
        MyClass obj = new MyClass();

        // Print the value of the object
        System.out.println("Value: " + obj.value);
    }
}

Output:

To resolve the compilation error, we can either provide a no-argument constructor explicitly or use one of the existing parameterized constructors to create objects.

8) Can you have both a default constructor and a parameterized constructor in the same class?

Yes, a class can have both a default constructor (no-argument constructor) and one or more parameterized constructors. If you define a parameterized constructor in the class, Java will not automatically provide a default constructor. However, you can explicitly define one alongside the parameterized constructor(s).

Example:

class MyClass {
    int value;
    // Default constructor
    public MyClass() {
        value = 0;
    }
    // Parameterized constructor
    public MyClass(int value) {
        this.value = value;
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating objects of MyClass using both constructors
        MyClass obj1 = new MyClass(); // Using the default constructor
        MyClass obj2 = new MyClass(42); // Using the parameterized constructor
        System.out.println("Object 1 Value: " + obj1.value); // Output: Object 1 Value: 0
        System.out.println("Object 2 Value: " + obj2.value); // Output: Object 2 Value: 42
    }
}

9) What happens if you don't provide any constructor in a class?

If you don't explicitly define any constructor in a class, Java will automatically provide a default (no-argument) constructor. This default constructor has no code inside it and is equivalent to writing an empty constructor with no arguments. It is crucial to note that once you define any constructor explicitly, the default constructor is not automatically generated.

Example:

class MyClass {
    int value;
    // No constructor defined in this class
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of MyClass using the default constructor
        MyClass obj = new MyClass();
    }
}

10) Can you call one constructor from another using the this() keyword?

Yes, in Java, you can call one constructor from another within the same class using the this() keyword. This technique is known as constructor chaining. It allows you to reuse initialization logic and reduces code duplication.

Example:

class MyClass {
    int value;
    // Constructor with one argument
    public MyClass(int value) {
        this.value = value;
    }
    // Constructor with no arguments, calling the one-argument constructor using 'this()'
    public MyClass() {
        this(0); // Call the constructor with one argument
    }
}
public class Main {
    public static void main(String[] args) {
        // Creating an object of MyClass using the no-argument constructor
        MyClass obj = new MyClass();
        System.out.println("Value: " + obj.value); 
    }
}

Output:

Value: 0

11) Can a constructor be static?

No, constructors cannot be static. The static keyword is used to define static members (variables and methods) of a class, and it is not applicable to constructors. Constructors are instance-level methods used to initialize object state and, as such, cannot be associated with the class itself.

Example:

class MyClass {
    static int value; // This is a static variable
    // This is a constructor (non-static method)
    public MyClass(int value) {
        MyClass.value = value;
    }
    // This is a static method
    public static void staticMethod() {
        // Code for the static method
    }
}
public class Main {
    public static void main(String[] args) {
        // Cannot call the constructor using the class name like a static method
        // MyClass(42); // This will cause a compilation error
        // Correct way to call the constructor is by creating an object
        MyClass obj = new MyClass(42);
    }
}

12) What happens if you define a return type for a constructor?

Constructors do not have a return type, not even void. If you attempt to provide a return type for a constructor, it will be considered a regular method, and the compiler will treat it as such. This will result in a compilation error.

Example:

class MyClass {
    int value;
    // This will cause a compilation error as constructors cannot have a return type
    // public void MyClass(int value) {
    //     this.value = value;
    // }
}

13) Can constructors be inherited in Java?

Constructors are not inherited in Java. Although a subclass implicitly calls the constructor of its superclass before executing its own constructor, the constructors themselves are not inherited. Each class, including subclasses, must define its constructors independently.

Example:

class Superclass {
    public Superclass() {
        System.out.println("Superclass constructor");
    }
}
class Subclass extends Superclass {
    // Subclass does not define any constructors explicitly
}
public class Main {
    public static void main(String[] args) {
        // Output: Superclass constructor
        Subclass obj = new Subclass();
    }
}

14) What is the purpose of the super() keyword in a constructor?

The super() keyword is used to call the constructor of the superclass from the subclass constructor. It is used for constructor chaining, ensuring that the initialization logic of the superclass is executed before the subclass initialization begins.

Example:

class Superclass {
    int number;
    public Superclass(int number) {
        this.number = number;
    }
}
class Subclass extends Superclass {
    String message;
    public Subclass(int number, String message) {
        super(number); // Calling the constructor of the superclass
        this.message = message;
    }
}
public class Main {
    public static void main(String[] args) {
        Subclass obj = new Subclass(10, "Hello");
        System.out.println("Number: " + obj.number + ", Message: " + obj.message);
        // Output: Number: 10, Message: Hello
    }
}

15) Can you make a constructor final?

No, constructors cannot be marked as final. The final keyword is used to indicate that a method, class, or variable cannot be overridden or changed. Since constructors cannot be overridden like regular methods, there is no need to use final with constructors.

class MyClass {
    // This will cause a compilation error as constructors cannot be final
    // public final MyClass() {
    //     // Constructor logic
    // }
}

16) Can you use access modifiers such as private, protected, or public with constructors?

Yes, constructors can have access modifiers like any other class members. The access modifier determines the visibility of the constructor in different contexts.

Example:

class MyClass {
    private int value; // Private instance variable
    // Private constructor
    private MyClass(int value) {
        this.value = value;
    }
    // Public method to create an object using the private constructor
    public static MyClass createInstance(int value) {
        return new MyClass(value);
    }
}
public class Main {
    public static void main(String[] args) {
        // Cannot directly create an object using the private constructor
        // MyClass obj = new MyClass(42); // This will cause a compilation error
        // Instead, use the public method to create an object
        MyClass obj = MyClass.createInstance(42);
        System.out.println("Value: " + obj.value); // Output: Value: 42
    }
}

17) What is the purpose of this keyword in a constructor?

Java this keyword is used to refer to the current instance of the class within a constructor or any other instance method. It is commonly used to disambiguate between instance variables and parameters with the same names.

Example:

class MyClass {
    int value;
    // Constructor with a parameter named 'value'
    public MyClass(int value) {
        this.value = value; // 'this.value' refers to the instance variable, and 'value' refers to the parameter
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass(42);
        System.out.println("Value: " + obj.value);
    }
}

Output:

Value: 42

18) Can we use the new keyword inside a constructor to create an object of another class?

Yes, we can use the new keyword inside a constructor to create an object of another class. Constructors can contain any valid Java code, including object creation.

Example:

class Student {
    String name;
    public Student(String name) {
        this.name = name;
    }
}
class School {
    Student student;
    public School(String studentName) {
        student = new Student(studentName); // Creating an object of Student inside the School constructor
    }
}
public class Main {
    public static void main(String[] args) {
        School school = new School("John Doe");
        System.out.println("Student Name: " + school.student.name); 
    }
}

Output:

Student Name: John Doe

19) Can we throw an exception from a constructor?

Yes, constructors can throw exceptions just like any other method. If an exception is thrown from a constructor, the object creation will be aborted, and the exception will be propagated to the calling code.

Example:

class MyClass {
    int value;
    public MyClass(int value) {
        if (value < 0) {
            throw new IllegalArgumentException("Value cannot be negative");
        }
        this.value = value;
    }
}
public class Main {
    public static void main(String[] args) {
        try {
            MyClass obj = new MyClass(-42); // This will throw an IllegalArgumentException
        } catch (IllegalArgumentException e) {
            System.out.println("Exception: " + e.getMessage()); 
        }
    }
}

Output:

Exception: Value cannot be negative

20) Can we define a constructor as abstract?

No, constructors cannot be defined as abstract. An abstract method is a method without a body, and it can only exist in an abstract class or an interface. Constructors, on the other hand, must have a body to initialize the object. Therefore, they cannot be abstract.

Example:

abstract class MyClass {
    // This will cause a compilation error as constructors cannot be abstract
    // public abstract MyClass();
}

21) Can you use the final keyword with constructor parameters?

Yes, we can use the final keyword with constructor parameters to indicate that the values of those parameters cannot be changed once they are assigned during object creation. This is helpful when you want to ensure immutability for specific instance variables.

Example:

class Point {
    final int x;
    final int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Main {
    public static void main(String[] args) {
        Point p = new Point(10, 20);
        // p.x = 5; // This will cause a compilation error as 'x' is final
    }
}

22) Can you use the this() keyword and super() keyword in the same constructor?

Yes, you can use both the this() keyword and super() keyword in the same constructor, but you must ensure they are the first statements in the constructor body. This is because both this() and super() must be the first statements in a constructor to avoid ambiguity.

Example:

class Parent {
    int x;
    public Parent(int x) {
        this.x = x;
    }
}
class Child extends Parent {
    int y;
    public Child(int x, int y) {
        super(x); // Call the constructor of the superclass
        this.y = y;
    }
}
public class Main {
    public static void main(String[] args) {
        Child obj = new Child(10, 20);
        System.out.println("X: " + obj.x + ", Y: " + obj.y); // Output: X: 10, Y: 20
    }
}

23) Can a constructor be recursive?

Yes, a constructor can be recursive, meaning a constructor can call itself. However, you should use recursive constructors with caution, ensuring that there is a base case to stop the recursion to avoid infinite recursion.

Example:

class MyClass {
    int value;
    // Recursive constructor
    public MyClass(int value) {
        if (value <= 0) {
            this.value = 0; // Base case: Stop recursion when value is less than or equal to 0
        } else {
            this.value = value;
            new MyClass(value - 1); // Recursive call
        }
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass(5);
        System.out.println("Value: " + obj.value); 
    }
}

Output:

Value: 0

24) Can a constructor be synchronized?

Yes, a constructor can be synchronized. When a constructor is marked as synchronized, it ensures that only one thread can enter the constructor and create an object at a time. This is useful in multi-threaded environments to avoid concurrent object creation issues.

Example:

class MyClass {
    int value;
    // Synchronized constructor
    public synchronized MyClass(int value) {
        this.value = value;
    }
}

25) What is the difference between default initialization and explicit initialization of instance variables in a constructor?

Default initialization assigns default values to instance variables (e.g., 0 for numeric types, null for object references) when they are declared. Explicit initialization, on the other hand, allows you to set custom values to instance variables within the constructor, enabling you to have more control over the initial state of the object.

Example:

class MyClass {
    int defaultVar; // Default initialization
    int explicitVar;
    public MyClass(int value) {
        explicitVar = value; // Explicit initialization within the constructor
    }
}
public class Main {
    public static void main(String[] args) {
        MyClass obj = new MyClass(42);
        System.out.println("Default Var: " + obj.defaultVar); // Output: Default Var: 0
        System.out.println("Explicit Var: " + obj.explicitVar); // Output: Explicit Var: 42
    }
}

26) Can a constructor call both this() and super() in the same constructor?

Yes, a constructor can call both this() and super() in the same constructor, but there are certain rules to follow. The this() and super() calls must be the first statements in the constructor, and they cannot be used together in the same constructor. However, you can use this() to call another constructor within the same class and super() to call a constructor in the immediate superclass.

Example:

class Parent {
    int x;
    public Parent(int x) {
        this.x = x;
    }
}
class Child extends Parent {
    int y;
    public Child(int x, int y) {
        super(x); // Call the constructor of the superclass
        this.y = y;
    }
    public Child(int y) {
        this(0, y); // Call another constructor within the same class using 'this()'
    }
}
public class Main {
    public static void main(String[] args) {
        Child obj1 = new Child(10, 20);
        System.out.println("X: " + obj1.x + ", Y: " + obj1.y); // Output: X: 10, Y: 20
        Child obj2 = new Child(30);
        System.out.println("X: " + obj2.x + ", Y: " + obj2.y); // Output: X: 0, Y: 30
    }
}

In this example, the Child class has two constructors?one with two arguments and another with one argument. The constructor with one argument calls the other constructor using this(), and the constructor with two arguments calls the constructor of the superclass using super(). By following these rules, you can effectively use this() and super() to create more flexible constructors in your Java classes.