Question

I’ve been having a hard time coming up a solution with this one. I’m hoping you all can help me out.

Best described with an example:

class Parent {
    public $nationality;

    function __construct($nationality)
    {
        $this->nationality = $nationality
    }
}

class Child extends Parent {
    function __construct() {
        echo $this->nationality; // hispanic
    }
}

// Usage:
$parent = new Parent('hispanic');
$child = new Child();

I want the child to inherit properties and methods from a parent that is already initialized.

---

EDIT: Thanks all for the responses – let me give you some background. I’m trying to make a templating system. I have two classes – say Tag.php, and Form.php.

I’d like it to look like this:

class Tag {
    public $class_location;
    public $other_tag_specific_info;
    public $args;

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

    public function wrap($wrapper) {
        ...
    }

    // More public methods Form can use.
}

class Form extends Tag {
    function __construct() {
        print_r($this->args()) // 0 => 'wahoo', 1 => 'ok'
        echo $this->class_location; // "/library/form/form.php"
        $this->wrap('form');
    }

    function __tostring() {
        return '<input type = "text" />';
    }
}

// Usage:
$tag = new Tag(array('wahoo', 'ok'));
$tag->class_location = "/library/form/form.php";
$tag->other_tag_specific_info = "...";
$form = new Form();

The reason I don’t like the composite pattern is that it doesn’t make
sense to me why I would be passing in an instance of Tag to the constructor
of one of its subclass, afterall – Form is a type of Tag right?

Thanks!
Matt Mueller

Answer 1

We’ve edited quite a bit here already so I’ll just post a new answer, hope that’s ok. Will leave my old answer up for the sake of it.

Anyway, we’re starting off from your latest example (Form extends Tag).

Seems like you’re trying to mimic some kind of Builder pattern, so bear with me and let’s go with a short example:

class TagBuilder
{
    protected $args;

    protected $className;

    protected $classLocation;

    function __construct()
    {

    }

    public function setClass($file, $class)
    {
        /* @todo Use reflection maybe to determine if $class is a Tag subclass */

        if (file_exists($file))
        {
            require_once $file; // Or use the autoloader
        }

        $this->classLocation = $file;
        $this->className = $class;
    }

    /**
     * @return Tag the built tag (or tag subclass) instance
     */
    public function getTag()
    {
        $fullyQualifiedClassName = $this->getFullyQualifiedClassName();

        $newTag = new $fullyQualifiedClassName($this->args);
        $newTag->class_location = $this->classLocation;

        return $newTag;
    }

    protected function getFullyQualifiedClassName()
    {
        return $this->className;
    }

    public function setArgs($args)
    {
        $this->args = $args;
    }
}

Additionally, you will have to modify the Form constructor to call it’s parent::__construct($args) method in order to pass the $args dependency.

And then run it with

$builder = new TagBuilder();
$builder->setClass('/library/form/form.php', 'Form');
$builder->setArgs(array('wahoo', 'ok'));

$form = $builder->getTag();

This is a bit of a long example and it implies changing some of the OP’s API, but if I understood the question correctly, then this is the desired behaviour (or part of it) that the OP wants to mimic in his application.

---

Note: I am aware that this isn’t a classical example of the Builder pattern and that the getTag method might seem a bit ambiguous to some purists.