Method overriding in PHP - Deep Dive

Overview - Method overriding

What is it?

Method overriding is when a child class provides its own version of a method that already exists in its parent class. This means the child class changes or extends the behavior of that method. It helps customize or improve how the method works for the child class. This is a key part of object-oriented programming that allows flexibility and reuse.

Why it matters

Without method overriding, every class would have to write all its methods from scratch or use the exact behavior of the parent class. This would make code repetitive and less flexible. Overriding lets programmers change only what they need, making programs easier to maintain and extend. It helps build systems where new features can be added without breaking old code.

Where it fits

Before learning method overriding, you should understand classes, objects, and inheritance in PHP. After mastering overriding, you can explore polymorphism, abstract classes, and interfaces to write more flexible and powerful code.

Mental Model

Core Idea

Method overriding lets a child class replace a parent's method with its own version to change behavior while keeping the same method name.

Think of it like...

It's like a recipe book passed from parent to child, but the child decides to change the recipe for chocolate cake to add extra chocolate, making it their own special version.

Parent Class
┌───────────────┐
│ methodA()     │
│ methodB()     │
└─────┬─────────┘
      │ Inherits
      ▼
Child Class
┌───────────────┐
│ methodA()     │  ← Overridden
│ methodB()     │  ← Inherited
└───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding basic inheritance

Concept: Inheritance allows a child class to use methods from a parent class.

greet(); // Outputs: Hello from Parent ?>

Result

Hello from Parent

Knowing inheritance is essential because method overriding builds on the idea that child classes start with parent methods before changing them.

2

Foundation

Defining methods in classes

Concept: Methods are functions inside classes that define behaviors.

sound(); // Outputs: Some sound ?>

Result

Some sound

Understanding how to write and call methods is the base skill needed before changing them with overriding.

3

Intermediate

Overriding a parent method

🤔Before reading on: do you think the child class method completely replaces the parent method or runs both methods together? Commit to your answer.

Concept: A child class can define a method with the same name as the parent to replace it.

greet(); // Outputs: Hello from Child ?>

Result

Hello from Child

Understanding that the child method fully replaces the parent method clarifies how overriding changes behavior.

4

Intermediate

Calling the parent method inside override

🤔Before reading on: can the child method still use the parent method's code? Commit to yes or no.

Concept: The child method can call the parent method using parent:: to reuse or extend its behavior.

greet(); // Outputs: Hello from Parent and Child ?>

Result

Hello from Parent and Child

Knowing you can combine parent and child methods helps create flexible overrides without losing original behavior.

5

Intermediate

Overriding with different visibility

Concept: The child method can change the visibility (public, protected, private) but must not reduce accessibility.

greet(); // Outputs: Hello from Child ?>

Result

Hello from Child

Understanding visibility rules prevents errors and keeps code secure while overriding.

6

Advanced

Overriding and type declarations

🤔Before reading on: do you think the child method can change the return type to something unrelated? Commit to yes or no.

Concept: PHP requires the child method's return type to be compatible with the parent's return type to maintain consistency.

getNumber(); // Outputs: 10 ?>

Result

10

Knowing type compatibility rules avoids runtime errors and keeps code predictable.

7

Expert

Overriding with late static binding

🤔Before reading on: does using self:: and static:: inside methods affect which class's method is called? Commit to your answer.

Concept: Late static binding allows overridden methods to refer to the called class, not just the parent, enabling more dynamic behavior.

Result

ChildClass

Understanding late static binding reveals how PHP resolves method calls dynamically, which is crucial for advanced inheritance designs.

Under the Hood

When a method is called on an object, PHP looks for that method starting from the object's class. If the method exists there, PHP uses it. If not, PHP checks the parent class, then the grandparent, and so on. Overriding works because the child class method shadows the parent's method with the same name. The method call resolves to the closest definition in the inheritance chain.

Why designed this way?

This design supports polymorphism and code reuse. It lets programmers write general behavior in parent classes and customize it in children without changing the parent. Alternatives like copying code would cause duplication and errors. PHP's approach balances flexibility with simplicity.

Method Call Flow

Caller -> Object of ChildClass
          │
          ▼
┌─────────────────────┐
│ ChildClass method?   │─Yes─> Use ChildClass method
│                     │
│ No                  │
└─────────────┬───────┘
              ▼
┌─────────────────────┐
│ ParentClass method?  │─Yes─> Use ParentClass method
│                     │
│ No                  │
└─────────────┬───────┘
              ▼
           ... and so on

Myth Busters - 4 Common Misconceptions

Quick: Does overriding a method mean the parent method is deleted or lost? Commit to yes or no.

Common Belief: Overriding a method deletes the parent method completely.

Reality: The parent method still exists and can be called explicitly using parent:: inside the child method.

Why it matters: Believing the parent method is lost can lead to duplicated code or missing out on reusing useful parent logic.

Quick: Can a child method have a different name and still override the parent method? Commit to yes or no.

Common Belief: A child method with a different name can override the parent method.

Reality: Overriding only works if the method name is exactly the same; different names mean no overriding.

Why it matters: Misunderstanding this causes bugs where the child method is never called, leading to unexpected behavior.

Quick: Can a child method have a more restrictive visibility than the parent? Commit to yes or no.

Common Belief: A child method can be private even if the parent method is public.

Reality: The child method cannot reduce visibility; it must be at least as accessible as the parent method.

Why it matters: Violating visibility rules causes fatal errors and breaks code access expectations.

Quick: Does late static binding mean static:: always calls the parent method? Commit to yes or no.

Common Belief: static:: always calls the parent class method regardless of the calling class.

Reality: static:: refers to the called class at runtime, enabling dynamic method resolution, not always the parent.

Why it matters: Misunderstanding late static binding leads to confusion about which method runs, causing bugs in inheritance hierarchies.

Expert Zone

1

Overriding methods with different parameter types or counts can cause subtle bugs if not carefully matched with parent signatures.

2

Using parent:: inside overridden methods is a powerful way to extend behavior but can cause infinite loops if misused.

3

Late static binding is essential for fluent interfaces and chaining methods in inheritance, but it can confuse debugging if not well understood.

When NOT to use

Avoid overriding when the child class behavior should not change the parent's method logic; instead, use composition or delegation. Also, do not override final methods or methods in final classes, as PHP forbids it.

Production Patterns

In real-world PHP applications, method overriding is used to customize framework classes, implement polymorphic behavior in models and controllers, and extend third-party libraries without modifying their source code.

Connections

Polymorphism

Method overriding enables polymorphism by allowing different classes to have methods with the same name but different behaviors.

Understanding overriding is key to grasping how polymorphism lets programs treat different objects uniformly while respecting their unique behaviors.

Software Design Patterns

Many design patterns like Template Method and Strategy rely on method overriding to customize parts of an algorithm or behavior.

Knowing overriding helps you implement and understand these patterns, which are common in professional software development.

Biology - Genetic Inheritance

Just like child organisms inherit traits from parents but can have mutations or variations, method overriding lets child classes inherit methods but change them.

Seeing overriding as a form of controlled variation helps appreciate how software evolves and adapts like living systems.

Common Pitfalls

#1 Overriding a method but forgetting to match the method signature.

Wrong approach:

Correct approach:

Root cause:

PHP requires method signatures to be compatible; changing parameters breaks overriding and causes errors.

#2 Trying to override a final method.

Wrong approach:

Correct approach:

Root cause:

Final methods cannot be overridden to protect critical behavior.

#3 Reducing method visibility in child class.

Wrong approach:

Correct approach:

Root cause:

Visibility cannot be reduced in overriding methods; PHP enforces this to maintain access consistency.

Key Takeaways

Method overriding lets child classes change or extend the behavior of parent class methods by using the same method name.

Overriding requires matching method names and compatible signatures to work correctly in PHP.

The child method can call the parent method using parent:: to reuse or build upon existing behavior.

Visibility rules must be respected: child methods cannot be less accessible than parent methods.

Advanced features like late static binding allow dynamic method resolution, making overriding more powerful and flexible.

Practice

1. What does method overriding allow a child class to do in PHP?

easy

A. Change the behavior of a method inherited from the parent class

B. Create a new method with a different name

C. Prevent the parent class from being instantiated

D. Automatically call all parent methods

Solution

1. Step 1: Understand method overriding concept

   Method overriding means a child class uses the same method name as the parent to change its behavior.

2. Step 2: Identify what overriding does

   It replaces or modifies the parent's method behavior in the child class.

3. Final Answer:

   Change the behavior of a method inherited from the parent class -> Option A

4. Quick Check:

   Method overriding = change parent method behavior [OK]

Hint: Overriding means same method name, new behavior [OK]

Common Mistakes:

• Thinking overriding creates new methods with different names
• Confusing overriding with inheritance itself
• Believing overriding prevents parent instantiation

2. Which of the following is the correct syntax to override a method named greet in a child class in PHP?

easy

A. function greetChild() { /* new code */ }

B. function greet() { /* new code */ }

C. override function greet() { /* new code */ }

D. parent::greet() { /* new code */ }

Solution

1. Step 1: Recall method overriding syntax

   To override, define a method with the same name in the child class.

2. Step 2: Check options for correct syntax

   Only function greet() { /* new code */ } defines function greet() correctly without extra keywords.

3. Final Answer:

   function greet() { /* new code */ } -> Option B

4. Quick Check:

   Same method name in child = override [OK]

Hint: Use same method name in child class to override [OK]

Common Mistakes:

• Adding 'override' keyword which PHP does not use
• Changing method name to something else
• Trying to call parent method syntax incorrectly

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

class ParentClass {
  function sayHello() {
    echo "Hello from Parent";
  }
}
class ChildClass extends ParentClass {
  function sayHello() {
    echo "Hello from Child";
  }
}
$obj = new ChildClass();
$obj->sayHello();

medium

A. Hello from ParentChild

B. Hello from Parent

C. Hello from Child

D. Error: Method not found

Solution

1. Step 1: Identify method overriding in ChildClass

   ChildClass defines sayHello() which overrides ParentClass method.

2. Step 2: Check which method is called

   Creating ChildClass object calls ChildClass's sayHello(), printing "Hello from Child".

3. Final Answer:

   Hello from Child -> Option C

4. Quick Check:

   Child method overrides parent = "Hello from Child" [OK]

Hint: Child method runs if overridden, not parent [OK]

Common Mistakes:

• Expecting parent method output instead of child
• Thinking both outputs print together
• Assuming error due to method name clash

4. Find the error in this PHP code that tries to override a method:

class Base {
  function show() {
    echo "Base";
  }
}
class Derived extends Base {
  function show() {
    parent.show();
    echo " Derived";
  }
}
$obj = new Derived();
$obj->show();

medium

A. Class Derived must declare show() as public

B. Cannot override methods in PHP

C. Missing return statement in show()

D. Incorrect syntax to call parent method; should use parent::show()

Solution

1. Step 1: Identify how parent method is called

   The code uses parent.show() which is invalid syntax in PHP.

2. Step 2: Correct syntax for calling parent method

   PHP requires parent::show() to call the parent's method inside child.

3. Final Answer:

   Incorrect syntax to call parent method; should use parent::show() -> Option D

4. Quick Check:

   Call parent method with parent::method() [OK]

Hint: Use parent::method() to call parent method inside child [OK]

Common Mistakes:

• Using dot (.) instead of :: to call parent method
• Thinking overriding is not allowed
• Forgetting to call parent method when needed

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

class Animal {
  function sound() {
    echo "Some sound";
  }
}
class Dog extends Animal {
  function sound() {
    parent::sound();
    echo " and Bark";
  }
}
class Puppy extends Dog {
  function sound() {
    echo "Yip";
  }
}
$pet = new Puppy();
$pet->sound();

hard

A. Yip

B. Some sound and Bark and Yip

C. Some sound and Bark

D. Error: Cannot override multiple times

Solution

1. Step 1: Trace method calls for Puppy object

   Puppy overrides sound() and only echoes "Yip" without calling parent.

2. Step 2: Understand overriding chain

   Since Puppy method does not call parent::sound(), Dog and Animal methods are not executed.

3. Final Answer:

   Yip -> Option A

4. Quick Check:

   Child override without parent call = only child output [OK]

Hint: If child method skips parent call, only child output shows [OK]

Common Mistakes:

• Assuming all parent methods run automatically
• Expecting combined outputs without explicit parent calls
• Thinking multiple overrides cause errors