call super class, run all subclasses

[superaktieboy]

Hi,

I am looking into a way of adding addons to a class I made.. I thought something like this would work, but not sure how to implement it:

<?php
class foo {
    function foobar($text) {
        $text = $text . 'a';
    }
}
class bar extends foo {
    function foobar($text) {
        $text = $text . 'b';
    }
}
?>
 

Now i want to be able to call up foo, and it calls the foobar of foo, and the foobar of bar.
is that possible?

hosh

[nathj]

Hi,
Try using the line

parent::foobar();
 

in you subclass to call the function on the parent class.

Cheers
nathj

[Dormilich]

neither is that possible, nor sensible.

inheritance is meant to work upwards (child classes can access parent classes) not downwards (try calling a child class that doesn’t exist!)

besides that, you are not supposed to call non-static methods statically.

[nathj]

oops, I added the post in a hurry, of course I meant add it to the child class.

As for the static context I was unaware that such concerns existed in PHP. Looks like a bit more reading for me today. Having worked in Java I'm keen to learn that PHP has a proper static context.

[Dormilich]

within an object instance of a specified class you have access to all properties/methods of that class and all public and protected properties/methods of all parent classes.

static context is like a global.

[nathj]

Thanks for the pointers. It's great when you start trying to help and then end up learning something more.

[superaktieboy]

thanks for the answers.. this did the trick for me:

<?php
 
class lol {
    private $lol = 'HA';
    private $extensions = array();
    function add(ext $obj) {
        $this->extensions[] = $obj;
    }
 
    function loop($text) {
        foreach($this->extensions as $obj) {
            $text = $obj->parse($text);
        }
        return $text;
    }
}
 
abstract class ext {
    public abstract function parse($text);
}
 
class ext1 extends ext {
    public function parse($text) {
        return $text . 'ext1';
    }
}
class ext2 extends ext {
    public function parse($text) {
        return $text . 'ext2';
    }
}
 
 
$lol = new lol();
$lol->add(new ext1());
$lol->add(new ext2());
echo $lol->loop('test');
?>
 

[Dormilich]

a classical Observer Pattern.

I recommend to use interfaces instead of abstract classes, though. (you can only extend one abstract class, but implement many interfaces)

interface ext
{
    public function parse($text);
}

class ext1 implements ext
{
    // …
}

tip: class/interface names should begin with an uppercase letter.

[nathj]

That's a neat solution. I appreciate the lesson I've learned here so thanks for that.

Cheers
nathj

[Dormilich]

more tips you can find in the Userland Naming Guide