Introduction to Java Constructors

What is a Constructor?

Think about building a new car. The blueprint for the car is like a class in Java. It defines all the potential properties, like color, model, and engine size. But a blueprint isn't a car. To get a real, drivable car, you have to build it on the assembly line.

A constructor is like that initial assembly process. It's a special block of code that runs automatically whenever a new object is created from a class. Its main job is to initialize the object, giving its instance variables their starting values. It ensures that when your object comes into existence, it's in a valid and ready-to-use state.

A constructor is a special type of method used in object-oriented programming languages to initialize objects.

Writing a Constructor

Constructors look similar to methods, but they follow two very specific rules that set them apart.

A constructor's name must be the exact same as its class name.

A constructor cannot have a return type, not even void.

These rules are how the Java compiler identifies a constructor. If you give it a return type or a different name, Java will just treat it as a regular method.

Let's look at a simple Car class with a constructor.

class Car {
    String model;

    // This is the constructor for the Car class
    public Car() {
        model = "Generic"; // Sets the initial value for the model field
        System.out.println("A new car has been created!");
    }

    // This is a regular method
    void drive() {
        System.out.println("The car is moving.");
    }
}

In this example, public Car() is the constructor. Notice its name matches the class name, Car, and it has no return type. When we create a new Car object, this constructor will automatically set the model to "Generic" and print a message to the console.

How Constructors Differ from Methods

While both are blocks of code, their roles and rules are distinct. The primary purpose of a constructor is object initialization. The purpose of a method is to expose the behavior of an object.

Another key difference is how they are called. You must call a method explicitly using its name, like myCar.drive(). You never call a constructor directly. It's invoked implicitly by the system when you use the new keyword to create an object.

Feature	Constructor	Method
Purpose	Initializes a new object	Performs an action or operation
Name	Same as the class name	Any legal identifier
Return Type	None (not even void)	Must have a return type or void
Invocation	Called implicitly with `new`	Called explicitly by the developer

The 'new' Keyword

The new keyword is the key that triggers object creation and constructor invocation. When you write a line of code like Car myCar = new Car();, a few things happen in order.

First, the new keyword allocates memory for a new Car object. Then, it invokes the Car constructor to set up the initial state of that object. Finally, a reference to the newly created and initialized object in memory is assigned to the myCar variable.

Let's see this in a complete, runnable program.

public class Dealership {
    public static void main(String[] args) {
        // The 'new' keyword creates the object and calls the constructor
        Car firstCar = new Car();

        // Now we can use the object
        System.out.println("Model: " + firstCar.model);
        firstCar.drive();
    }
}

// We can put the Car class in the same file for this example
class Car {
    String model;

    public Car() {
        model = "Generic";
        System.out.println("A new car has been created!");
    }

    void drive() {
        System.out.println("The car is moving.");
    }
}

When you run this code, the output will be:

A new car has been created! Model: Generic The car is moving.

As you can see, the message from the constructor printed first, confirming it was called during the object creation process. After that, we were able to access the model field that it initialized.

Quiz Questions 1/6

What is the primary purpose of a constructor in Java?

Quiz Questions 2/6

Which two rules are mandatory for a code block to be a valid constructor?

Constructors are a fundamental part of object-oriented programming in Java. They provide a reliable way to set up your objects, ensuring they start their lives in a consistent and predictable state.

Java Constructors Explained