Constructors in OOP

In Java, a constructor is a special type of method that is used to initialize objects. It is called when an instance of a class is created. The main purpose of a constructor is to set initial values for the object’s fields (variables).

Think of it as a way of setting up your object when it is first created, similar to preparing a car before driving it.

Key Features of a Constructor

• Same Name as the Class: A constructor must have the same name as the class it is in.
• No Return Type: Constructors do not have a return type, not even void.
• Called Automatically: A constructor is automatically called when an object is created using the new keyword.

Why Use a Constructor?

Imagine you want to create multiple Car objects with different properties (like color, make, and model). Instead of setting these properties manually for each car, you can pass them as parameters to the constructor. This simplifies object creation and ensures that every car object is created properly.

Types of Constructors

1. Parameterized Constructor: Accepts arguments to initialize the object’s fields.
2. Default Constructor (No-argument Constructor): Does not accept any parameters and assigns default values to the fields.

Parameterized Constructor

Let’s take a look at the Car class you provided:

public class Car {
    private String color;
    private String make;
    private String model;

    // Parameterized Constructor
    public Car(String color, String make, String model) {
        this.color = color;
        this.make = make;
        this.model = model;
    }
    public void start() {
        System.out.println("Car started.");
    }
    public void stop() {
        System.out.println("Car stopped.");
    }
    public void accelerate() {
        System.out.println("Car accelerating.");
    }
}

How it works:

• The constructor Car(String color, String make, String model) takes three arguments: color, make, and model.
• Inside the constructor, this.color, this.make, and this.model refer to the instance variables of the class, and they are assigned the values passed through the constructor.

Usage Example:

public class Main {
    public static void main(String[] args) {
        // Creating a new Car object using the constructor
        Car myCar = new Car("Red", "Toyota", "Corolla");

        // Calling methods on the Car object
        myCar.start();
        myCar.accelerate();
        myCar.stop();
    }
}

In the above code:

• A Car object myCar is created with specific values ("Red", "Toyota", "Corolla").
• When myCar is created, the constructor initializes its color, make, and model with the values provided.

Constructor with No Parameters (Default Constructor)

If you don’t provide a constructor in your class, Java provides a default constructor. However, you can also explicitly define your own no-parameter constructor if you want.

Here’s how you could add a no-parameter constructor:

public class Car {
    private String color;
    private String make;
    private String model;

    // No-argument Constructor (Default Constructor)
    public Car() {
        this.color = "Unknown";
        this.make = "Unknown";
        this.model = "Unknown";
    }
    public void start() {
        System.out.println("Car started.");
    }
    public void stop() {
        System.out.println("Car stopped.");
    }
    public void accelerate() {
        System.out.println("Car accelerating.");
    }
}

How it works:

• The no-argument constructor (public Car()) sets default values to the fields color, make, and model (in this case, "Unknown").

Usage Example:

public class Main {
    public static void main(String[] args) {
        
        Car defaultCar = new Car();

        defaultCar.start();  
      
    }
}

defaultCar uses the no-argument constructor, so it has default values ("Unknown").

Key Points About Constructors:

1. Constructor Overloading: You can have multiple constructors in a class, as long as they have different parameter lists. This is known as constructor overloading.
2. No Return Type: Constructors do not return any value, not even void.
3. Default Constructor: If no constructor is defined in a class, Java provides a default no-argument constructor. But if any constructor is defined, Java no longer provides a default one.

Download the presentation here.