Learn OOP in PHP without the noise

Without the noise, using simple, real-world examples, I'll teach you Object-Oriented Programming (OOP) in PHP in this post. Let's break this down step by step.
Classes and Objects
Think of a class as a blueprint, and objects as things created from that blueprint.
// This is our blueprint (class)
class Car {
// Properties (characteristics)
public $brand;
public $color;
// Method (action)
public function startEngine() {
return "Vroom! The $this->color $this->brand is starting.";
}
}
// Creating objects from the blueprint
$myCar = new Car();
$myCar->brand = "Toyota";
$myCar->color = "Red";
echo $myCar->startEngine(); // Outputs: Vroom! The Red Toyota is starting.
Constructor
This is like a setup method that runs when you create a new object:
class Dog {
public $name;
public $breed;
// Constructor
public function __construct($name, $breed) {
$this->name = $name;
$this->breed = $breed;
}
}
$myDog = new Dog("Buddy", "Golden Retriever");
Encapsulation
This means protecting your data by making it private and providing public methods to access it:
class BankAccount {
private $balance = 0; // Can't access directly from outside
public function deposit($amount) {
if ($amount > 0) {
$this->balance += $amount;
return "Deposited $" . $amount;
}
}
public function getBalance() {
return $this->balance;
}
}
Inheritance
This allows a class to inherit properties and methods from another class:
class Animal {
public function eat() {
return "I'm eating!";
}
}
class Cat extends Animal {
public function meow() {
return "Meow!";
}
}
$myCat = new Cat();
echo $myCat->eat(); // From parent class: "I'm eating!"
echo $myCat->meow(); // From child class: "Meow!"
Polymorphism
This means different classes can have methods with the same name that work differently:
class Bird {
public function makeSound() {
return "Tweet tweet!";
}
}
class Duck extends Bird {
public function makeSound() { // Same method name, different behavior
return "Quack quack!";
}
}
Interfaces
These are like contracts that classes must follow:
interface Vehicle {
public function accelerate();
public function brake();
}
class Bicycle implements Vehicle {
public function accelerate() {
return "Pedaling faster!";
}
public function brake() {
return "Squeezing brakes!";
}
}
Abstract Classes
These are partial blueprints that other classes must complete:
abstract class Shape {
abstract public function calculateArea();
}
class Circle extends Shape {
private $radius;
public function __construct($radius) {
$this->radius = $radius;
}
public function calculateArea() {
return pi() * $this->radius * $this->radius;
}
}
These are the fundamental concepts of OOP in PHP, if you have any questions feel free to ask in the comment.
Subscribe to my newsletter
Read articles from Babatunde Daramola directly inside your inbox. Subscribe to the newsletter, and don't miss out.
Written by

Babatunde Daramola
Babatunde Daramola
Over a decade in web development | PHP | Laravel | Js | Vue | React | nodejs | Educator. More = https://linktr.ee/ritechoice23