Implementing Inheritance with `extends`

1. What is Inheritance?

At its core, inheritance is a mechanism for creating a parent-child relationship between classes.

• The parent class (also known as a base class or superclass) is the class being inherited from. It contains common properties and methods.
• The child class (also known as a subclass or derived class) is the class that inherits. It receives all public and protected properties and methods from the parent, can add its own unique features, and can even change the implementation of the methods it inherits.

The key principle behind inheritance is the "is-a" relationship. For example, in a web application:

• An AdminUser is a type of User.
• A BlogPost is a type of Content.
• A Car is a type of Vehicle.

This hierarchical structure allows you to avoid duplicating code. Instead of writing the same properties (username, email) in both a User class and an AdminUser class, you define them once in the User class and let AdminUser inherit them.

To establish this relationship in PHP, we use the extends keyword.

// Parent Class
class User {
    // ... properties and methods
}

// Child Class
class AdminUser extends User {
    // This class now has everything from User, plus its own additions.
}

Let's watch a short video that introduces this concept clearly.

2. Implementing Inheritance with extends

Now let's see inheritance in action. When a child class extends a parent, it immediately has access to the parent's public methods. If the child class doesn't define its own constructor, PHP will even automatically call the parent's constructor when you create a new object of the child class.

As you saw, even without any code inside the AdminUser class, we were able to create an AdminUser object that behaved just like a User object. This is the power of code reuse in action.

3. Adding to and Overriding the Parent

Inheritance wouldn't be very useful if child classes were just exact copies. The real power comes from:

1. Adding new properties and methods specific to the child class.
2. Overriding parent methods to provide a specialized implementation.

When you add a new property to a child class (e.g., an $adminLevel for our AdminUser), you typically need to initialize it in a constructor. This means you must create a __construct() method in the child class.

However, once you define a constructor in the child class, the parent's constructor is no longer called automatically. You must do it yourself. This is a critical rule.

You can explicitly call the parent's constructor using the syntax parent::__construct().

Let's see exactly how this works.

4. Visibility Modifiers and Inheritance

In our previous module, you learned about public, private, and protected. Inheritance is where the protected modifier becomes essential.

Let's review their roles in the context of inheritance:

• public: Public members are inherited by the child class and can be accessed from anywhere (inside the child class, or from outside code).
• private: Private members are not inherited. They can only be accessed by the class that defines them. A child class cannot access its parent's private members.
• protected: Protected members are inherited. They can be accessed within the parent class and within any child classes, but not from outside. This is perfect for sharing data or methods between related classes while keeping them hidden from the rest of the application.

Hands-on Practice

Let's apply these concepts. You are building a content management system. You have a general Post class, but you want a more specific Article class for news articles that must include an author.

1. Create the Parent Post Class:

   • Create a class named Post.
   • Give it two protected properties: $title and $content.
   • Create a public constructor that accepts $title and $content and assigns them to the properties.
   • Add a public method display() that echos the title and content in a simple format.

2. Create the Child Article Class:

   • Create a class named Article that extends Post.
   • Add a new public property: $author.
   • Create a public constructor for Article that accepts $title, $content, and $author.
   • Inside the Article constructor, call the parent's constructor to handle the $title and $content.
   • Assign the $author to its property.

3. Instantiate and Test:

   • Create a new Article object with a title, some content, and an author.
   • Call the display() method on your new object.
   • Echo the author property to confirm it was set.

<?php

// 1. Parent Class
class Post
{
    protected string $title;
    protected string $content;

    public function __construct(string $title, string $content)
    {
        $this->title = $title;
        $this->content = $content;
    }

    public function display(): void
    {
        echo "<h2>{$this->title}</h2>";
        echo "<p>{$this->content}</p>";
    }
}

// 2. Child Class
class Article extends Post
{
    public string $author;

    public function __construct(string $title, string $content, string $author)
    {
        // Call the parent constructor
        parent::__construct($title, $content);
        
        // Handle the new property
        $this->author = $author;
    }
}

// 3. Instantiate and Test
$myArticle = new Article(
    'PHP Inheritance Explained',
    'Inheritance is a key feature of OOP...',
    'Alex'
);

// Call the inherited display() method
$myArticle->display();

// Access the child's public property
echo "<p><em>By: {$myArticle->author}</em></p>";

?>

Conclusion

Great work today! You've just learned one of the most powerful concepts in object-oriented programming. By using inheritance, you can build complex and logical class hierarchies that are easy to maintain and extend, which is fundamental to building professional web applications.

Key Takeaways:

• Inheritance creates a parent-child relationship between classes using the extends keyword.
• It models an "is-a" relationship, allowing you to create specialized versions of a general class.
• Child classes inherit all public and protected members from their parent.
• If a child class defines its own constructor, it must explicitly call parent::__construct() to run the parent's constructor logic.
• The protected visibility modifier allows members to be shared with child classes while remaining inaccessible to the outside world.

Preview of the Next Lesson:
We've seen that a child class can have its own constructor, which effectively overrides the parent's. In the next lesson, we will explore this concept of method overriding in more detail. You'll learn how to replace any parent method with a new implementation in the child class and how to use parent:: to call the original parent method from within the overridden one.