Pass func_get_args() to another method or an object?

[Hall_of_Famer]

@TomB

I would definitely suggest that making everything inherit from a base class clearly violates SRP because you are, by definition, adding extra responsibilities to each class which extends it. Inheritance, in most cases, is a bad idea. Let’s take serialisation as an example since you mentioned it:

This:

$object->serialize();

Is less useful than:

$serializer->serialize($object);

Why? Because the serialize behaviour is a different behaviour than the responsibility of whatever the object is. The serializer could do a standard php serialize or serialize to JSON, serialize to a url encoded form string or anything. To achieve this using $object->serialize() you either need a switch statement in the serialize method, which will only ever be able to serialize into formats that the serialize method supports, or you need to add a specific serialization method for each type. $object->serializeToJson(); for example.

Using a serializer class, the serialize needs only one method:

interface Serialize {
	public function serialize($object);
}

class Serializer implements Serialize {
	public function serialize($object) {
		return serialize($object);
	}
}

class JsonSerializer implements Serialize {
	public function serialize($object) {
		return json_encode($object);
	}
}

This is a perfect example of polymorphism in action, you can pass a fully constructed $serialize object around, and it will serialize it into a format decided at the point when $serialize was created. Using $obj->serialize() the serialisation method is hard coded because it’s based on the return value of the object’s serialization method.

Your problem is definitely that you have a poor separation of concerns. Extending all objects from a base class is a bad idea because it severely reduces portability of individual components.

Well you have a good point, I definitely try not to give the root class too much responsibility, definitely not what almost all subclasses actually use. The Object::hashCode() method for instance, is used by every subclass for equality comparison, so yeah its there for a reason. In my system the standard object serialization is far more common than Json-Serialization, which is why each object has a built-in serialize() method. Sure in minor cases when Json-serialization is needed, I will past the very object to a special Json-Serializer object, such cases are rare though. Maybe constructing argument object is not an appropriate responsibility for the root object, if so I will make some changes.

Anyway, there is a reason why almost all OO languages like Smalltalk, Java, C#, Objective-C, Python and Ruby there is a root object class that is parent to all classes. I dont think theres anything wrong with that, after all all objects/classes share certain behaviors, the bottom-line is to make sure the root class does not do more than what its supposed to, dont you agree?