Module 5: Object-Oriented Programming — Classes & Objects

A Class is a blueprint or template that defines what data an object will hold (its fields or attributes) and what actions it can perform (its methods). A class definition occupies memory in the JVM's Metaspace for its bytecode, but holds no data instances.

An Object is a concrete, living instance instantiated from a class template using the new keyword. When an object is created, the JVM allocates memory for it on the Heap and automatically executes a constructor to initialize its instance variables.

class Car {
    String color; // instance field
    int speed;

    void drive() {
        System.out.println(color + " car driving at " + speed + " km/h");
    }
}

public class Main {
    public static void main(String[] args) {
        Car c1 = new Car();
        c1.color = "Red";
        c1.speed = 100;

        Car c2 = new Car();
        c2.color = "Blue";
        c2.speed = 120; // c1 and c2 are completely independent instances on the heap!
    }
}

A Constructor is a special member method that shares the exact same name as the class and has no return type — not even void. It is called automatically and exactly once whenever an object is instantiated with new.

The Role of the this Keyword

The this keyword is an implicit reference variable that points to the current executing object instance. Its two most essential uses are:

• Resolving Naming Shadowing: When a constructor parameter has the exact same identifier as an instance variable, this.name refers to the instance field on the heap, while name refers to the local parameter on the stack:

  class Student {
      String name;
      int roll;
  
      Student(String name, int roll) {
          this.name = name; // this.name = instance field, name = parameter
          this.roll = roll;
      }
  }

• Constructor Chaining via this(): Calling another constructor in the same class. Crucial rule: The call to this(...) MUST be the first statement in the constructor body.

Methods define the reusable operations and behavior that an object can perform. Java supports Method Overloading (also called Compile-Time Polymorphism): defining multiple methods in the same class with the exact same name but different parameter lists.

class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
    int add(int a, int b, int c) { return a + b + c; }
}

The Method Signature Rule

In Java, a method's signature consists exclusively of: Method Name + Parameter Type List.

Understanding the distinction between Static and Instance members is crucial for designing clean object architectures and mastering Java memory management:

• Instance Members: Belong to each individual object. Every object created with new receives its own separate memory copy on the heap. Instance methods operate within the context of this.
• Static Members: Marked with the static keyword and belong to the Class blueprint itself. Loaded once into the Metaspace when the class is loaded by the ClassLoader, and shared across all instances:

  class Student {
      String name;            // Instance variable: each student has their own name
      static String college = "MIT"; // Static variable: shared across all 1,000 students
  }