Question

I have a drawing PHP class called ClassA that is extended by many other drawing classes, ClassB for instance.

I need the inherited classes to fire its parent classes’ Draw() method. However, in my particular situation, I do not want to call such method directly (e.g.: parent::Draw()). I’d like a third function (e.g.: parent::InvokeDraw()) to call my drawing method from within the parent’s context.

Here’s some code to illustrate:

class ClassA
{
    function Draw()
    {

        /* Drawing code ... */

    }

    function InvokeDraw()
    {
        $this->Draw();
    }
}

class ClassB extends ClassA
{
    function Draw()
    {
        parent::InvokeDraw();

        /* Drawing code ... */

    }
}

The problem I’m facing is that InvokeDraw() will not call the parent’s Draw() method, but rather the extended class’ own Draw() method, thus causing an infinite loop.

Although the issue is fairly logical, I am having a hard time figuring out a workaround on that. How to accomplish this task?

Desired effect

Infinite loop problem

Answer 1

This one is with using static methods

<?php

class ClassA
{
    function Draw()
    {
        echo "DrawA";
        /* Drawing code ... */

    }

    function InvokeDraw()
    {
        self::Draw();
    }
}

class ClassB extends ClassA
{
    function Draw()
    {
        echo "DrawB";
        parent::InvokeDraw();

        /* Drawing code ... */

    }
}

echo "Begin:<br>";

$cb = new ClassB();
$cb->Draw();

Note that the only thing I changed is the InvokeDraw() method and made it use self which refers to a class, rather than object as it is with $this

Output:

Begin:
DrawBDrawA

Edit:
To answer your comment below I will add a short description of how your code works and how this code works.

What happens in your code:

1. We create B and start working with it
2. We call B->Draw() while working within B class AND B object.
3. B->Draw() calls statically(that means class method) A::Invoke() from class A BUT we are still using B object.
4. Static call A::Invoke() calls $this->Draw(); and as we are working currently with B object, $this refers to an instance of ClassB.
5. And here we go looping.

What happens in the code above:

1. We create B and start working with it
2. We call B->Draw() while working within B class AND B object.
3. B->Draw() calls statically(that means class method) A::Invoke from class A BUT as well as in your code we are still using B object.
4. Static call A::Invoke() calls self::Draw() which is basically the same as ClassA::Draw() and because it’s a static method, we don’t care what object we are currently working with and we call the A‘s Draw() method.
5. A::Draw() method executes as we need.

I will provide the same explanation for the code in my second answer, which doesn’t use static calls:

1. We create B and start working with it
2. We call B->Draw() while working within B class AND B object.
3. B->Draw() CREATES an instance of A.
4. B->Draw() calls A->Invoke() which means we start to work with an object that is instance of class A and not B like before.

At this point we completely forget that B even exists and work only with A

1. A->Invoke() calls $this->Draw() which means that we are calling A->Draw(), because we already work with an instance of class A.
2. A->Draw() executes as we expect.

From usability point of view, we can see that the static method is better, as we can define some static properties and you can work with them when A::Draw() executes. If we use non-static method, then we need to pass the data we need within arguments of our methods.

I hope this makes it clear. The sequences above do not have the right terminology, but it was written on purpose, I think it’s easier to understand the flow that way.