Topic 10624 min readStructured Tutorial

Java Constructors Explained

Quick Answer

Constructors explains in Java, constructors are special methods used to initialize new objects.

Learning Objectives

Explain the purpose of Constructors in a practical learning context.
Identify the main ideas, terms, and decisions involved in Constructors.
Apply Constructors in a simple real-world scenario or practice task.

Introduction

In Java, constructors are special methods used to initialize new objects.

They have the same name as the class and do not have a return type.

Constructors help set initial values for object attributes when an object is created.

A constructor is the foundation of every Java object.

What is a Constructor?

A constructor is a block of code called when an instance of a class is created.

It prepares the new object by initializing its fields or performing setup tasks.

Has the same name as the class.
No return type, not even void.
Automatically called when using the new keyword.
Can be overloaded to provide multiple ways to initialize an object.

Types of Constructors

Java supports two main types of constructors: default and parameterized.

Constructor Types Comparison
Constructor Type	Description	Example Usage
Default Constructor	No parameters, initializes with default values.	public Car() { this.color = "red"; }
Parameterized Constructor	Accepts parameters to initialize fields with specific values.	public Car(String color) { this.color = color; }

How to Define and Use Constructors

To define a constructor, write a method with the class name and no return type.

You can overload constructors by providing different parameter lists.

Use the this keyword to refer to the current object's fields.
Call one constructor from another using this() syntax.

Constructor Overloading Example

Multiple constructors allow flexible object creation.

Constructor Rules and Characteristics

Constructors have specific rules that distinguish them from regular methods.

Must have the same name as the class.
Cannot have a return type.
Are called automatically when an object is created.
If no constructor is defined, Java provides a default no-argument constructor.
Constructors can call other constructors in the same class using this().

Practical Example

This example defines a parameterized constructor to initialize the car's color and displays it.

This example shows a default constructor and a parameterized constructor to create boxes with different dimensions.

Examples

Simple Constructor Example

public class Car {
  String color;

  // Constructor
  public Car(String color) {
    this.color = color;
  }

  public void display() {
    System.out.println("Car color: " + color);
  }

  public static void main(String[] args) {
    Car myCar = new Car("blue");
    myCar.display();
  }
}

This example defines a parameterized constructor to initialize the car's color and displays it.

Constructor Overloading Example

public class Box {
  int width, height, depth;

  // Default constructor
  public Box() {
    width = height = depth = 0;
  }

  // Parameterized constructor
  public Box(int w, int h, int d) {
    width = w;
    height = h;
    depth = d;
  }

  public int volume() {
    return width * height * depth;
  }

  public static void main(String[] args) {
    Box box1 = new Box();
    Box box2 = new Box(3, 4, 5);
    System.out.println("Volume of box1: " + box1.volume());
    System.out.println("Volume of box2: " + box2.volume());
  }
}

This example shows a default constructor and a parameterized constructor to create boxes with different dimensions.

Best Practices

Always initialize all important fields in your constructors.
Use constructor overloading to provide flexible object creation options.
Avoid complex logic inside constructors; keep them simple and focused on initialization.
Use this() to call other constructors and reduce code duplication.
Document your constructors clearly to explain their purpose.

Common Mistakes

Defining a constructor with a return type (which makes it a method, not a constructor).
Forgetting to initialize important fields in the constructor.
Not using constructor overloading when multiple initialization options are needed.
Trying to call a constructor like a regular method after object creation.
Confusing default constructors with no-argument constructors defined explicitly.

Hands-on Exercise

Create a Class with Multiple Constructors

Define a class Person with fields name and age. Create a default constructor and a parameterized constructor to initialize these fields. Instantiate objects using both constructors and print their details.

Expected output: Printed details of Person objects with default and specified values.

Hint: Use constructor overloading and the this keyword.

Constructor Chaining Practice

Create a class Rectangle with width and height. Implement three constructors: no-argument, one-argument (square), and two-argument. Use constructor chaining to avoid code duplication.

Expected output: Correct initialization of Rectangle objects with different constructors.

Hint: Use this() to call constructors from other constructors.

Interview Questions

What is a constructor in Java?

Interview

A constructor is a special method used to initialize objects. It has the same name as the class and no return type.

Can constructors be overloaded in Java?

Interview

Yes, constructors can be overloaded by defining multiple constructors with different parameter lists.

What happens if you do not define any constructor in a Java class?

Interview

Java provides a default no-argument constructor automatically if no constructors are defined.

How do you call one constructor from another in the same class?

Interview

You use the this() keyword with appropriate parameters to call another constructor.