Extending classes in PHP

Introduction

Extending classes lets you create a new class based on an existing one. This helps you reuse code and add new features easily.

When you want a new class to have all features of an existing class plus some extra.

When you want to organize similar things in a family of classes.

When you want to change or add behavior without rewriting code.

When you want to keep your code clean and avoid repetition.

Syntax

PHP

<?php
class ParentClass {
    // properties and methods
}

class ChildClass extends ParentClass {
    // new or changed properties and methods
}
?>

The extends keyword is used to create a child class.

The child class inherits all public and protected properties and methods from the parent.

Examples

This example shows a child class Dog that changes the speak method of the parent Animal.

PHP

<?php
class Animal {
    public function speak() {
        echo "Animal sound\n";
    }
}

class Dog extends Animal {
    public function speak() {
        echo "Bark!\n";
    }
}

$dog = new Dog();
$dog->speak();
?>

The Car class extends Vehicle and adds a new method openDoor.

PHP

<?php
class Vehicle {
    public function start() {
        echo "Vehicle started\n";
    }
}

class Car extends Vehicle {
    public function openDoor() {
        echo "Door opened\n";
    }
}

$car = new Car();
$car->start();
$car->openDoor();
?>

Sample Program

This program shows a Student class extending Person. The student has a name and a grade. It can greet and study.

PHP

<?php
class Person {
    public $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function greet() {
        echo "Hello, my name is {$this->name}.\n";
    }
}

class Student extends Person {
    public $grade;

    public function __construct($name, $grade) {
        parent::__construct($name);
        $this->grade = $grade;
    }

    public function study() {
        echo "{$this->name} is studying for grade {$this->grade}.\n";
    }
}

$student = new Student("Alice", 10);
$student->greet();
$student->study();
?>

Important Notes

Use parent::__construct() to call the parent class constructor inside the child.

Child classes can override parent methods by defining a method with the same name.

Only public and protected members are inherited; private members are not accessible directly.

Summary

Extending classes helps reuse and organize code by creating child classes from parent classes.

Use extends keyword to make a child class inherit from a parent.

Child classes can add new features or change existing ones easily.

Practice

1. What keyword is used in PHP to create a child class that inherits from a parent class?

easy

A. extends

B. inherits

C. implements

D. uses

Solution

1. Step 1: Understand class inheritance in PHP

   PHP uses a specific keyword to let one class inherit properties and methods from another.

2. Step 2: Identify the correct keyword

   The keyword to extend a class in PHP is extends, not inherits, implements, or uses.

3. Final Answer:

   extends -> Option A

4. Quick Check:

   Keyword for inheritance = extends [OK]

Hint: Remember: PHP uses 'extends' to inherit classes [OK]

Common Mistakes:

• Using 'inherits' instead of 'extends'
• Confusing 'implements' with 'extends'
• Using 'uses' keyword incorrectly

2. Which of the following is the correct syntax to extend a class named Animal in PHP?

easy

A. class Dog extends Animal {}

B. class Dog inherits Animal {}

C. class Dog implements Animal {}

D. class Dog use Animal {}

Solution

1. Step 1: Recall PHP class extension syntax

   To create a child class, PHP uses the syntax: class Child extends Parent {}.

2. Step 2: Match the syntax with options

   class Dog extends Animal {} matches the correct syntax. The other options use incorrect keywords.

3. Final Answer:

   class Dog extends Animal {} -> Option A

4. Quick Check:

   Correct syntax uses 'extends' keyword [OK]

Hint: Use 'extends' keyword exactly after class name [OK]

Common Mistakes:

• Using 'inherits' instead of 'extends'
• Confusing 'implements' with 'extends'
• Using 'use' keyword for inheritance

3. What will be the output of the following PHP code?

class ParentClass {
    public function greet() {
        return "Hello from Parent";
    }
}

class ChildClass extends ParentClass {
    public function greet() {
        return "Hello from Child";
    }
}

$object = new ChildClass();
echo $object->greet();

medium

A. Hello from Parent

B. Fatal error

C. Hello from Child

D. No output

Solution

1. Step 1: Understand method overriding in child class

   The child class ChildClass overrides the greet() method of the parent class.

2. Step 2: Determine which method is called

   When calling greet() on an instance of ChildClass, the overridden method in the child class runs.

3. Final Answer:

   Hello from Child -> Option C

4. Quick Check:

   Child method overrides parent method [OK]

Hint: Child method overrides parent method with same name [OK]

Common Mistakes:

• Assuming parent method runs instead of child
• Expecting syntax error due to override
• Thinking no output will be printed

4. Identify the error in this PHP code that tries to extend a class:

class Vehicle {
    public function start() {
        return "Starting vehicle";
    }
}

class Car Vehicle {
    public function start() {
        return "Starting car";
    }
}

medium

A. Class Car should not have methods

B. Method start() cannot be overridden

C. Class Vehicle should be abstract

D. Missing 'extends' keyword before Vehicle

Solution

1. Step 1: Check class extension syntax

   In PHP, to extend a class, the child class must use the extends keyword.

2. Step 2: Identify the missing keyword

   The code class Car Vehicle {} misses extends between Car and Vehicle.

3. Final Answer:

   Missing 'extends' keyword before Vehicle -> Option D

4. Quick Check:

   Extending requires 'extends' keyword [OK]

Hint: Always write 'extends' when inheriting a class [OK]

Common Mistakes:

• Omitting 'extends' keyword
• Thinking methods cannot be overridden
• Confusing abstract class requirement

5. Given the following classes, what will be the output?

class Base {
    public function message() {
        return "Base message";
    }
}

class Derived extends Base {
    public function message() {
        return parent::message() . " and Derived message";
    }
}

class MoreDerived extends Derived {
    public function message() {
        return parent::message() . " plus MoreDerived message";
    }
}

$obj = new MoreDerived();
echo $obj->message();

hard

A. MoreDerived message

B. Base message and Derived message plus MoreDerived message

C. Base message

D. Fatal error due to parent call

Solution

1. Step 1: Trace method calls through inheritance chain

   MoreDerived::message() calls parent::message(), which is Derived::message().

2. Step 2: Understand Derived::message() call

   Derived::message() calls parent::message(), which is Base::message(), returning "Base message".

3. Step 3: Combine returned strings

   Base returns "Base message"; Derived appends " and Derived message"; MoreDerived appends " plus MoreDerived message".

4. Final Answer:

   Base message and Derived message plus MoreDerived message -> Option B

5. Quick Check:

   parent:: calls chain methods up inheritance [OK]

Hint: parent:: calls chain up inheritance to combine outputs [OK]

Common Mistakes:

• Ignoring parent:: calls and output only last method
• Expecting fatal error from parent calls
• Thinking only base method runs