PHP Program to Demonstrate OOP in PHP - Building Smart Objects That Think for Themselves
Learn PHP step by step.
All about PHP - OOP in PHP - Building Smart Objects That Think for Themselves
Jan 29, 2026
## Chapter 18: OOP in PHP - Building Smart Objects That Think for Themselves
**OOP is like organizing your tools in labeled boxes instead of throwing everything in one big pile!**
**Think of OOP as creating smart robots - each one knows its own job and follows its own rules!**
### What is OOP? - The Lego Analogy
**Object-Oriented Programming is like building with Lego blocks - each block (object) has its own shape, color, and purpose!**
**Instead of having one big mess of functions, you create "things" that know how to do their job!**
**Real-world analogy:**
```
Pizza Shop Analogy:
- Chef object: Knows how to make pizza
- Order object: Knows what's in the order
- Payment object: Knows how to handle money
- Delivery object: Knows how to deliver
Each object has its own job and rules!
```
### Why OOP Makes Life Easier - The Kitchen Analogy
**Without OOP (messy kitchen):**
```php
<?php
// Everything mixed together - confusing!
$userName = "John";
$userEmail = "john@example.com";
$userAge = 25;
function validateUser($name, $email, $age) {
// Long function with lots of parameters
}
function sendUserEmail($name, $email) {
// Another function that needs all user data
}
?>
```
**With OOP (organized kitchen):**
```php
<?php
// Everything organized in one place - clean!
$user = new User("John", "john@example.com", 25);
$user->validate(); // User knows how to validate itself
$user->sendEmail(); // User knows how to send emails
?>
```
### A Practical Example: Building a Smart CartItem
**Let's create a shopping cart item that knows its own price and quantity - like a smart product!**
**Think of CartItem as a product with a brain - it knows its name, price, and can calculate its own total!**
**Breaking Down the CartItem Class:**
```php
<?php
declare(strict_types=1);
final class CartItem {
// The brain: stores the item's data
public function __construct(
private string $name, // Product name
private float $unitPrice, // Price per item
private int $qty // How many
) {}
// The mouth: tells you the name
public function name(): string {
return $this->name;
}
// The calculator: knows how many items
public function qty(): int {
return $this->qty;
}
// The accountant: calculates total price
public function total(): float {
return $this->unitPrice * $this->qty;
}
}
// Using our smart cart item
$item = new CartItem("Notebook", 40.0, 3);
echo "Product: " . $item->name() . "n"; // "Notebook"
echo "Total: $" . $item->total() . "n"; // "Total: $120"
?>
```
**What Just Happened? - The Magic Explained:**
```
1. We built a smart object (CartItem)
2. We gave it data (name, price, quantity)
3. We taught it skills (calculate total)
4. We use it anywhere without repeating code!
```
**Real-World Benefits:**
- **No more copy-pasting** the "price × quantity" formula everywhere
- **One place to change** if the calculation rules change
- **Easy to understand** - the object tells you what it does
### Encapsulation - Why Private is Your Security Guard
**`private` is like putting your valuables in a safe - only you control who can touch them!**
**Think of private properties as a restaurant kitchen - customers can't just walk in and cook!**
**The Bank Account Analogy:**
```
Bank Account Rules:
- Anyone can directly change balance: $account->balance = 1000000
- Only the account can change itself through proper methods
```
**Without Encapsulation (Dangerous!):**
```php
<?php
class BankAccount {
public $balance = 0; // Anyone can change this directly!
}
$account = new BankAccount();
$account->balance = 1000000; // Magic money appears!
echo "Balance: $" . $account->balance; // "Balance: $1000000"
?>
```
**With Encapsulation (Safe!):**
```php
<?php
class BankAccount {
private float $balance = 0; // Only the account can touch this!
public function __construct(float $initialBalance = 0) {
$this->balance = $initialBalance;
}
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 funds");
}
$this->balance -= $amount;
}
public function getBalance(): float {
return $this->balance;
}
}
$account = new BankAccount(100);
$account->deposit(50); // Valid operation
echo "Balance: $" . $account->getBalance(); // "Balance: $150"
?>
```
**Why This Matters:**
- **Protection:** Can't accidentally break the object's state
- **Validation:** Object can check if operations are valid
- **Consistency:** All changes go through the same rules
### When Many Objects Work Together: The Shopping Cart Orchestra
**Think of objects working together like an orchestra - each instrument (object) plays its part, but together they create beautiful music!**
**The Shopping Cart is like a conductor - it doesn't know HOW each item calculates its price, it just asks them for their total!**
**Real-World Analogy - The Restaurant Kitchen:**
```
Restaurant Flow:
- CartItem (Chef): "I know my recipe and cost"
- Cart (Kitchen Manager): "I don't need to know recipes, just tell me the total cost"
- Total Calculation: Kitchen manager asks each chef for their dish cost
```
**Breaking Down the Cart Class - The Smart Collection:**
```php
<?php
declare(strict_types=1);
final class Cart {
// Private property - only Cart can touch this list
private array $items = [];
// Add an item to our collection
public function add(CartItem $item): void {
$this->items[] = $item;
// CartItem is automatically validated by PHP type system!
}
// Ask each item for its total, then add them up
public function total(): float {
$sum = 0.0;
foreach ($this->items as $item) {
// Magic happens here: Cart doesn't know HOW CartItem calculates total
// It just trusts that CartItem will give the right answer!
$sum += $item->total(); // "Hey item, what's your total?"
}
return $sum;
}
public function items(): array {
return $this->items;
}
}
// Real-world usage
$cart = new Cart();
$cart->add(new CartItem("Pen", 10.0, 2)); // "Add 2 pens at $10 each"
$cart->add(new CartItem("Notebook", 40.0, 3)); // "Add 3 notebooks at $40 each"
echo "Total: $" . $cart->total(); // Cart asks each item for its total
// Output: Total: $140
?>
```
**The Beautiful Thing About This Design:**
** Cart doesn't need to know:**
- How CartItem calculates its total
- What formula CartItem uses
- Whether CartItem has discounts or taxes
** Cart only needs to know:**
- CartItem has a `total()` method
- That method returns a float
**This is called "loose coupling" - objects work together without knowing each other's internal details!**
**Benefits of This Approach:**
1. **Easy to change:** Want to add tax calculation? Change CartItem, not Cart
2. **Easy to test:** Test CartItem separately from Cart
3. **Easy to understand:** Each class has one clear responsibility
4. **Reusable:** CartItem can be used in other parts of your app
**Real-World Example - Extending the System:**
```php
<?php
// What if we want to add a discount feature?
final class DiscountedCartItem extends CartItem {
private float $discountPercent;
public function __construct(
string $name,
float $unitPrice,
int $qty,
float $discountPercent = 0
) {
parent::__construct($name, $unitPrice, $qty);
$this->discountPercent = $discountPercent;
}
public function total(): float {
$originalTotal = parent::total();
$discount = $originalTotal * ($this->discountPercent / 100);
return $originalTotal - $discount;
}
}
// Cart doesn't need to change at all!
$cart = new Cart();
$cart->add(new DiscountedCartItem("Laptop", 1000.0, 1, 10)); // 10% discount
$cart->add(new CartItem("Mouse", 25.0, 1));
echo "Total: $" . $cart->total(); // Cart still works perfectly!
?>
```
**Your Business Logic Lives in Objects:**
- **Before:** Scattered functions everywhere: `calculateItemTotal()`, `addToCart()`, `getCartTotal()`
- **After:** Organized in objects: `$item->total()`, `$cart->add()`, `$cart->total()`
**This is why OOP is powerful - it organizes your code like a well-run business!**
### Interface - The Contract That Everyone Must Follow
**An interface is like a restaurant menu - it tells you what dishes are available, but not how they're cooked!**
**Think of interfaces as job contracts - they say "You must do these tasks" but don't tell you HOW to do them!**
**Real-World Analogy - The Power Outlet:**
```
Power Outlet Interface:
- You can plug in a lamp, phone charger, or computer
- They all fit the same socket
- You don't need to know how electricity works
- The outlet doesn't care what's plugged in, as long as it follows the shape!
```
**Without Interfaces (Messy Code):**
```php
<?php
// Everything is hardcoded - hard to change!
class FileNotes {
public function readFile() { /* file logic */ }
}
class DatabaseNotes {
public function readDatabase() { /* database logic */ }
}
// You have to remember different method names for each!
$fileNotes = new FileNotes();
$dbNotes = new DatabaseNotes();
?>
```
**With Interfaces (Clean Code):**
```php
<?php
// Contract: All note systems MUST have these methods
interface NotesStore {
public function add(string $title, string $body): void;
public function all(): array;
}
// File-based notes - follows the contract
final class InMemoryNotesStore implements NotesStore {
private array $notes = [];
public function add(string $title, string $body): void {
$this->notes[] = ["title" => $title, "body" => $body];
}
public function all(): array {
return $this->notes;
}
}
// Database notes - also follows the same contract
final class PdoNotesStore implements NotesStore {
private PDO $db;
public function __construct(PDO $db) {
$this->db = $db;
}
public function add(string $title, string $body): void {
$stmt = $this->db->prepare("INSERT INTO notes (title, body) VALUES (?, ?)");
$stmt->execute([$title, $body]);
}
public function all(): array {
$stmt = $this->db->query("SELECT * FROM notes");
return $stmt->fetchAll(PDO::FETCH_ASSOC);
}
}
// Your code doesn't care WHICH system you use!
function displayNotes(NotesStore $store): void { // Accepts ANY NotesStore!
foreach ($store->all() as $note) {
echo "- {$note['title']}: {$note['body']}n";
}
}
// Test with memory storage
$memoryStore = new InMemoryNotesStore();
$memoryStore->add("Idea", "Write notes safely.");
displayNotes($memoryStore);
// Later, switch to database - NO CODE CHANGES NEEDED!
// $dbStore = new PdoNotesStore($pdo);
// displayNotes($dbStore); // Same function works!
?>
```
**Why Interfaces Are Powerful:**
** Easy to Switch:** Change from file to database without touching your main code!
** Easy to Test:** Use fake implementations for testing!
** Clear Contracts:** Everyone knows what methods are available!
** Type Safety:** PHP ensures you implement all required methods!
**Visual Example - The USB-C Analogy:**
```
┌─────────────────────────────────────────┐
│ Interface = USB-C Standard │
├─────────────────────────────────────────┤
│ │
│ Phone Charger ←──┐ │
│ Laptop ←──┼──→ All fit USB-C │
│ Headphones ←──┘ │
│ │
│ They all follow the same "contract"! │
│ │
└─────────────────────────────────────────┘
```
**Common Interface Mistakes:**
| Mistake | What Happens | How to Fix |
|---------|---------------|------------|
| Forgetting to implement all methods | PHP throws an error | Check your interface contract |
| Making interfaces too big | Hard to implement | Keep interfaces small and focused |
| Not using interfaces at all | Tight coupling everywhere | Start with simple interfaces |
| Putting implementation details in interface | Breaks the contract | Interfaces should only have method signatures |
**Real-World Exercise - Payment Processing:**
```php
<?php
// Payment interface - any payment method must implement this
interface PaymentMethod {
public function charge(float $amount): bool;
public function refund(string $transactionId): bool;
}
// Credit card implementation
final class CreditCardPayment implements PaymentMethod {
public function charge(float $amount): bool {
echo "Charging ${$amount} to credit card...n";
return true; // In real life, call payment gateway
}
public function refund(string $transactionId): bool {
echo "Refunding transaction {$transactionId} to credit card...n";
return true;
}
}
// PayPal implementation
final class PayPalPayment implements PaymentMethod {
public function charge(float $amount): bool {
echo "Charging ${$amount} via PayPal...n";
return true;
}
public function refund(string $transactionId): bool {
echo "Refunding ${$transactionId} via PayPal...n";
return true;
}
}
// Your checkout doesn't care HOW customers pay!
function checkout(PaymentMethod $payment, float $total): void {
if ($payment->charge($total)) {
echo "Payment successful! 🎉n";
}
}
// Customer pays with credit card
checkout(new CreditCardPayment(), 99.99);
// Another customer pays with PayPal
checkout(new PayPalPayment(), 149.99);
?>
```
**Key Takeaway:** Interfaces let you write code that works with ANY implementation, as long as it follows the contract!
```php
<?php
declare(strict_types=1);
final class User {
public function __construct(
private int $id,
private string $name
) {}
public function id(): int {
return $this->id;
}
public function name(): string {
return $this->name;
}
}
$u = new User(10, "Meera");
echo $u->name();
```
If you understand:
- constructor
- private vs public
- methods returning values
You can understand most real-world PHP OOP.
---