Object-Oriented Programming (OOP)

Introduction

So far, every lesson in this course has used a procedural style — variables, functions, and control structures operating on data that is passed around explicitly. This works well for smaller scripts, but as applications grow, it can become difficult to keep track of which functions are allowed to touch which data.

Object-Oriented Programming (OOP) is a different way of organizing code: instead of separating data and the functions that operate on it, you bundle them together into self-contained units called objects. This lesson is a conceptual overview — you will not write much class syntax yet. The goal is to understand what OOP is and why it exists before diving into the mechanics in the next lesson.

What Is OOP?

Object-oriented programming is a way of modeling your code around "objects" — self-contained units that bundle together data (called properties) and the behavior that acts on that data (called methods). Instead of a Car being represented as several loose variables and functions scattered around your script, a Car becomes a single object that knows its own speed, color, and how to accelerate.

Why OOP Matters

In a small script, procedural code is perfectly fine — a handful of functions operating on a few variables is easy to follow. But as an application grows to dozens or hundreds of files, keeping track of which functions modify which data, and in what order, becomes increasingly difficult.

OOP addresses this by grouping related data and behavior into objects. If you are working with a "User", all the logic for validating a user, checking their permissions, or updating their profile can live inside a single User class, rather than being spread across many unrelated functions that all take a $user array as an argument.

Procedural vs Object-Oriented Style

To see the difference concretely, here is the same small idea — a bank account with a balance that can be deposited into — written both ways.

<?php
// Procedural style: data and behavior are separate
$account = ["balance" => 100];

function deposit(array &$account, float $amount): void {
    $account["balance"] += $amount;
}

deposit($account, 50);
echo $account["balance"];

150

<?php
// Object-oriented style: data and behavior live together
class Account {
    public float $balance = 100;

    public function deposit(float $amount): void {
        $this->balance += $amount;
    }
}

$account = new Account();
$account->deposit(50);
echo $account->balance;

150

Both produce the same result, but notice how the object-oriented version keeps balance and deposit() bundled together inside Account, instead of relying on a loose array and a separate function that has to be passed that array every time.

The Four Pillars of OOP

Object-oriented programming is usually described in terms of four core ideas, often called the "four pillars." Each one gets its own dedicated lesson soon, but here is a quick preview of what each means.

What's Coming Next

The very next lesson dives into the actual syntax for defining classes, creating objects, and working with properties and methods. From there, the course builds up through constructors, access modifiers, inheritance, polymorphism, and abstraction, giving each pillar the space it deserves.

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Object-oriented programming reorganizes code around objects that bundle data and behavior together, making larger applications easier to reason about and extend. The four pillars — encapsulation, inheritance, polymorphism, and abstraction — describe the core ideas that make this style powerful, and each will get its own dedicated lesson soon.

Next, you will roll up your sleeves and learn the actual syntax for defining classes and creating objects in PHP.