Java OOP — Complete Guide

Java is a class-based, object-oriented language. Every piece of running logic lives inside a class, and every value you work with (except the 8 primitives) is an object. Understanding OOP is not optional in Java — it is the language. The sooner you build a solid mental model of objects, classes, and the four pillars, the easier every other topic becomes.

What Is OOP?

Object-Oriented Programming organises code around objects — self-contained units that bundle data (fields) and behaviour (methods). This mirrors how we think about the real world: a BankAccount knows its own balance and knows how to deposit or withdraw. A Car knows its own speed and knows how to accelerate. This bundling of state and behaviour in one place is what makes large codebases manageable — each object is responsible for itself.

The alternative — procedural code — passes data between separate functions. OOP keeps data and the functions that operate on it together, making large codebases dramatically easier to manage.

The Four Pillars

Each pillar solves a specific design problem. Encapsulation prevents accidental state corruption. Inheritance enables code reuse across related types. Polymorphism lets one piece of code work with many different types. Abstraction lets you work at a higher level without being tangled in implementation details.

Learning Path

Work through these in order. Each page builds on the previous one.

Beginner

1. Introduction to OOP in Java — classes, objects, constructors, this
2. Encapsulation — access modifiers, getters/setters, immutability
3. Inheritance — extends, super, method overriding, final
4. Polymorphism — runtime dispatch, @Override, interface polymorphism
5. Abstraction — abstract classes, interface, default methods

Intermediate

6. Interfaces — Deep Dive — segregation, default methods, functional interfaces
7. Abstract Classes — template method pattern, partial implementations
8. Method Overloading — compile-time polymorphism, varargs, autoboxing
9. Composition vs Inheritance — when to favour composition, Decorator pattern

Advanced

10. SOLID Principles — five design principles every Java engineer must know
11. Design Patterns — Singleton, Factory, Observer, Strategy, Builder
12. Generics and OOP — type-safe collections, bounded wildcards, generic methods

The four pillars in one program

Here is a small but complete program that uses all four pillars at once. Each comment names the pillar at work; the lessons above cover each in depth.

import java.util.List;

public class Pillars {
    interface Shape {                                   // abstraction: what, not how
        double area();
        default String describe() { return getClass().getSimpleName() + " " + String.format("%.1f", area()); }
    }

    static class Rectangle implements Shape {
        private final double w, h;                      // encapsulation: private state
        Rectangle(double w, double h) {
            if (w <= 0 || h <= 0) throw new IllegalArgumentException("sides must be positive");
            this.w = w; this.h = h;
        }
        public double area() { return w * h; }
    }

    static class Square extends Rectangle {             // inheritance: a Square is a Rectangle
        Square(double side) { super(side, side); }
    }

    record Circle(double r) implements Shape {
        public double area() { return Math.PI * r * r; }
    }

    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Rectangle(2, 3), new Square(4), new Circle(1));
        for (Shape s : shapes) System.out.println(s.describe());   // polymorphism
        double total = shapes.stream().mapToDouble(Shape::area).sum();
        System.out.printf("total %.2f%n", total);
    }
}

$ java Pillars.java
Rectangle 6.0
Square 16.0
Circle 3.1
total 25.14

The loop never asks which kind of shape it has: each object answers area() its own way (polymorphism) behind the Shape interface (abstraction). Square reuses Rectangle’s fields and validation through super (inheritance), and nothing outside Rectangle can change w or h (encapsulation).

Practice

1. Add a Triangle(double base, double height) record implementing Shape and include it in the list. Which existing code had to change?

import java.util.List;

public class AddTriangle {
    interface Shape {
        double area();
        default String describe() { return getClass().getSimpleName() + " " + String.format("%.1f", area()); }
    }

    record Circle(double r) implements Shape {
        public double area() { return Math.PI * r * r; }
    }

    record Triangle(double base, double height) implements Shape {
        public double area() { return 0.5 * base * height; }
    }

    public static void main(String[] args) {
        List<Shape> shapes = List.of(new Circle(1), new Triangle(3, 4));
        for (Shape s : shapes) System.out.println(s.describe());
    }
}

$ java AddTriangle.java
Circle 3.1
Triangle 6.0

2. Try to construct new Rectangle(-1, 2), catch the exception, and print its message. Which pillar protects the object here?

public class Guarded {
    static class Rectangle {
        private final double w, h;
        Rectangle(double w, double h) {
            if (w <= 0 || h <= 0) throw new IllegalArgumentException("sides must be positive");
            this.w = w; this.h = h;
        }
    }

    public static void main(String[] args) {
        try {
            new Rectangle(-1, 2);
        } catch (IllegalArgumentException e) {
            System.out.println("rejected: " + e.getMessage());
        }
    }
}

$ java Guarded.java
rejected: sides must be positive

3. Override describe() in Square so it prints Square of side 4.0 instead of the default, and check that the loop picks it up without changes.

import java.util.List;

public class OverrideDescribe {
    interface Shape {
        double area();
        default String describe() { return getClass().getSimpleName() + " " + area(); }
    }

    static class Rectangle implements Shape {
        protected final double w, h;
        Rectangle(double w, double h) { this.w = w; this.h = h; }
        public double area() { return w * h; }
    }

    static class Square extends Rectangle {
        Square(double side) { super(side, side); }
        @Override public String describe() { return "Square of side " + w; }
    }

    public static void main(String[] args) {
        for (Shape s : List.of(new Rectangle(2, 3), new Square(4))) System.out.println(s.describe());
    }
}

$ java OverrideDescribe.java
Rectangle 6.0
Square of side 4.0