Inheritance and Abstraction

🏠 Building a Family Tree: PHP Inheritance and Abstraction

One Simple Idea: Think of PHP classes like a family. Parents pass down their traits to children, but each child can be unique too!

🌳 The Family Tree Analogy

Imagine you have a family tree. Your grandparents have certain traits—maybe brown eyes or curly hair. Your parents inherited those traits, and then you inherited traits from your parents!

In PHP, Inheritance works exactly the same way:

• A parent class is like your parents
• A child class is like you—inheriting everything but able to add your own twist

🧬 Inheritance: Passing Down the Good Stuff

What is it? Inheritance lets one class (the child) use all the properties and methods from another class (the parent).

Real-life example:

• Your mom knows how to cook
• You learn cooking from her automatically
• You don’t need to learn from scratch!

class Animal {
    public $name;

    public function eat() {
        echo "Yum yum!";
    }
}

class Dog extends Animal {
    public function bark() {
        echo "Woof!";
    }
}

$buddy = new Dog();
$buddy->name = "Buddy";
$buddy->eat();  // Works! Inherited
$buddy->bark(); // Also works!

The magic word is extends — it’s like saying “I want everything my parent has!”

graph TD
    A["Animal Class"] -->|extends| B["Dog Class"]
    A -->|extends| C["Cat Class"]
    B --> D["Has eat#40;#41; + bark#40;#41;"]
    C --> E["Has eat#40;#41; + meow#40;#41;"]

👨‍👩‍👧 The parent Keyword: Calling Mom and Dad

Sometimes you want to do what your parents do, but add a little extra. The parent keyword lets you call your parent’s methods from inside the child.

Think of it like this:

• Mom makes a basic sandwich
• You make the same sandwich BUT add extra cheese

class Animal {
    public function speak() {
        echo "Some sound";
    }
}

class Cat extends Animal {
    public function speak() {
        parent::speak(); // Mom's version first
        echo " Meow!";   // Then my extra part
    }
}

$kitty = new Cat();
$kitty->speak();
// Output: Some sound Meow!

Use parent::methodName() to call the parent’s version!

🔄 Method Overriding: Doing It Your Own Way

What is it? When a child class creates its own version of a method that already exists in the parent.

Real-life example:

• Your parents wave by moving their whole arm
• You wave with just your fingers
• Same action name, different style!

class Bird {
    public function move() {
        echo "Walking slowly";
    }
}

class Eagle extends Bird {
    public function move() {
        echo "Flying high!"; // Completely new
    }
}

$eagle = new Eagle();
$eagle->move();
// Output: Flying high!

The child’s version replaces the parent’s version completely!

graph TD
    A["Parent: move = walking"] -->|Child Overrides| B["Child: move = flying"]
    B --> C["Original walking is hidden"]

🔒 The final Keyword: No Changes Allowed!

Sometimes parents say “Do it exactly this way. No changes!”

The final keyword does exactly that—it prevents children from overriding a method or extending a class.

Real-life example:

• The recipe for grandma’s secret sauce
• NO ONE is allowed to change it. Ever!

Final Method (Can’t Override)

class Recipe {
    final public function secretSauce() {
        echo "Top secret ingredients!";
    }
}

class MyRecipe extends Recipe {
    // ERROR! Can't override secretSauce()
    // public function secretSauce() { }
}

Final Class (Can’t Extend)

final class UltimateRecipe {
    public function cook() {
        echo "Perfect dish!";
    }
}

// ERROR! Can't extend a final class
// class MyVersion extends UltimateRecipe { }

🎨 Abstract Classes: The Unfinished Blueprint

What is it? An abstract class is like a blueprint that says “Here’s the plan, but you need to finish the details.”

Real-life example:

• A blueprint for a house says “There must be a door here”
• But it doesn’t specify if it’s wood, glass, or metal
• The builder (child class) decides!

abstract class Shape {
    public $color;

    // Regular method - complete
    public function getColor() {
        return $this->color;
    }

    // Abstract - child MUST create this
    abstract public function area();
}

Key rules:

• ❌ You cannot create an object from an abstract class
• ✅ You must extend it and fill in the blanks

📝 Abstract Methods: “You Must Do This”

What is it? Abstract methods are like homework assignments—children MUST complete them!

abstract class Animal {
    abstract public function makeSound();
}

class Dog extends Animal {
    public function makeSound() {
        echo "Woof!"; // MUST write this
    }
}

class Cat extends Animal {
    public function makeSound() {
        echo "Meow!"; // MUST write this
    }
}

graph TD
    A["Abstract Animal"] -->|"Must implement makeSound#40;#41;"| B["Dog: Woof!"]
    A -->|"Must implement makeSound#40;#41;"| C["Cat: Meow!"]

If you forget to write the method, PHP will show an error!

🤝 Interfaces: The Promise Contract

What is it? An interface is like a promise or contract. It says “If you sign this, you MUST do these things.”

Real-life example:

• A job contract says: “You must arrive at 9 AM and complete your tasks”
• You sign it = You MUST follow it

interface Flyable {
    public function fly();
    public function land();
}

Key differences from abstract classes:

• Interfaces have NO code inside methods
• Interfaces use implements not extends
• A class can implement MANY interfaces!

✨ Interface Implementation: Signing the Contract

When you implement an interface, you MUST create every method it lists.

interface Flyable {
    public function fly();
}

interface Swimmable {
    public function swim();
}

class Duck implements Flyable, Swimmable {
    public function fly() {
        echo "Duck flying!";
    }

    public function swim() {
        echo "Duck swimming!";
    }
}

$duck = new Duck();
$duck->fly();  // Duck flying!
$duck->swim(); // Duck swimming!

One class can sign MULTIPLE contracts!

graph TD
    A["Flyable Interface"] -->|implements| C["Duck Class"]
    B["Swimmable Interface"] -->|implements| C
    C --> D["Must have fly#40;#41; and swim#40;#41;"]

🎯 Quick Comparison: Abstract Class vs Interface

🏆 Putting It All Together

// Interface - the promise
interface Speakable {
    public function speak();
}

// Abstract class - the blueprint
abstract class Pet implements Speakable {
    public $name;

    abstract public function play();

    public function sleep() {
        echo "{$this->name} is sleeping";
    }
}

// Concrete class - the real thing
class Dog extends Pet {
    public function speak() {
        echo "Woof!";
    }

    public function play() {
        echo "Fetching ball!";
    }
}

$buddy = new Dog();
$buddy->name = "Buddy";
$buddy->speak(); // Woof!
$buddy->play();  // Fetching ball!
$buddy->sleep(); // Buddy is sleeping

🌟 Remember This!

💡 Final Thought

Think of building with LEGOs:

• Inheritance = Using pre-built pieces
• Abstract Classes = Instruction books with blanks
• Interfaces = Rules about what must be included

Now you can build amazing things in PHP! 🚀