Learn Java constructors, including default and parameterized constructors, constructor overloading, chaining, and how constructors initialize objects.

Gaurav 29 Sep 2026 6 min read Sign in to save

On this page

What Is a Constructor in Java?
Why Are Constructors Used?
Constructor Syntax
Types of Constructors in Java
Default Constructor
Important
No-Argument Constructor
Parameterized Constructor
Using this in a Constructor
Constructor Overloading
Constructor Chaining
Rule for this()
Constructor Chaining with Inheritance
Constructors and Inheritance
Constructor vs Method
Can a Constructor Be static?
Can a Constructor Be final?
Can a Constructor Be abstract?
Can a Constructor Be private?
Copy Constructor Pattern
Constructor Execution Order
Common Constructor Mistakes
1. Adding a Return Type
2. Assuming a Default Constructor Always Exists
3. Calling this() After Another Statement
4. Confusing Constructors with Methods
Key Points to Remember
Conclusion

Java Constructors

A constructor in Java is a special member of a class that is automatically called when an object is created. Constructors are mainly used to initialize the object's state.

For example:

class Student {
    String name;
    int age;

    Student() {
        name = "Gaurav";
        age = 20;
    }
}

When an object is created:

Student student = new Student();

the Student() constructor is automatically called.

What Is a Constructor in Java?

A constructor is a special block of code that has the same name as the class and does not have a return type, not even void.

Example:

class Car {

    Car() {
        System.out.println("Constructor called");
    }
}

Creating an object:

Car car = new Car();

Output:

Constructor called

The constructor is executed automatically when the Car object is created.

Why Are Constructors Used?

Constructors are commonly used to:

Initialize instance variables.
Set default values.
Initialize objects with specific values.
Perform required initialization when an object is created.
Ensure an object starts in a valid state.

For example:

class Employee {
    String name;
    double salary;

    Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
}

Now an employee can be initialized when the object is created:

Employee employee = new Employee("Rahul", 50000);

Constructor Syntax

The basic syntax is:

class ClassName {

    ClassName() {
        // initialization code
    }
}

For example:

class Student {

    Student() {
        System.out.println("Student object created");
    }
}

A constructor has three important characteristics:

Its name must match the class name.
It does not have a return type.
It is automatically invoked when an object is created.

Types of Constructors in Java

Constructors are commonly discussed as:

Default constructor
No-argument constructor
Parameterized constructor
Copy constructor pattern

Java does not have a special built-in copy constructor feature like C++, but a constructor can be designed to copy values from another object.

Default Constructor

If you do not explicitly declare any constructor in a class, the Java compiler provides a default constructor.

Example:

class Student {
    String name;
    int age;
}

Conceptually, the compiler provides a no-argument constructor similar to:

Student() {
}

You can then create an object:

Student student = new Student();

The instance variables receive their normal Java default values.

For example:

int → 0
double → 0.0
boolean → false
Reference types → null

Important

The compiler provides a default constructor only when you do not declare any constructor yourself.

For example:

class Student {

    Student(String name) {
        this.name = name;
    }

    String name;
}

In this case, Java does not automatically provide Student().

Therefore:

Student student = new Student();

will cause a compilation error.

No-Argument Constructor

A no-argument constructor is a constructor that does not accept parameters.

Example:

class Student {

    String name;

    Student() {
        name = "Unknown";
    }
}

Here, Student() is explicitly defined by the programmer.

This is different from the compiler-provided default constructor because an explicitly written no-argument constructor can contain initialization logic.

Student student = new Student();

System.out.println(student.name);

Output:

Unknown

Parameterized Constructor

A parameterized constructor accepts arguments and uses them to initialize an object.

Example:

class Student {

    String name;
    int age;

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Create an object:

Student student = new Student("Rahul", 21);

The values passed to the constructor are assigned to the object's fields.

Using `this` in a Constructor

The this keyword refers to the current object.

It is commonly used when constructor parameters have the same names as instance variables.

class Employee {

    String name;
    double salary;

    Employee(String name, double salary) {
        this.name = name;
        this.salary = salary;
    }
}

Here:

this.name

refers to the instance variable, while:

name

refers to the constructor parameter.

Without this, the assignment can become ambiguous.

Constructor Overloading

Java supports constructor overloading, which means a class can have multiple constructors with different parameter lists.

Example:

class Student {

    String name;
    int age;

    Student() {
        name = "Unknown";
        age = 0;
    }

    Student(String name) {
        this.name = name;
        age = 0;
    }

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

Now different constructors can be used depending on the available information:

Student student1 = new Student();

Student student2 = new Student("Rahul");

Student student3 = new Student("Amit", 22);

Constructor overloading provides flexibility when creating objects.

Constructor Chaining

Constructor chaining means one constructor calls another constructor in the same class or parent class.

The this() keyword is used to call another constructor in the same class.

Example:

class Student {

    String name;
    int age;

    Student() {
        this("Unknown", 0);
    }

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

When this code executes:

Student student = new Student();

the no-argument constructor calls the parameterized constructor.

Rule for `this()`

When used inside a constructor, this() must be the first statement.

For example:

Student() {
    this("Unknown", 0);
}

is valid.

But:

Student() {
    System.out.println("Creating student");
    this("Unknown", 0);
}

is invalid because this() is not the first statement.

Constructor Chaining with Inheritance

The super() keyword is used to call a constructor of the parent class.

Example:

class Animal {

    Animal() {
        System.out.println("Animal constructor");
    }
}

class Dog extends Animal {

    Dog() {
        super();
        System.out.println("Dog constructor");
    }
}

Creating an object:

Dog dog = new Dog();

Output:

Animal constructor
Dog constructor

The parent constructor executes before the child constructor.

If a child constructor does not explicitly call super(), Java implicitly attempts to insert a call to the accessible no-argument constructor of the parent class.

Constructors and Inheritance

Constructors are not inherited by subclasses.

For example:

class Animal {

    Animal(String name) {
        System.out.println(name);
    }
}

class Dog extends Animal {

    Dog() {
        super("Dog");
    }
}

The Dog class does not inherit the Animal(String) constructor. Instead, it explicitly invokes it using super().

Constructor vs Method

Constructors and methods are different.

Constructor	Method
Initializes an object	Performs an operation
Same name as the class	Can have any valid name
Has no return type	Has a return type or `void`
Called automatically during object creation	Usually called explicitly
Cannot be inherited	Methods can be inherited
Cannot be overridden	Methods can be overridden

Example:

class Car {

    Car() {
        System.out.println("Car created");
    }

    void drive() {
        System.out.println("Car is driving");
    }
}

Here, Car() is the constructor and drive() is a method.

Can a Constructor Be `static`?

No. Constructors cannot be declared static.

For example, this is invalid:

class Student {

    static Student() {
    }
}

Constructors belong to object creation, while static members belong to the class itself.

Can a Constructor Be `final`?

No. Constructors cannot be declared final.

The final keyword is used with methods, variables, and classes, but it does not apply to constructors.

Can a Constructor Be `abstract`?

No. Constructors cannot be abstract.

An abstract method requires implementation in a subclass, while a constructor is responsible for initializing an object of its class.

Can a Constructor Be `private`?

Yes. A constructor can be private.

A private constructor prevents code outside the class from directly creating objects using that constructor.

Example:

class Database {

    private Database() {
    }
}

This prevents:

Database db = new Database();

from outside the class.

Private constructors are commonly used in patterns such as utility classes and certain singleton implementations.

Copy Constructor Pattern

Java does not provide a special copy constructor syntax, but you can create a constructor that accepts another object of the same class.

Example:

class Student {

    String name;
    int age;

    Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    Student(Student other) {
        this.name = other.name;
        this.age = other.age;
    }
}

Usage:

Student student1 = new Student("Rahul", 21);

Student student2 = new Student(student1);

The second constructor copies values from student1.

Constructor Execution Order

When an object of a child class is created, constructors execute from the parent class toward the child class.

Example:

class Animal {

    Animal() {
        System.out.println("Animal");
    }
}

class Dog extends Animal {

    Dog() {
        System.out.println("Dog");
    }
}

Creating the object:

Dog dog = new Dog();

Output:

Animal
Dog

This ensures that the parent portion of the object is initialized before the child portion.

Common Constructor Mistakes

1. Adding a Return Type

This is not a constructor:

void Student() {
}

It is a method named Student.

The correct constructor is:

Student() {
}

2. Assuming a Default Constructor Always Exists

If you define any constructor yourself, Java does not automatically add a no-argument constructor.

class Student {

    Student(String name) {
    }
}

This does not provide:

Student()

3. Calling `this()` After Another Statement

This is invalid:

Student() {
    System.out.println("Hello");
    this("Unknown");
}

this() must be the first statement.

4. Confusing Constructors with Methods

A constructor has no return type and has the same name as its class.

class Student {

    Student() {
        // Constructor
    }

    void Student() {
        // Method
    }
}

These are different members.

Key Points to Remember

A constructor initializes an object when it is created.
A constructor has the same name as its class.
A constructor does not have a return type.
Constructors are called automatically when objects are created.
Java provides a compiler-generated default constructor only when no constructor is declared.
Constructors can be overloaded.
this() is used for constructor chaining within the same class.
super() is used to invoke a parent-class constructor.
Constructors are not inherited or overridden.
Constructors can be private.
Constructors cannot be static, final, or abstract.
Java does not have a dedicated copy-constructor feature, but a copy-constructor pattern can be implemented manually.

Conclusion

Constructors are an important part of Java object creation and initialization. They allow developers to ensure that objects begin with appropriate values and provide different ways to initialize objects through constructor overloading and chaining.

Understanding constructors is essential for working with classes, objects, inheritance, encapsulation, and object-oriented programming in Java.

classes constructors inheritance interview java objects oop overloading

Found a problem on this page, or something that could be clearer?

What kind of thing?

What happened?

Email — only if you want a reply

Goes straight to the author. Not published anywhere.

Java Constructors

Java Constructors

What Is a Constructor in Java?

Why Are Constructors Used?

Constructor Syntax

Types of Constructors in Java

Default Constructor

Important

No-Argument Constructor

Parameterized Constructor

Using this in a Constructor

Constructor Overloading

Constructor Chaining

Rule for this()

Constructor Chaining with Inheritance

Constructors and Inheritance

Constructor vs Method

Can a Constructor Be static?

Can a Constructor Be final?

Can a Constructor Be abstract?

Can a Constructor Be private?

Copy Constructor Pattern

Constructor Execution Order

Common Constructor Mistakes

1. Adding a Return Type

2. Assuming a Default Constructor Always Exists

3. Calling this() After Another Statement

4. Confusing Constructors with Methods

Key Points to Remember

Conclusion

Related

Inheritance

Java Encapsulation

Java Polymorphism

Java Abstraction

Using `this` in a Constructor

Rule for `this()`

Can a Constructor Be `static`?

Can a Constructor Be `final`?

Can a Constructor Be `abstract`?

Can a Constructor Be `private`?

3. Calling `this()` After Another Statement