Master OOP in Java

Defining a Class

A class is declared using the class keyword. It contains fields (data/attributes) and methods (behaviour).

public class Student {

    // Fields (instance variables)
    private String name;
    private int age;
    private double gpa;

    // Method (behaviour)
    public void study() {
        System.out.println(name + " is studying!");
    }

    public void introduce() {
        System.out.println("Hi, I am " + name + " and I'm " + age);
    }
}Java

Creating Objects

An object is an instance of a class, created using the new keyword. Each object gets its own copy of the instance variables.

public class Main {
    public static void main(String[] args) {

        // Creating objects (instances) of Student class
        Student s1 = new Student();
        Student s2 = new Student();

        // s1 and s2 are SEPARATE objects — they don't share data
        s1.name = "Rahul";   // Only possible if field is public
        s2.name = "Priya";

        s1.study();  // Output: Rahul is studying!
        s2.study();  // Output: Priya is studying!
    }
}Java

Instance vs Class Members

The new Keyword — What Actually Happens

When you write new Student(), Java does three things:

1. Allocates memory in the heap for the new object.
2. Initialises instance variables to default values (0, null, false).
3. Calls the constructor to set up the object.

A constructor is a special method that is automatically called when an object is created with new. Its job is to initialise the object.

Types of Constructors

1. Default Constructor

If you write no constructor, Java automatically provides a no-argument constructor that sets all fields to default values. As soon as you define any constructor, Java stops providing this.

public class Car {
    String brand;
    int speed;

    // Java provides this implicitly if you write nothing:
    // public Car() { }  — fields get: brand=null, speed=0
}Java

2. Parameterised Constructor

Accepts arguments so you can initialise an object with specific values at creation time.

public class Car {
    private String brand;
    private int speed;

    // Parameterised Constructor
    public Car(String brand, int speed) {
        this.brand = brand;   // 'this' differentiates field from parameter
        this.speed = speed;
    }

    public void display() {
        System.out.println(brand + " goes " + speed + " km/h");
    }
}

// Usage:
Car c1 = new Car("Toyota", 180);  // brand="Toyota", speed=180
Car c2 = new Car("BMW", 250);     // brand="BMW", speed=250Java

3. Constructor Overloading

Multiple constructors with different parameter lists in the same class. Java picks the right one based on the arguments.

public class Rectangle {
    private double length, width;

    // No-arg constructor — creates a unit square
    public Rectangle() {
        this.length = 1.0;
        this.width = 1.0;
    }

    // One-arg — creates a square of given size
    public Rectangle(double side) {
        this.length = side;
        this.width = side;
    }

    // Two-arg — creates a rectangle
    public Rectangle(double length, double width) {
        this.length = length;
        this.width = width;
    }

    public double area() { return length * width; }
}

// All valid:
Rectangle r1 = new Rectangle();           // 1×1
Rectangle r2 = new Rectangle(5.0);        // 5×5
Rectangle r3 = new Rectangle(4.0, 6.0);  // 4×6Java

4. Copy Constructor

Creates a new object as a copy of an existing one. Java doesn't provide one automatically like C++ — you write it manually.

public Car(Car other) {
    this.brand = other.brand;
    this.speed = other.speed;
}

Car original = new Car("Honda", 150);
Car copy = new Car(original);  // separate object, same dataJava

Access Modifiers

Implementing Encapsulation

public class BankAccount {

    // Step 1: Make fields PRIVATE
    private String owner;
    private double balance;

    public BankAccount(String owner, double initialBalance) {
        this.owner = owner;
        this.balance = initialBalance;
    }

    // Step 2: Provide PUBLIC getters (read access)
    public String getOwner() { return owner; }
    public double getBalance() { return balance; }

    // Step 3: Provide PUBLIC setters (write access) WITH VALIDATION
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        } else {
            System.out.println("Deposit amount must be positive!");
        }
    }

    public void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            System.out.println("Invalid withdrawal!");
        }
    }
}Java

Why Encapsulation Matters

• Data hiding — Internal state is safe from accidental corruption.
• Controlled access — You can make a field read-only (getter, no setter).
• Validation — Setters can enforce rules before changing data.
• Maintainability — You can change the internal implementation without breaking external code.

Inheritance allows a class (child/subclass) to acquire properties and methods of another class (parent/superclass). It's Java's primary mechanism for code reuse.

Basic Inheritance

// Parent (Superclass)
public class Animal {
    protected String name;
    protected int age;

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

    public void eat() {
        System.out.println(name + " is eating.");
    }

    public void breathe() {
        System.out.println(name + " is breathing.");
    }
}

// Child (Subclass) — inherits from Animal
public class Dog extends Animal {

    private String breed;

    public Dog(String name, int age, String breed) {
        super(name, age);   // Call parent constructor FIRST
        this.breed = breed;
    }

    // Dog's own behaviour
    public void bark() {
        System.out.println(name + " says: Woof!");
    }
}

// Dog inherits eat() and breathe() from Animal
Dog d = new Dog("Bruno", 3, "Labrador");
d.eat();     // Inherited from Animal → "Bruno is eating."
d.bark();    // Dog's own method → "Bruno says: Woof!"Java

Types of Inheritance in Java

Method Overriding

A child class can redefine a method from the parent class. The child's version replaces the parent's when called on a child object.

public class Animal {
    public void makeSound() {
        System.out.println("Some generic animal sound");
    }
}

public class Dog extends Animal {
    @Override   // Good practice — compiler checks you're actually overriding
    public void makeSound() {
        System.out.println("Woof!");
    }
}

public class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

Animal a = new Dog();  // Polymorphism — covered next chapter
a.makeSound();          // Output: "Woof!" — Dog's version runsJava

The word comes from Greek: poly (many) + morphos (forms). In Java, polymorphism means that the same method call can behave differently depending on the object it's acting on.

Two Types

Method Overloading (Compile-time)

Same method name, different parameters in the same class.

public class Calculator {

    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {  // different param types
        return a + b;
    }

    public int add(int a, int b, int c) {  // different param count
        return a + b + c;
    }
}

Calculator calc = new Calculator();
calc.add(2, 3);          // Calls first: int version → 5
calc.add(2.5, 3.5);     // Calls second: double version → 6.0
calc.add(1, 2, 3);       // Calls third: three-arg version → 6Java

Runtime Polymorphism — The Magic

This is where it gets powerful. A parent class reference can hold a child class object. The method called is determined at runtime based on the actual object type.

class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }
}

class Circle extends Shape {
    @Override
    public void draw() { System.out.println("Drawing a circle ○"); }
}

class Triangle extends Shape {
    @Override
    public void draw() { System.out.println("Drawing a triangle △"); }
}

// Runtime polymorphism in action:
Shape s;

s = new Circle();    // Shape ref → Circle object
s.draw();            // "Drawing a circle ○" — Circle's version!

s = new Triangle(); // Shape ref → Triangle object
s.draw();            // "Drawing a triangle △" — Triangle's version!

// POWER: Process any shape uniformly
Shape[] shapes = { new Circle(), new Triangle(), new Circle() };
for (Shape shape : shapes) {
    shape.draw();  // Correct version called each time — automatically!
}Java

Abstraction is the process of hiding complex implementation details and showing only the essential features of an object. Think about driving a car — you know how to use the steering wheel and pedals, but you don't need to understand the combustion engine internals.

In Java, abstraction is achieved via abstract classes and interfaces.

Abstract Classes

abstract class Vehicle {

    protected String model;
    protected int year;

    public Vehicle(String model, int year) {
        this.model = model;
        this.year = year;
    }

    // Abstract method — NO body, subclass MUST implement
    public abstract void fuelUp();
    public abstract double calculateRange();

    // Concrete method — has body, inherited as-is
    public void displayInfo() {
        System.out.println(year + " " + model);
    }
}

class ElectricCar extends Vehicle {
    private double batteryCapacity;

    public ElectricCar(String model, int year, double battery) {
        super(model, year);
        this.batteryCapacity = battery;
    }

    @Override
    public void fuelUp() {
        System.out.println("Charging battery...");
    }

    @Override
    public double calculateRange() {
        return batteryCapacity * 6.5; // 6.5 km per kWh
    }
}

// Vehicle v = new Vehicle(...);  ← ERROR! Cannot instantiate abstract class
Vehicle v = new ElectricCar("Tesla Model 3", 2024, 82.0);
v.fuelUp();           // "Charging battery..."
v.displayInfo();      // "2024 Tesla Model 3"Java

An interface defines a contract — a set of method signatures that a class promises to implement. Think of it as a job description: "Anyone who takes this role MUST be able to do these things."

Defining an Interface

// By default, interface methods are public and abstract
public interface Drawable {
    void draw();        // implicitly public abstract
    double getArea();
}

public interface Serializable {
    void serialize();
}

// A class can implement MULTIPLE interfaces — solves multiple inheritance!
public class Circle implements Drawable, Serializable {
    private double radius;

    public Circle(double radius) { this.radius = radius; }

    @Override
    public void draw() {
        System.out.println("Drawing circle with radius: " + radius);
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }

    @Override
    public void serialize() {
        System.out.println("Serializing circle data...");
    }
}Java

Abstract Class vs Interface — The Big Comparison

Java 8+ Interface Features

public interface Logger {

    // Abstract method (must implement)
    void log(String message);

    // Default method — has a body, optional to override
    default void logError(String message) {
        log("ERROR: " + message);
    }

    // Static method — called via interface name, not object
    static Logger getConsoleLogger() {
        return msg -> System.out.println("[LOG] " + msg);
    }
}Java

The static Keyword

static members belong to the class, not to individual objects. There's exactly one copy, shared by all instances.

public class Counter {

    private static int count = 0;  // Shared by ALL Counter objects
    private int id;               // Each object has its OWN id

    public Counter() {
        count++;              // Every time a Counter is created, count grows
        this.id = count;
    }

    public static int getCount() { return count; }
    public int getId() { return id; }
}

Counter c1 = new Counter();
Counter c2 = new Counter();
Counter c3 = new Counter();

System.out.println(Counter.getCount());  // 3 — accessed via class nameJava

Static Blocks

public class Config {
    public static final String DB_URL;

    static {  // Runs once when class is first loaded
        DB_URL = "jdbc:mysql://localhost:3306/mydb";
        System.out.println("Config class loaded.");
    }
}Java

The final Keyword

// final variable — must be initialised once
final double PI = 3.14159;
// PI = 3.0;  ← COMPILE ERROR

// final class — String is a classic example
public final class ImmutablePoint {
    private final double x, y;  // Both fields are final too

    public ImmutablePoint(double x, double y) {
        this.x = x;
        this.y = y;
    }

    public double getX() { return x; }
    public double getY() { return y; }
}

// class MyPoint extends ImmutablePoint {}  ← COMPILE ERRORJava

The this Keyword

this is a reference to the current object — the object on which the method is being called.

public class Employee {
    private String name;
    private double salary;

    // Use 1: Distinguish field from parameter with same name
    public Employee(String name, double salary) {
        this.name = name;      // this.name = field, name = parameter
        this.salary = salary;
    }

    // Use 2: Call another method of the same object
    public void printDetails() {
        this.validate();  // 'this.' is optional here, but makes intent clear
        System.out.println(name + ": ₹" + salary);
    }

    // Use 3: Constructor chaining — call another constructor
    public Employee(String name) {
        this(name, 30000.0);  // Calls the 2-param constructor above
    }

    private void validate() { /* validation logic */ }
}Java

The super Keyword

super refers to the parent class. It lets you access parent class members that have been hidden or overridden.

public class Animal {
    protected String name;

    public Animal(String name) {
        this.name = name;
    }

    public void describe() {
        System.out.println("I am an animal named " + name);
    }
}

public class Dog extends Animal {
    private String breed;

    public Dog(String name, String breed) {
        super(name);   // Use 1: Call parent constructor
        this.breed = breed;
    }

    @Override
    public void describe() {
        super.describe();   // Use 2: Call parent's version of the method
        System.out.println("I am a " + breed + " dog!");
    }
}

Dog d = new Dog("Bruno", "Labrador");
d.describe();
// Output:
// I am an animal named Bruno
// I am a Labrador dog!Java

These are genuine questions asked at companies. Practice saying these answers out loud.

Keywords Summary

Access Modifiers Quick View

The Four Pillars — One-Line Definitions

Abstract Class vs Interface — Quick

Overloading vs Overriding — Quick

Common Exam Traps

• Constructors are not inherited — but they are chained via super().
• You cannot override private methods — they aren't visible to the child.
• Static methods are hidden, not overridden.
• Interfaces cannot have instance fields — only public static final constants.
• Abstract classes can have constructors — called by subclass via super().
• final method can be inherited, just not overridden.
• Java passes object references by value — not actual objects.