OOPs Concepts in PHP: Complete Guide with Examples [2026]

A PHP script with a few functions is easy to manage. The difficulty begins when the application grows to hundreds of files, multiple developers and features that depend on one another. Changing one section can suddenly affect several others. The same logic may appear in different files. Testing becomes harder because responsibilities are mixed together.

Object-Oriented Programming (OOP) provides a way to organise that complexity. Instead of treating an application as one long sequence of instructions, OOP divides it into classes and objects with clearly defined responsibilities. A User object can manage user information. An Order object can calculate totals. A PaymentGateway can define how payments should behave.

PHP provides a complete object model with classes, inheritance, interfaces, abstract classes, visibility, traits, magic methods and several modern OOP features. As of August 2026, PHP 8.5.10 is the current stable PHP release. PHP 8.6 is still in beta and should not yet be treated as the production version.

This guide explains the major OOPs concepts in PHP with practical examples, how the four pillars work together and how modern PHP developers use object-oriented design to build maintainable applications.

Quick Answer: OOPs concepts in PHP are object-oriented programming principles used to organise PHP applications into reusable classes and objects. The four core pillars are encapsulation, abstraction, inheritance and polymorphism, while classes, objects, properties, methods, constructors, interfaces and traits provide the PHP features used to implement them.

• Classes and objects organise data and behaviour.
• Encapsulation controls access to an object’s internal state.
• Inheritance lets child classes reuse parent behaviour.
• Polymorphism allows different objects to follow the same interface in different ways.
• Abstraction exposes essential behaviour while hiding implementation details.
• Interfaces and traits help build flexible, reusable PHP applications.

What Are OOPs Concepts in PHP?

Object-Oriented Programming in PHP is a programming approach in which related data and behaviour are grouped into objects created from classes.

A class describes what an object should contain and what it should be able to do.

For example, an e-commerce application may contain:

class Product
{
    public function __construct(
        public string $name,
        public float $price
    ) {}

    public function displayPrice(): string
    {
        return "₹" . number_format($this->price, 2);
    }
}

Create an object:

$product = new Product("Keyboard", 2499);

echo $product->name;
echo $product->displayPrice();

Here:

• Product is the class.
• $product is an object.
• $name and $price are properties.
• displayPrice() is a method.

Object-oriented PHP becomes especially useful as applications grow because related logic remains grouped instead of being scattered across unrelated functions. This fits naturally with modern software development methodologies that prioritise maintainability, testing and clear separation of responsibilities.

OOPs Concepts in PHP: Quick Comparison

Key OOPs Concepts in PHP

These are the following OOPs concepts in PHP:

1. Classes and Objects

A class is a definition or blueprint.

An object is a particular instance created from that class.

Consider a Car class:

class Car
{
    public function __construct(
        public string $brand,
        public string $colour
    ) {}

    public function drive(): string
    {
        return "{$this->brand} is moving.";
    }
}

Now create two objects:

$car1 = new Car("Toyota", "Black");
$car2 = new Car("Honda", "White");

Both objects follow the same structure, but they hold different values.

echo $car1->brand; // Toyota
echo $car2->brand; // Honda

This is the basic idea behind object-oriented programming: define reusable behaviour once and create multiple objects from it.

2. Properties and Methods

Objects usually contain state and behaviour.

Properties represent the state:

private float $balance;

Methods represent behaviour:

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

Consider:

class Student
{
    public function __construct(
        public string $name,
        private float $marks
    ) {}

    public function getResult(): string
    {
        return $this->marks >= 40 ? "Pass" : "Fail";
    }
}

The object contains information about the student and the logic required to determine the result.

3. Constructors and Destructors

A constructor runs automatically when an object is created.

PHP defines constructors using:

__construct()

For example:

class Customer
{
    public function __construct(
        public string $name,
        public string $email
    ) {}
}

Create an object:

$customer = new Customer(
    "Aarav",
    "[email protected]"
);

Modern PHP supports constructor property promotion, allowing properties to be declared directly inside constructor parameters.

A destructor uses:

__destruct()

It runs when an object has no remaining references or during application shutdown.

class Connection
{
    public function __construct()
    {
        echo "Connection opened.";
    }

    public function __destruct()
    {
        echo "Connection closed.";
    }
}

PHP’s manual notes that parent constructors and destructors are not automatically called when a child defines its own version. The child must explicitly call parent::__construct() or parent::__destruct() when required.

In real applications, destructors should not be treated as the primary mechanism for important business operations because their exact execution timing may depend on object lifetime and shutdown behaviour.

4. Inheritance

Inheritance allows a child class to reuse public and protected behaviour from a parent class.

PHP uses the extends keyword.

class Vehicle
{
    public function start(): string
    {
        return "Vehicle started.";
    }
}

class Car extends Vehicle
{
    public function openBoot(): string
    {
        return "Boot opened.";
    }
}

Now:

$car = new Car();

echo $car->start();
echo $car->openBoot();

Car receives the inherited start() method while adding its own functionality.

PHP supports single class inheritance. A class extends one parent class, although interfaces and traits provide additional ways to compose behaviour.

The PHP manual confirms that child classes inherit public and protected methods, properties and constants unless the child overrides them. Private parent members are not directly accessible to the child.

Inheritance works well when there is a genuine is-a relationship.

For example:

Car is a Vehicle.

It is less appropriate when classes only happen to share one convenient method.

5. Polymorphism

Polymorphism means that different object types can be used through the same contract while providing different behaviour.

Interfaces provide a clean PHP example.

interface PaymentGateway
{
    public function pay(float $amount): string;
}

Different classes implement it:

class CardPayment implements PaymentGateway
{
    public function pay(float $amount): string
    {
        return "Paid ₹{$amount} by card.";
    }
}

class UpiPayment implements PaymentGateway
{
    public function pay(float $amount): string
    {
        return "Paid ₹{$amount} through UPI.";
    }
}

Now one function can work with either implementation:

function processPayment(
    PaymentGateway $gateway,
    float $amount
): void {
    echo $gateway->pay($amount);
}

Call it with different objects:

processPayment(new CardPayment(), 1500);
processPayment(new UpiPayment(), 1500);

The calling function depends on the PaymentGateway contract rather than one concrete payment class. This makes systems easier to extend. Adding another payment type does not require rewriting the function. Developers familiar with Java will recognise the same underlying OOP principle, although PHP’s syntax and object model differ.

Level up your programming skills from beginner to advanced with our free C++ handbook.

6. Abstraction

Abstraction defines what an object must do while hiding unnecessary implementation details.

PHP supports abstraction through:

• Abstract classes
• Abstract methods
• Interfaces

Consider:

abstract class InsurancePolicy
{
    abstract public function calculatePremium(): float;
}

Concrete classes decide how the calculation works:

class HealthInsurance extends InsurancePolicy
{
    public function calculatePremium(): float
    {
        return 7500;
    }
}

class CarInsurance extends InsurancePolicy
{
    public function calculatePremium(): float
    {
        return 5200;
    }
}

The calling code only needs to know that every policy can calculate a premium.

It does not need to know the internal formula.

That is abstraction.

The objective is not simply “hiding data.” Encapsulation controls access to state, while abstraction hides unnecessary implementation complexity behind a useful contract.

7. Encapsulation

Encapsulation means keeping an object’s internal state under the control of the class.

Consider a bank account.

Allowing outside code to modify the balance directly would be risky:

$account->balance = -500000;

Instead, make the property private:

class BankAccount
{
    private float $balance = 0;

    public function deposit(float $amount): void
    {
        if ($amount <= 0) {
            throw new InvalidArgumentException(
                "Deposit must be positive."
            );
        }

        $this->balance += $amount;
    }

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

Now the internal value can be changed only through approved behaviour.

$account = new BankAccount();

$account->deposit(5000);

echo $account->getBalance();

PHP provides three primary visibility levels:

PHP’s official documentation confirms that protected properties cannot be accessed freely from outside the class hierarchy.

Encapsulation is therefore not simply about “security.” Its main purpose is protecting an object’s valid state and controlling how other parts of the application interact with it.

It can also contribute to stronger data consistency and integrity when domain rules are enforced through methods rather than unrestricted property changes.

Build stronger full-stack development skills to understand OOPs concepts in PHP and write cleaner backend code with HCL GUVI’s Full Stack Development Course. Learn HTML, CSS, JavaScript, PHP concepts, backend development, APIs, databases, and real-world web projects through structured training designed for aspiring full-stack developers in 2026.

Real-World Code Example of OOPs Concepts in PHP

This PHP code is designed to create food orders, enabling users to add multiple food items along with their prices. After the food items are added, this program calculates the total amount, including the delivery fee, and displays the final amount when the order is completed.

<?php

// Abstraction: Abstract class for Orders

abstract class Order {

    protected $items = []; // Encapsulation

    public function addItem($item, $price) {

        $this->items[$item] = $price;

    }
    abstract public function calculateTotal(); // Must be implemented by child

}

// Inheritance: OnlineOrder inherits from Order

class OnlineOrder extends Order {

    private $deliveryFee;

    public function __construct($fee) { // Constructor

        $this->deliveryFee = $fee;

    }

    public function calculateTotal() { // Polymorphism

        $total = array_sum($this->items) + $this->deliveryFee;

        return $total;
    }

    public function __destruct() { // Destructor

        echo "Order completed. Total: $" . $this->calculateTotal() . "\n";

    }

}

// Classes & Objects: Using the OnlineOrder

$order = new OnlineOrder(5); // $5 delivery fee

$order->addItem("Burger", 10);

$order->addItem("Fries", 3);

$order->addItem("Coke", 2);

echo "Total without delivery: $" . array_sum($order->items) . "\n";

?>

Explanation:

• In this food ordering program, the Order class is basically acting as a template and is responsible for instructing every order that it must possess a way to calculate the total, which is known as abstraction.

• As you can see, there is a list of food items, $items, which is protected. To change it, you have to carefully implement the addItem() method, which is known as encapsulation.   

• Here, the OnlineOrder class extends the Order class by inheriting its properties, and $order is the actual instance of that class, highlighting the respective classes and objects.     

• Now, when anyone creates a new order, the __construct() function sets the delivery fee, and when the order is completed, the __destruct() method automatically returns the total amount as the output.

• Here, as the inheritance is also involved, the OnlineOrder class overrides the calculateTotal() method from the Order class to ensure it behaves differently according to the online orders, which demonstrates the polymorphism process.

Does PHP Support Method Overloading?

This question causes considerable confusion. PHP uses the term overloading, but it means something different from traditional Java or C++ method overloading. In languages such as Java, multiple methods can share the same name while accepting different parameter signatures.

PHP does not provide that form of method overloading in the same way. Instead, PHP documentation uses overloading to describe dynamically handling inaccessible or undefined properties and methods through magic methods such as:

__get()
__set()
__call()
__callStatic()

For example:

class DynamicService
{
    public function __call(
        string $name,
        array $arguments
    ): void {
        echo "Attempted to call {$name}";
    }
}

$service = new DynamicService();

$service->sendNotification();

__call() handles the undefined method.

PHP’s own manual explicitly notes that its definition of overloading differs from the traditional OOP meaning used by many other languages.

Interfaces in PHP

An interface defines a contract that implementing classes must follow.

interface Exportable
{
    public function export(): string;
}

Implement it:

class PdfReport implements Exportable
{
    public function export(): string
    {
        return "PDF generated";
    }
}

Interfaces are useful when different classes need to provide the same capability.

For example:

PaymentGateway
├── StripeGateway
├── RazorpayGateway
└── PayPalGateway

The implementation can change while the application continues depending on the same interface.

PHP classes can implement multiple interfaces.

PHP 8.4 also expanded interfaces by allowing them to declare property requirements.

Traits in PHP

PHP supports single class inheritance, which means one class cannot extend several parent classes.

Traits solve a different problem: sharing reusable behaviour across otherwise unrelated classes.

trait Logger
{
    public function log(string $message): void
    {
        echo "[LOG] {$message}";
    }
}

Use it inside multiple classes:

class OrderService
{
    use Logger;
}

class PaymentService
{
    use Logger;
}

Both classes receive the log() method without sharing the same parent.

PHP’s documentation describes traits as a mechanism for horizontal code reuse in a single-inheritance language.

Traits are particularly useful for small pieces of reusable behaviour.

They should not become a replacement for good class design.

Abstract Class vs Interface vs Trait in PHP

These three features are often confused.

A simple rule is:

Abstract class: “These classes share a base.”

Interface: “These classes promise the same capability.”

Trait: “These classes need the same reusable behaviour.”

PHP OOP vs Procedural Programming

PHP supports both procedural and object-oriented programming. Neither approach is automatically correct for every script.

A short utility script does not necessarily need twenty classes. A large billing, e-commerce or CRM application usually benefits much more from deliberate object-oriented design. The goal is not to use OOP everywhere. It is to use it where objects and responsibilities make the system easier to understand.

Real-World Example of OOPs Concepts in PHP

Consider an online food-ordering system.

We want:

• Different order types
• Shared item-management logic
• Different total calculations
• Protected internal data
• One common interface for totals

PHP Code

<?php

interface TotalCalculator
{
    public function calculateTotal(): float;
}

abstract class Order implements TotalCalculator
{
    protected array $items = [];

    public function addItem(
        string $name,
        float $price
    ): void {
        if ($price < 0) {
            throw new InvalidArgumentException(
                "Price cannot be negative."
            );
        }

        $this->items[$name] = $price;
    }

    public function getSubtotal(): float
    {
        return array_sum($this->items);
    }

    abstract public function calculateTotal(): float;
}

final class OnlineOrder extends Order
{
    public function __construct(
        private float $deliveryFee
    ) {}

    public function calculateTotal(): float
    {
        return $this->getSubtotal()
            + $this->deliveryFee;
    }
}

final class PickupOrder extends Order
{
    public function calculateTotal(): float
    {
        return $this->getSubtotal();
    }
}

function displayTotal(
    TotalCalculator $order
): void {
    echo "Total: ₹"
        . number_format(
            $order->calculateTotal(),
            2
        )
        . PHP_EOL;
}

$onlineOrder = new OnlineOrder(50);

$onlineOrder->addItem("Burger", 180);
$onlineOrder->addItem("Fries", 90);

$pickupOrder = new PickupOrder();

$pickupOrder->addItem("Burger", 180);
$pickupOrder->addItem("Fries", 90);

displayTotal($onlineOrder);
displayTotal($pickupOrder);

How Each OOP Concept Appears

1. Class and object: OnlineOrder is a class, while $onlineOrder is an object.
2. Encapsulation: $items is protected, so arbitrary external code cannot directly overwrite the collection.
3. Abstraction: Order declares that every order must implement calculateTotal().
4. Inheritance: OnlineOrder and PickupOrder extend Order.
5. Polymorphism: displayTotal() accepts the TotalCalculator interface and works with both order types.
6. Constructor: OnlineOrder uses __construct() to initialise its delivery fee.
7. Interface: TotalCalculator establishes a common contract.

This example also avoids a problem in the earlier implementation: outside code never attempts to access the protected $items property directly.

Modern OOP Features in PHP 8.5

1. Typed Properties

Properties can declare their expected type:

class User
{
    public string $name;
    public int $age;
}

This makes object contracts clearer and catches invalid assignments earlier.

2. Constructor Property Promotion

Instead of declaring a property and then assigning the constructor parameter separately:

class Product
{
    public function __construct(
        public string $name,
        public float $price
    ) {}
}

The constructor creates and initialises both properties.

3. Readonly Properties and Classes

A readonly property can be initialised and then protected against reassignment.

class UserId
{
    public function __construct(
        public readonly int $value
    ) {}
}

PHP also supports readonly classes. PHP’s documentation notes that readonly classes automatically apply readonly behaviour to their declared properties.

4. Property Hooks

PHP 8.4 introduced property hooks, allowing developers to customise how properties are read or written without relying entirely on traditional getter/setter boilerplate.

For example:

class User
{
    public string $name {
        set => trim($value);
    }
}

The feature allows property behaviour to remain close to the property itself.

5. Asymmetric Visibility

Modern PHP can apply different visibility rules to reading and writing a property. For example, an object may expose a property publicly for reading while restricting who can modify it. PHP 8.5 further extends set visibility support to static properties. These additions show why learning OOP in PHP should not stop at the four classic pillars.

When Should You Use OOP in PHP?

OOP is particularly useful when an application contains entities with clear responsibilities. Good examples include:

• Users
• Orders
• Products
• Payments
• Notifications
• Reports
• Database repositories
• API clients

OOP also works well when:

• Several implementations follow the same contract.
• Business rules need to be protected inside classes.
• The application will grow over time.
• Automated testing is important.
• Multiple developers work on the project.
• Components need to be replaced without rewriting unrelated code.

However, a very small PHP script does not automatically become better because everything is wrapped in classes. Choose OOP when the structure reduces complexity rather than adding unnecessary abstraction.

Best Practices for Writing Clean OOPs Code in PHP

Best Practices for Writing Clean OOP Code in PHP

1. Give Classes One Clear Responsibility

A class called InvoiceCalculator should calculate invoices.

It should not also send emails, create database tables and resize images.

2. Prefer Encapsulation Over Public Mutable State

Avoid exposing properties simply because it is convenient.

Allow objects to protect their valid state.

3. Depend on Interfaces Where Flexibility Matters

Instead of forcing an application to depend directly on one payment service, depend on a PaymentGateway interface.

This makes implementations easier to replace and test.

4. Use Inheritance Carefully

Inheritance creates a strong relationship between classes.

If two classes merely need the same helper behaviour, composition or a trait may be more appropriate.

5. Use Type Declarations

Types make method contracts easier to understand.

public function calculateTax(
    float $amount
): float

is clearer than a method that accepts an unspecified value.

6. Avoid God Classes

A class containing dozens of unrelated responsibilities becomes difficult to test and maintain.

Split responsibilities into smaller components.

7. Use Dependency Injection

Instead of creating dependencies deep inside a class, pass them in.

class CheckoutService
{
    public function __construct(
        private PaymentGateway $gateway
    ) {}
}

The service can then work with any valid gateway implementation.

8. Follow Consistent Naming

Classes normally describe things:

Order
Customer
PaymentGateway
InvoiceRepository

Methods normally describe actions:

calculateTotal()
save()
send()
validate()

Clear names reduce the amount of explanation code requires.

Learning these principles is useful beyond PHP. They are fundamental skills for anyone planning to become a software developer.

Common OOP Mistakes PHP Beginners Make

1. Confusing Abstraction With Encapsulation

Encapsulation controls access to an object’s internal state. Abstraction defines a simpler public contract while hiding unnecessary implementation details. They often work together, but they are not the same concept.

2. Making Every Property Public

Public properties are easy to use, but they can allow arbitrary state changes. Consider whether the object should control modifications.

3. Using Inheritance Only to Reuse Code

Inheritance should model a meaningful relationship. Use interfaces, composition or traits when inheritance would create an artificial hierarchy.

4. Creating Getters and Setters for Everything

Encapsulation does not mean automatically creating a getter and setter for every private property. Expose behaviour the application actually needs.

5. Putting Business Logic in Destructors

Destructors are useful for limited cleanup scenarios. Critical actions such as saving an order or completing a payment should happen explicitly rather than depending on object destruction.

6. Ignoring Interfaces

Classes that directly depend on concrete implementations become harder to replace and test. Interfaces can establish stable boundaries between components.

Why Are OOPs Concepts Important for PHP Developers?

Modern PHP applications frequently use frameworks and architectures built heavily around objects.

Understanding OOP makes concepts such as these easier to learn:

• Dependency injection
• MVC architecture
• Repositories
• Services
• Controllers
• Middleware
• Design patterns
• Automated testing
• Framework containers

OOP knowledge is also common in technical interviews because it tests whether a developer can organise code, not simply remember syntax. A candidate who understands classes but cannot explain why encapsulation or polymorphism matters will usually struggle with larger software-design questions.

If you want to strengthen broader programming fundamentals, you can also compare how OOP appears in languages such as Java and explore HCL GUVI’s free C++ handbook.

Conclusion

OOP in PHP is not simply about putting functions inside classes. Its real purpose is organising software so responsibilities remain clear as an application grows.

Classes and objects provide the foundation. Encapsulation protects state. Inheritance shares appropriate base behaviour. Abstraction creates cleaner contracts. Polymorphism allows multiple implementations to work through those contracts. Interfaces and traits provide additional flexibility when class inheritance alone is not the right solution. For beginners, the best way to understand these concepts is to build small systems rather than memorise definitions. Create an order system, banking application, product catalogue or payment module and decide where each responsibility belongs.

Once you understand why objects are designed the way they are, PHP frameworks, design patterns and larger backend applications become much easier to work with.

FAQs