Module 08 — Object-Oriented Programming

1. What Is Object-Oriented Programming?

Up through Module 7 you have been writing procedural code: a list of instructions that runs top-to-bottom, broken up by methods. That works fine for small programs. Once a project grows, though, procedural code gets messy fast. Variables get passed everywhere, methods have to know about all the data, and adding a new feature often breaks existing ones.

Object-Oriented Programming (OOP) takes a different angle. Instead of writing a sequence of steps, you model your program as a collection of objects that each know their own data and what they can do with it.

1.1 Procedural vs. Object-Oriented

1.2 Objects Have State and Behavior

Think about a bank account. It has data: the owner’s name, the balance. It also has things it can do: accept a deposit, process a withdrawal, report the balance. In OOP those two ideas have names:

• State — the data an object holds (also called fields or instance variables)
• Behavior — what the object can do (its methods)

A BankAccount object knows its own balance and knows how to deposit and withdraw. A Student object knows its own name and GPA. That pairing — state plus behavior — is the core idea of OOP.

2. Classes and Objects

The words class and object get used a lot. Here are the precise definitions:

• A class is a blueprint or template. It describes what an object looks like and what it can do. No actual data yet — just the design.
• An object is an instance of a class. It is the real thing created from that blueprint, with its own actual data values.

2.1 Your First Class

Here is a minimal Dog class with two fields and one method:

public class Dog {
    String name;   // field: the dog's name
    int age;       // field: the dog's age

    void bark() {
        System.out.println(name + " says: Woof!");
    }
}

And here is a separate Main class that creates two Dog objects from that blueprint:

public class Main {
    public static void main(String[] args) {
        Dog d1 = new Dog();   // create first Dog object
        d1.name = "Rex";
        d1.age  = 3;

        Dog d2 = new Dog();   // create second Dog object
        d2.name = "Bella";
        d2.age  = 5;

        d1.bark();
        d2.bark();
    }
}

Both objects share the same bark() method defined in the class, but each has its own name and age. That is the blueprint-versus-instance relationship in action.

3. Defining a Class

A well-written Java class has three sections in this order:

1. Fields — the data the object holds
2. Constructor(s) — special methods that set up a new object
3. Methods — what the object can do

3.1 Access Modifiers: public and private

Java lets you control who can see each part of a class. The two you will use most:

3.2 Fields Should Be private

The rule you will follow from now on: fields are always private. This prevents outside code from directly reading or changing an object’s data without going through methods you control. That is the whole point of encapsulation (more in Section 8).

public class Person {
    private String name;   // private -- only accessible inside this class
    private int age;

    // constructors and methods go here
}

4. Constructors

A constructor is a special method that runs automatically when you create a new object with new. Its job is to initialize the object — give its fields starting values.

Constructor rules:

• Same name as the class (exact capitalization matters)
• No return type — not even void
• Called exactly once, at the moment the object is created

4.1 Default Constructor

If you write no constructor at all, Java quietly provides a default constructor with no parameters. It sets every field to its zero/null default: 0 for numbers, null for objects, false for booleans. That is what happened in the Dog example above.

4.2 Custom Constructor with Parameters

public class Person {
    private String name;
    private int age;

    // This constructor runs when "new Person(...)" is called
    public Person(String name, int age) {
        this.name = name;   // assign the parameter to the field
        this.age  = age;
    }
}

4.3 The this Keyword

Notice this.name = name. There is a naming conflict: the constructor parameter is called name, and the field is also called name. Java needs a way to tell them apart.

this refers to the current object. So this.name means “the name field that belongs to this object.” The plain name on the right side is the constructor parameter.

4.4 Overloaded Constructors

You can have more than one constructor as long as they have different parameter lists. This is constructor overloading — the same concept as method overloading from Module 7.

public class Person {
    private String name;
    private int age;

    // Constructor 1: name and age provided
    public Person(String name, int age) {
        this.name = name;
        this.age  = age;
    }

    // Constructor 2: only name provided, default age to 0
    public Person(String name) {
        this.name = name;
        this.age  = 0;
    }
}

// Usage:
Person p1 = new Person("Alice", 30);   // calls Constructor 1
Person p2 = new Person("Bob");         // calls Constructor 2

5. Creating and Using Objects

You create an object with the new keyword. This does three things:

1. Allocates memory for the new object
2. Calls the matching constructor to initialize it
3. Returns a reference to the object, which you store in a variable

5.1 The new Keyword

Person p1 = new Person("Alice", 30);
Person p2 = new Person("Bob",   22);

// p1 and p2 are completely independent objects
// Changing p1 does not affect p2

5.2 Dot Notation

Once you have an object, you call its methods using a dot:

objectVariable.methodName(arguments);

Full example with a greet() method:

public class Person {
    private String name;
    private int age;

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

    public void greet() {
        System.out.println("Hi, I'm " + name + " and I'm " + age + " years old.");
    }
}

// In Main:
Person p1 = new Person("Alice", 30);
Person p2 = new Person("Bob",   22);
p1.greet();
p2.greet();

5.3 Multiple Objects from One Class

Person alice = new Person("Alice", 30);
Person bob   = new Person("Bob",   22);
Person carol = new Person("Carol", 45);

alice.greet();
bob.greet();
carol.greet();

Each object has its own independent copy of the fields. They do not share data — only the method definitions are shared across all instances.

6. Getters and Setters

Fields are private. So how does outside code read or change them? Through methods you write specifically for that purpose:

• A getter (accessor method) returns the value of a field. Convention: name it getFieldName().
• A setter (mutator method) changes the value of a field. Convention: name it setFieldName().

6.1 Why Not Just Use Public Fields?

If a field is public, anyone can set it to anything — including nonsense values like a negative age or an empty name. A setter gives you a place to validate the incoming value before you accept it.

public class Person {
    private String name;
    private int age;

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

    // --- Getters ---
    public String getName() { return name; }
    public int    getAge()  { return age;  }

    // --- Setters with validation ---
    public void setName(String name) {
        if (name != null && !name.isEmpty()) {
            this.name = name;
        }
    }

    public void setAge(int age) {
        if (age >= 0) {
            this.age = age;
        }
        // if negative, the old value is kept -- no error thrown yet
    }
}

// In Main:
Person p = new Person("Alice", 30);
System.out.println(p.getName());    // Alice
p.setAge(31);
System.out.println(p.getAge());     // 31
p.setAge(-5);                       // rejected by setter
System.out.println(p.getAge());     // still 31

7. The toString() Method

Every Java class automatically inherits a method called toString(). By default it returns something like Person@3764951d — the class name plus a memory address. Not useful for debugging.

You can override toString() to return something meaningful instead.

7.1 Overriding toString()

public class Person {
    private String name;
    private int age;

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

    public String getName() { return name; }
    public int    getAge()  { return age;  }

    @Override
    public String toString() {
        return "Person[name=" + name + ", age=" + age + "]";
    }
}

// In Main:
Person p = new Person("Alice", 30);
System.out.println(p);       // Java calls toString() automatically

The @Override annotation tells Java (and other programmers) that you are intentionally replacing the inherited version. The compiler uses it to catch typos in the method signature. Always include it.

7.2 How println Uses toString()

Whenever you pass an object to System.out.println(), Java automatically calls that object’s toString() and prints the result. The same thing happens when you concatenate an object into a String:

Person p = new Person("Alice", 30);
String msg = "Employee: " + p;   // toString() called automatically here
System.out.println(msg);

8. Encapsulation

Encapsulation is the principle of bundling data and behavior together in one class, and restricting direct access to the data from outside. The recipe:

• Fields: private
• Methods intended for outside use: public

That combination hides the internals and forces all interaction through a controlled interface you design.

8.1 Benefits of Encapsulation

8.2 A Broken Example (No Encapsulation)

// BAD -- public fields, no protection
public class BankAccount {
    public double balance;   // anyone can set this directly
}

// In Main:
BankAccount acct = new BankAccount();
acct.balance = -50000;   // no one stopped us -- this is a bug waiting to happen

8.3 Fixed with Encapsulation

// GOOD -- private field, controlled access
public class BankAccount {
    private double balance = 0;

    public double getBalance() {
        return balance;
    }

    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
}

// In Main:
BankAccount acct = new BankAccount();
acct.deposit(500);
System.out.println(acct.getBalance());   // 500.0
// acct.balance = -50000;  -- COMPILER ERROR: balance is private

9. UML Class Diagrams

UML (Unified Modeling Language) is a standard way to draw pictures of classes before or after you code them. A class diagram is the most common type — you will see it in textbooks, job interviews, and design meetings.

A class diagram has three sections stacked vertically:

1. Class name — at the top, usually bold
2. Fields — in the middle, with their types
3. Methods — at the bottom, with return types and parameters

Visibility symbols:

• + means public
• − means private

9.1 UML for the Person Class

Reading left to right in the methods section: visibility — method name — parameters — return type. Simple once you know the notation.

9.2 Reading a UML Diagram

Given this diagram for a Car class:

You can immediately tell: four private fields, a constructor that takes three arguments, six public methods. You could write the Java skeleton for this class without reading another word of documentation.

10. Complete Example — The BankAccount Class

Let’s build a real, working BankAccount class from scratch, applying everything from Sections 1 through 9. We will follow this UML diagram:

10.1 The BankAccount Class

public class BankAccount {

    // Fields -- always private
    private String owner;
    private double balance;

    // Constructor
    public BankAccount(String owner, double initialBalance) {
        this.owner = owner;
        if (initialBalance >= 0) {
            this.balance = initialBalance;
        } else {
            this.balance = 0;   // reject negative starting balance
        }
    }

    // Getters
    public String getOwner()   { return owner;   }
    public double getBalance() { return balance; }

    // deposit -- add money to the account
    public void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            System.out.println("Deposited $" + amount
                               + " | New balance: $" + balance);
        } else {
            System.out.println("Deposit rejected: amount must be positive.");
        }
    }

    // withdraw -- remove money if funds are available
    // returns true if successful, false if not enough funds
    public boolean withdraw(double amount) {
        if (amount <= 0) {
            System.out.println("Withdrawal rejected: amount must be positive.");
            return false;
        }
        if (amount > balance) {
            System.out.println("Withdrawal rejected: insufficient funds.");
            return false;
        }
        balance -= amount;
        System.out.println("Withdrew $" + amount
                           + " | New balance: $" + balance);
        return true;
    }

    // toString -- readable summary of the account
    @Override
    public String toString() {
        return "BankAccount[owner=" + owner + ", balance=$" + balance + "]";
    }
}

10.2 Using BankAccount from Main

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

        // Create two accounts
        BankAccount alice = new BankAccount("Alice", 1000.00);
        BankAccount bob   = new BankAccount("Bob",    250.00);

        // Print using toString()
        System.out.println(alice);
        System.out.println(bob);
        System.out.println();

        // Alice deposits and withdraws
        alice.deposit(500.00);
        alice.withdraw(200.00);
        alice.withdraw(2000.00);   // should be rejected
        System.out.println();

        // Bob tries a bad deposit
        bob.deposit(-100.00);      // should be rejected
        bob.deposit(75.00);
        System.out.println();

        // Final state
        System.out.println("Final balances:");
        System.out.println(alice.getOwner() + ": $" + alice.getBalance());
        System.out.println(bob.getOwner()   + ": $" + bob.getBalance());
    }
}

10.3 What This Demonstrates

• Private fields — owner and balance cannot be changed directly from Main
• Constructor with validation — negative starting balances are silently corrected to 0
• Getter methods — getOwner() and getBalance() give read access
• Validated behavior — deposit() rejects negative amounts; withdraw() checks for sufficient funds
• Return values from methods — withdraw() returns boolean so callers know if it succeeded
• toString() — System.out.println(alice) gives useful output automatically
• Two independent objects — Alice’s account and Bob’s account do not affect each other

📋 Summary

Vocabulary

📋 Module 08 Quiz

Choose the best answer for each question. Each question has exactly one correct answer.

public class Counter {
    private int count = 5;

    @Override
    public String toString() {
        return "Count: " + count;
    }
}

Counter c = new Counter();

public Product(String name, double price) {
    this.name  = name;
    this.price = price;
}

public class Box {
    private int value;

    public Box(int value) { this.value = value; }

    public void setValue(int v) {
        if (v > 0) this.value = v;
    }

    public int getValue() { return value; }
}

Box b = new Box(10);
b.setValue(-5);
b.setValue(20);
System.out.println(b.getValue());

✅ Answer Key