Java Constructors

Welcome to The Coding College! In this guide, we’ll explore constructors in Java, their importance, and how to use them effectively. Constructors are a fundamental concept in Object-Oriented Programming (OOP), and mastering them will enhance your Java coding skills.

What is a Constructor in Java?

A constructor is a special method used to initialize objects. It is called automatically when an object of a class is created. Constructors ensure that an object is in a valid and ready-to-use state immediately after creation.

Key Features of a Constructor:

  • Name: Must have the same name as the class.
  • No Return Type: Constructors do not have a return type, not even void.
  • Automatic Invocation: They are invoked automatically during object creation.

Types of Constructors

1. Default Constructor

A constructor with no parameters is called a default constructor.

Example:

class Car {
    String model;

    // Default constructor
    Car() {
        model = "Unknown";
    }

    void displayModel() {
        System.out.println("Car Model: " + model);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car(); // Default constructor called
        myCar.displayModel();
    }
}

Output:

Car Model: Unknown

2. Parameterized Constructor

A constructor that accepts parameters to initialize an object with specific values.

Example:

class Car {
    String model;

    // Parameterized constructor
    Car(String modelName) {
        model = modelName;
    }

    void displayModel() {
        System.out.println("Car Model: " + model);
    }
}

public class Main {
    public static void main(String[] args) {
        Car myCar = new Car("Tesla Model S"); // Parameterized constructor called
        myCar.displayModel();
    }
}

Output:

Car Model: Tesla Model S

3. No-Argument Constructor

A constructor that has no parameters (similar to a default constructor but explicitly defined).

class Person {
    String name;

    // No-argument constructor
    Person() {
        name = "John Doe";
    }

    void displayName() {
        System.out.println("Name: " + name);
    }
}

public class Main {
    public static void main(String[] args) {
        Person person = new Person();
        person.displayName();
    }
}

4. Constructor Overloading

You can define multiple constructors in the same class, each with a different parameter list.

Example:

class Employee {
    String name;
    int id;

    // No-argument constructor
    Employee() {
        name = "Unknown";
        id = 0;
    }

    // Parameterized constructor
    Employee(String empName, int empId) {
        name = empName;
        id = empId;
    }

    void displayInfo() {
        System.out.println("Name: " + name + ", ID: " + id);
    }
}

public class Main {
    public static void main(String[] args) {
        Employee emp1 = new Employee(); // Calls no-argument constructor
        emp1.displayInfo();

        Employee emp2 = new Employee("Alice", 101); // Calls parameterized constructor
        emp2.displayInfo();
    }
}

Output:

Name: Unknown, ID: 0  
Name: Alice, ID: 101

Why Use Constructors?

  1. Automatic Initialization: Simplifies object initialization during creation.
  2. Encapsulation: Ensures data is initialized and encapsulated within the object.
  3. Overloaded Flexibility: Provides multiple ways to create and initialize objects.

Constructor Rules

  1. No Return Type: Constructors cannot have a return type, not even void.
  2. Constructor Name: Must match the class name exactly (case-sensitive).
  3. Cannot Be Static or Final: Constructors cannot be marked static, final, or abstract.
  4. Default Constructor Absence: If you define a constructor, the default constructor is not provided automatically.

Practical Example

A Class with Default and Parameterized Constructors

class Student {
    String name;
    int rollNo;

    // Default constructor
    Student() {
        name = "Not Assigned";
        rollNo = 0;
    }

    // Parameterized constructor
    Student(String studentName, int studentRollNo) {
        name = studentName;
        rollNo = studentRollNo;
    }

    void displayInfo() {
        System.out.println("Name: " + name + ", Roll No: " + rollNo);
    }
}

public class Main {
    public static void main(String[] args) {
        Student student1 = new Student(); // Default constructor
        Student student2 = new Student("Rohan", 101); // Parameterized constructor

        student1.displayInfo();
        student2.displayInfo();
    }
}

Output:

Name: Not Assigned, Roll No: 0  
Name: Rohan, Roll No: 101

Practice Problems

  1. Create a Book class with a default constructor that sets a default title and a parameterized constructor that accepts a title.
  2. Write a BankAccount class with constructors to initialize an account with or without an initial balance.
  3. Design a Shape class with constructors to initialize a rectangle (length and breadth) or a square (only side).

For more insights and tutorials, visit The Coding College and take your programming skills to the next level! 🚀

Leave a Comment