PHP Object-Oriented Programming: Practical Examples and Best Practices

By Robert F1 min readFebruary 10, 2026

Defining a Class and Instantiating an Object

In PHP, a class is defined using the class keyword. A class can contain properties (variables) and methods (functions). Here's a simple example of a class representing a Car:

<?php
class Car {
    public $brand;
    public $model;

    public function __construct($brand, $model) {
        $this->brand = $brand;
        $this->model = $model;
    }

    public function getDetails() {
        return "Car: {$this->brand} {$this->model}";
    }
}

// Instantiating an object
$myCar = new Car("Toyota", "Corolla");
echo $myCar->getDetails(); // Outputs: Car: Toyota Corolla

Best Practice: Use Visibility Modifiers

Always define visibility for properties and methods using public, protected, or private. This helps encapsulate data and prevents unintended modifications.

Inheritance and Method Overriding

Inheritance allows a class to inherit properties and methods from another class. The child class can also override methods from the parent class.

<?php
class Vehicle {
    public function startEngine() {
        return "Engine started.";
    }
}

class SportsCar extends Vehicle {
    public function startEngine() {
        return "Vroom! Sports car engine started.";
    }
}

$car = new SportsCar();
echo $car->startEngine(); // Outputs: Vroom! Sports car engine started.

Best Practice: Use the `parent` Keyword

When overriding a method, you can still call the parent method using parent::method() if needed.

Interfaces and Abstract Classes

Interfaces define a contract that classes must follow. Abstract classes can provide both abstract and concrete methods.

<?php
interface Drivable {
    public function drive();
}

abstract class MotorVehicle {
    abstract public function start();

    public function stop() {
        return "Vehicle stopped.";
    }
}

class Truck extends MotorVehicle implements Drivable {
    public function start() {
        return "Truck engine started.";
    }

    public function drive() {
        return "Truck is moving on the road.";
    }
}

$truck = new Truck();
echo $truck->start();  // Outputs: Truck engine started.
echo $truck->drive();  // Outputs: Truck is moving on the road.
echo $truck->stop();   // Outputs: Vehicle stopped.

Best Practice: Use Interfaces for Behavior Contracts

Interfaces are ideal for defining behavior that multiple classes may share, especially in loosely coupled systems.

Static Properties and Methods

Static members belong to the class itself rather than any instance.

<?php
class Counter {
    public static $count = 0;

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

    public static function getCount() {
        return self::$count;
    }
}

$obj1 = new Counter();
$obj2 = new Counter();
echo Counter::getCount(); // Outputs: 2

Best Practice: Use Static for Utility or Shared Data

Static properties and methods should be used sparingly and only when necessary, such as for utility classes or global counters.

Namespaces and Autoloading

Namespaces help organize code and avoid naming conflicts. PHP 5.3+ supports namespaces natively. Autoloading allows classes to be automatically loaded when needed.

<?php
// File: src/Utils/Logger.php
namespace Utils;

class Logger {
    public function log($message) {
        echo "Log: {$message}\n";
    }
}

// File: index.php
require 'vendor/autoload.php';

use Utils\Logger;

$logger = new Logger();
$logger->log("User logged in.");

Best Practice: Use Composer for Autoloading

Use Composer to manage dependencies and autoloading. It ensures a consistent and manageable structure for your PHP projects.

Summary of OOP Features in PHP

Feature	Description	Syntax Example
Class	Blueprint for objects	`class Car {}`
Object	Instance of a class	`$car = new Car();`
Inheritance	Child class inherits from parent	`class SportsCar extends Car {}`
Interface	Defines method contracts	`interface Drivable {}`
Abstract Class	Can have abstract and concrete methods	`abstract class Vehicle {}`
Static Members	Belong to class, not instance	`public static $count;`
Namespace	Groups classes to avoid conflicts	`namespace Utils;`