PHP What is OOP

What Is Object-Oriented Programming?

In simple terms: Object-oriented programming (OOP) organizes code around objects — units that combine data (what something is) with behavior (what it can do). A bank account object knows its balance and knows how to accept deposits and withdrawals; a shopping cart object knows its items and how to calculate its total.

Technically: In OOP, you define classes — blueprints that describe the properties (data) and methods (functions) of a kind of thing — and create objects (instances) from them. PHP has supported OOP since PHP 5 and has steadily added modern features: typed properties, constructor promotion, enums, readonly properties, and property hooks (PHP 8.4).

Procedural vs Object-Oriented

So far, most examples in this tutorial used procedural code: data in variables and arrays, processed by separate functions. That works well for small scripts. As applications grow, OOP helps keep code organized:

A Comparison: Bank Account

Procedural Version

<?php
$account = ['owner' => 'Asha', 'balance' => 1000.0];

function deposit(array $account, float $amount): array
{
    $account['balance'] += $amount;
    return $account;
}

$account = deposit($account, 500);
$account['balance'] = -999999;   // nothing prevents this

echo $account['balance'] . "\n";

Output

-999999

The rules for a valid account (no negative deposits, no overdrafts) live in functions, but any code can bypass them and change the array directly. As a project grows, such changes happen in many places, and nobody can guarantee that the data is valid.

Object-Oriented Version

<?php
class BankAccount
{
    private float $balance = 0.0;

    public function __construct(private string $owner) {}

    public function deposit(float $amount): void
    {
        if ($amount <= 0) {
            throw new InvalidArgumentException('Deposit must be positive.');
        }
        $this->balance += $amount;
    }

    public function withdraw(float $amount): void
    {
        if ($amount > $this->balance) {
            throw new RuntimeException('Insufficient balance.');
        }
        $this->balance -= $amount;
    }

    public function balance(): float
    {
        return $this->balance;
    }
}

$account = new BankAccount('Asha');
$account->deposit(1000);
$account->withdraw(300);

echo "Balance: " . $account->balance() . "\n";

try {
    $account->withdraw(5000);
} catch (RuntimeException $e) {
    echo "Error: " . $e->getMessage() . "\n";
}

try {
    $account->balance = -999999;
} catch (Error $e) {
    echo get_class($e) . ": " . $e->getMessage() . "\n";
}

Output

Balance: 700
Error: Insufficient balance.
Error: Cannot access private property BankAccount::$balance

What Changed

1. The balance is private: only the class's own methods can change it. Direct access from outside is rejected with an Error.
2. All rules live in one place — deposit() and withdraw() — and are applied every time.
3. Code using the class does not need to know how the balance is stored; it only uses the public methods.

This idea — protecting data behind methods that enforce the rules — is called encapsulation, and it is the most important benefit of OOP.

The Core Concepts

The Four Principles of OOP

Polymorphism in a Nutshell

<?php
interface Shape
{
    public function name(): string;
    public function area(): float;
}

class Circle implements Shape
{
    public function __construct(private float $radius) {}

    public function name(): string
    {
        return 'Circle';
    }

    public function area(): float
    {
        return M_PI * $this->radius ** 2;
    }
}

class Rectangle implements Shape
{
    public function __construct(private float $width, private float $height) {}

    public function name(): string
    {
        return 'Rectangle';
    }

    public function area(): float
    {
        return $this->width * $this->height;
    }
}

$shapes = [new Circle(2), new Rectangle(3, 4)];

foreach ($shapes as $shape) {
    echo $shape->name() . ': ' . number_format($shape->area(), 2) . "\n";
}

Output

Circle: 12.57
Rectangle: 12.00

Why This Is Powerful

• The loop does not care which kind of shape it has; it only relies on the Shape interface.
• Adding a new shape (a triangle, for example) requires a new class, but no change to the loop.
• In real applications, the same idea lets you swap a payment provider, a storage system, or a mail service without changing the code that uses it.

Interfaces and polymorphism are covered in PHP Interfaces and Polymorphism.

Benefits of OOP

When Procedural Code Is Fine

OOP is not required for everything. Short scripts, simple command-line tools, and small one-page features are often clearer as a few functions. Use OOP when data has rules that must always be enforced, when the code base grows, or when different implementations of the same behavior are needed.

OOP in Real PHP Applications

In a typical Laravel or Symfony application, almost everything is an object:

Learning OOP concepts is therefore essential for working with modern PHP frameworks and libraries.

Common Misconceptions

"OOP Means Putting Functions Into Classes"

Grouping unrelated static functions in a class (Utils::doEverything()) is still procedural code. OOP is about objects that own their data and enforce their rules.

"Everything Should Use Inheritance"

Deep inheritance hierarchies make code rigid. Modern design prefers composition (objects using other objects) and interfaces; inheritance is used where a true "is-a" relationship exists.

"OOP Is Slower"

The performance difference is negligible for web applications. The maintainability gains far outweigh it.

Best Practices

• Model important concepts of your application as classes with clear responsibilities.
• Keep data private and expose behavior through public methods.
• Depend on interfaces rather than concrete classes where implementations may vary.
• Prefer composition over deep inheritance.
• Use procedural code where it is simpler; use OOP where structure and rules matter.

Official reference: https://www.php.net/manual/en/language.oop5.php