I'm going to try something with the format of this question and I'm very open to suggestions about a better way to handle it.

I didn't want to just dump a bunch of code in the question so I've posted the code for the class on refactormycode.

base-class-for-easy-class-property-handling

My thought was that people can either post code snippets here or make changes on refactormycode and post links back to their refactorings. I'll make upvotes and accept an answer (assuming there's a clear "winner") based on that.

At any rate, on to the class itself:

I see a lot of debate about getter/setter class methods and is it better to just access simple property variables directly or should every class have explicit get/set methods defined, blah blah blah. I like the idea of having explicit methods in case you have to add more logic later. Then you don't have to modify any code that uses the class. However I hate having a million functions that look like this:

public function getFirstName()
{
   return $this->firstName;
}
public function setFirstName($firstName)
{
   return $this->firstName;
}

Now I'm sure I'm not the first person to do this (I'm hoping that there's a better way of doing it that someone can suggest to me).

Basically, the PropertyHandler class has a __call magic method. Any methods that come through __call that start with "get" or "set" are then routed to functions that set or retrieve values into an associative array. The key into the array is the name of the calling method after get or set. So, if the method coming into __call is "getFirstName", the array key is "FirstName".

I liked using __call because it will automatically take care of the case where the subclass already has a "getFirstName" method defined. My impression (and I may be wrong) is that the __get & __set magic methods don't do that.

So here's an example of how it would work:

class PropTest extends PropertyHandler
{
    public function __construct()
    {
        parent::__construct();
    }
}

$props = new PropTest();

$props->setFirstName("Mark");
echo $props->getFirstName();

Notice that PropTest doesn't actually have "setFirstName" or "getFirstName" methods and neither does PropertyHandler. All that's doing is manipulating array values.

The other case would be where your subclass is already extending something else. Since you can't have true multiple inheritance in PHP, you can make your subclass have a PropertyHandler instance as a private variable. You have to add one more function but then things behave in exactly the same way.

class PropTest2
{
    private $props;

    public function __construct()
    {
        $this->props = new PropertyHandler();
    }

    public function __call($method, $arguments)
    {
        return $this->props->__call($method, $arguments);
    }
}

$props2 = new PropTest2();

$props2->setFirstName('Mark');
echo $props2->getFirstName();

Notice how the subclass has a __call method that just passes everything along to the PropertyHandler __call method.

Another good argument against handling getters and setters this way is that it makes it really hard to document.

In fact, it's basically impossible to use any sort of document generation tool since the explicit methods to be don't documented don't exist.

I've pretty much abandoned this approach for now. It was an interesting learning exercise but I think it sacrifices too much clarity.