11. Introduction to Object-Oriented Programming

[!NOTE] Until now, you've written procedural code—a simple list of instructions executed from top to bottom. Java was built from the ground up for a different paradigm: Object-Oriented Programming (OOP).

What is OOP?

OOP is a methodology that attempts to map software directly to real-world entities.

Instead of treating your application as a chaotic mix of variables (userName, userAge) and standalone functions (login(), logout()), OOP bundles related data and behaviors together into structured Objects.

The Blueprint vs The Reality

Consider a Car factory. You don't just randomly weld metal together. You start with an engineering Blueprint. The blueprint defines what a car should have (color, engine type, speed) and what it should do (drive, brake, honk).

In Java:

The Class is the blueprint.
The Object (or Instance) is the actual car that rolls off the assembly line.

// 1. We create the Blueprint (Class)
public class Car {
    // Attributes (State)
    String color;
    int currentSpeed;

    // Methods (Behavior)
    void drive() {
        currentSpeed = 60;
        System.out.println("The car is driving!");
    }
}

Once the blueprint exists, we can use it to stamp out thousands of unique Objects in the main method execution.

public class Main {
    public static void main(String[] args) {
        // 2. We build the physical car (Object) from the blueprint!
        Car myVolvo = new Car();
        myVolvo.color = "Red";
        
        Car myBMW = new Car();
        myBMW.color = "Black";
        
        // 3. We tell the object to perform its behavioral action
        myVolvo.drive(); 
    }
}

Why Use OOP?

Faster Execution and Maintenance: Finding bugs is easier when all logic related to a "User" is firmly locked inside a single User.java file, rather than scattered across 50 random functions.
DRY (Don't Repeat Yourself): You can build a Vehicle class and have Car, Truck, and Motorcycle automatically inherit all of its logic without rewriting code.
Security: You can hide sensitive data (like userPassword) inside an object and strictly control how outside code interacts with it.

How to Think in Objects

The easiest way to design an object is to ask two questions: what data does it own, and what actions should it perform with that data? A Student may own a name and marks. It may calculate its average. A BankAccount may own a balance. It may deposit and withdraw money.

Object Design Example

class Student {
    String name;
    int marks;

    boolean hasPassed() {
        return marks >= 40;
    }
}

The method hasPassed() belongs inside Student because it uses student data and answers a question about that student. This is the heart of OOP: keep related data and behavior together.

Class vs Object vs Reference

Term	Meaning	Example
Class	Blueprint	`Student`
Object	Actual instance in memory	`new Student()`
Reference	Variable pointing to an object	`Student s`

Common Mistakes

Creating classes that only store data and never provide useful behavior.
Putting unrelated logic inside one large class named Main or Utility.
Confusing the class blueprint with the object created from it.
Making every field public before learning encapsulation properly.

Mini Practice

Design a Book class with title, author, pages, and a method called isLongBook(). Then create two book objects and print whether each one is long.

Practice Lab: Model a Real Object

Turn a real-world idea into a class with state and behavior.

Create a Book class with title, author, page count, and current page.
Add a method readPages(int pages).
Add a method isFinished().
Create two book objects and update them separately.

Goal: Understand how a class bundles related data and actions.

Revision Checkpoint

Class: Blueprint that defines fields and methods.
Object: Real instance created from a class using new.
State: Data owned by an object.
Behavior: Methods an object can perform.
OOP habit: Keep related data and behavior together.

Before the quiz: Pick one real object and list its fields and methods.