On 10/10/07, Robert Cummings <robert@xxxxxxxxxxxxx> wrote:
>
> On Wed, 2007-10-10 at 13:30 -0500, Jay Blanchard wrote:
> > [snip]
> > so what are the benefits of the "with interfaces" solution over
> > the"without
> > > interfaces" solution
> > [/snip]
> >
> > Polymorphism.
>
> Bleh, polymorphism isn't unique to interfaces. In fact, PHP has
> polymorphism all over the place by virtue of it's loose type system. I
> can pass ANY object to any function or method (that doesn't use PHP5's
> restrictive type hinting stuff) and the code will "just use it" as long
> as the appropriate member functions/variables exist. PHP doesn't need
> inheritance or interfaces to achieve this. In fact this is far more
> flexible than the restrictive nature of interfaces. Lemme illustrate:
>
> class Finger
> {
> function wiggle()
> {
> echo 'A finger wiggles ominously.';
> }
> }
>
> class Earthworm
> {
> function wiggle()
> {
> echo 'An earthworm wiggles around.';
> }
> }
>
> function wiggle( $something )
> {
> if( method_exists( $something, 'wiggle' ) )
> {
> $something->wiggle();
> }
> else
> {
> echo 'Nothing happens.';
> }
> }
>
> $finger = new Finger();
> $jim = new Earthworm();
>
> wiggle( $finger );
> wiggle( $jim );
>
> Look Ma, no inheritance, no interfaces, and we have polymorphism. in
> fact, our wiggle function can take absolutely anything and just try to
> wiggle it. Undoubtedly OOP purists are going to scream at this because
> it just feels wrong, *hah*, too bad :)
>
>
another interesting code example, but the use of method_exists is in
userspace and
would have to be called everywhere you wanted to use the 'wiggleable'
interface.
could you imagine using interfaces with multiple methods and multiple
parameters w/
this technique; i think it would get rather messy.
interface A {
function a($someVar);
function b($someOtherVar, $anotherOtherVar);
function c($someStupidVar)
}
very easily identified by A.
vs.
function doSomethingWithA($classInstance) {
if(method_exists($classInstance, 'a') &&
method_exists($classInstance, 'b') &&
method_exists($classInstance, 'c')) {
$classInstance->a('a');
$classInstance->b('b', 'c');
$classInstance->c('c');
}
}
and we dont have the ability to count the number of parameters in each
method
without using reflection or going into some unorthodox technique; more
specifically,
php doesnt provide a function similar to func_num_args() for class methods.
at
least i didnt see one here <http://us3.php.net/manual/en/ref.classobj.php>.
so identifying one method, no parameter interfaces would work with this
technique.
it doesnt do well for moderately complex interfaces which ill define as any
interface
with more than one method where those methods have 1 or more parameters.
yes,
code using this technique would be quite ugly for such interfaces.
another benefit of going w/ the language constructs is the existence of the
interfaces, or
other classes that would be used polymorphically is that they are defined
outside of the
code that uses them. thats a little cleaner.
i hate digging through code where some functionality is in one place and
then mysteriously
its in another; and then a light turns on and i realize its the same
functionality in two different
places w/o a label to let me know w/o thinking they are the same.
this example is a little better than that, but still not as nice as the
language keywords.
there is a new art that php exposes; one that mingles functions and objects
without
requiring objects. functions are not first class citizens but they have a
global visibility.
one interesting argument is that in java static methods are essentially a
way (the only way)
to provide a global method call. in php that isnt necessary, a function
could just be written.
but i still like the static class method; because there is the association
of the function w/
some other functions that belong to the class; there is encapsulation.
this example is cool because it illustrates some of the neat things that can
be done w/ phps
mix of objects and functions.
-nathan
