🧰 PHP Object-Oriented Programming: Classes, Objects, Inheritance, Traits Explained

Object-Oriented Programming (OOP) in PHP introduces powerful features that help you build modular, reusable, and maintainable code. PHP OOP allows developers to structure software like real-world entities using classes and objects.

🧠 PHP OOP Introduction

OOP (Object-Oriented Programming) in PHP lets you build applications by organizing code into classes and objects, rather than just procedures and functions.

class Car {
    public $brand = "Toyota";
}

$car = new Car();
echo $car->brand; // Toyota

🧱 PHP Classes and Objects

• Class: Blueprint for an object.
• Object: Instance of a class.

class Person {
    public $name;

    function greet() {
        return "Hello, I'm " . $this->name;
    }
}

$p = new Person();
$p->name = "Alice";
echo $p->greet();

🚪 PHP Constructor and Destructor

• Constructor: Automatically called when an object is created.
• Destructor: Called when there are no more references to the object.

class Animal {
    function __construct() {
        echo "Animal created!";
    }
    
    function __destruct() {
        echo "Animal destroyed!";
    }
}

🔐 PHP Access Modifiers

• public: Accessible everywhere
• protected: Accessible in class and subclasses
• private: Accessible only within the class

class BankAccount {
    private $balance = 1000;

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

🔁 PHP Inheritance

Child classes can inherit properties and methods from a parent class.

class ParentClass {
    protected function sayHello() {
        echo "Hello from Parent!";
    }
}

class ChildClass extends ParentClass {
    public function greet() {
        $this->sayHello();
    }
}

🧳 PHP Encapsulation

Encapsulation hides internal object details and exposes only what’s necessary using methods.

class Box {
    private $item;

    public function setItem($item) {
        $this->item = $item;
    }

    public function getItem() {
        return $this->item;
    }
}

🧱 PHP Final Keyword

The final keyword prevents classes or methods from being extended or overridden.

final class Base {}

class Sub extends Base {} // ❌ Error

🔒 PHP Class Constants

Use const to define constants inside a class.

class App {
    const VERSION = "1.0";
}

echo App::VERSION;

🧰 PHP Abstract Classes

Used to define base templates. Cannot be instantiated.

abstract class Shape {
    abstract public function area();
}

class Circle extends Shape {
    public function area() {
        return 3.14 * 5 * 5;
    }
}

🔌 PHP Interfaces

Interfaces define required methods without implementation.

interface Logger {
    public function log($msg);
}

class FileLogger implements Logger {
    public function log($msg) {
        echo "Logged: $msg";
    }
}

🧬 PHP Traits

Traits allow reusing methods across classes without inheritance.

trait Sharable {
    public function share() {
        return "Shared!";
    }
}

class Post {
    use Sharable;
}

🧿 PHP Static Methods

Static methods can be called without an instance.

class Math {
    public static function square($x) {
        return $x * $x;
    }
}

echo Math::square(4);

💾 PHP Static Properties

Shared across all instances.

class Counter {
    public static $count = 0;

    public function __construct() {
        self::$count++;
    }
}

🗂️ PHP Namespaces

Avoid class name conflicts by organizing code into namespaces.

namespace MyApp\Models;

class User {}

🔄 PHP Object Iteration

Iterate through object properties using foreach.

class Book {
    public $title = "PHP";
    public $author = "John";
}

$book = new Book();
foreach ($book as $key => $value) {
    echo "$key: $value\n";
}

♻️ PHP Overloading

Using __get, __set, __call to define dynamic behavior.

class Demo {
    private $data = [];

    public function __set($name, $value) {
        $this->data[$name] = $value;
    }

    public function __get($name) {
        return $this->data[$name];
    }
}

📋 PHP Cloning Objects

Use clone to duplicate objects.

class Item {
    public $name = "Box";
}

$copy = clone new Item();

🕵️ PHP Anonymous Classes

Classes defined without a name; useful for one-time use.

$logger = new class {
    public function log($msg) {
        echo "Log: $msg";
    }
};

$logger->log("Success");

✅ Summary

PHP’s Object-Oriented Programming enables cleaner, modular, and scalable code. From basic classes to advanced traits and interfaces, mastering OOP is essential for building modern PHP applications.

❓ FAQ

Q1. What is the difference between abstract class and interface?
Abstract classes can include implementation; interfaces only define method signatures.

Q2. When should I use traits in PHP?
Use traits to share common methods between unrelated classes, avoiding multiple inheritance.

Q3. What is encapsulation in PHP?
Encapsulation hides object details using private/protected members and provides access via public methods.