Hello Hans,
Tuesday, February 17, 2004, 2:59:26 PM, you wrote:
> Andi Gutmans wrote:
>> It depends what you call different signature. If you are talking about
>> default arguments, we should consider allowing those as they don't
>> change the isA relationship. However, if you want us to allow
>> inheriting interfaces which truly differ in function prototypes than
>> that would definitely be a strong no. You can never break the isA
>> relationship.
> I think at the heart of the problem (well, my problem) is the fact that
> using interfaces is restricting the way that classes are allowed to
> inherit from other classes.
> -- Example (1) --
> In more traditional PHP this works fine:
> class A {
> function init() { ... }
> function doSomething($arg1, $arg2) { ... }
> }
> class B extends A {
> function doSomething($arg1, $arg2, $arg3, $arg4 = null) { ... }
> function doSomethingElse($arg1) { ... }
> }
> $obj = new B;
> // $obj instanceof B : YES
> // $obj instanceof A : YES -- but misleading
> -- Example (2) --
> Now when you throw interfaces into the mix, I won't be able to do that
> anymore -- even if I use two separate interfaces for class A and class B.
> interface IA {
> function init();
> function doSomething($arg1,$arg2);
> }
> interface IB {
> funciton init();
> function doSomething($arg1, $arg2, $arg3, $arg4 = null);
> function doSomethingElse($arg1);
> }
> class A implements IA {
> // same class body as above
> }
> class B extends A implements IB {
> // same class body as above
> }
> Now I get fatal errors, because class B is inheriting functionality from
> A that is required by the interface IB. Actually, I think what is
> happening (can someone confirm this?) is that class B is being forced to
> implement both IA and IB, and because interfaces (unlike classes) are
> not allowed to override methods class B cannot implement both interfaces.
No the problem is that doSomething() cannot have more than one origin.
> Posslble solutions to this (in PHP engine):
> - do not inherit interfaces: force "implements" to be explicit for
> each class, so that in this case class B would not implement interface
> IA. This doesn't seem like a particularly good solution, but it would
> work [I think].
> - allow interfaces to override methods. I think to be consistent
> with PHP class behavior this is still the best option. Just like PHP
> classes can override methods, I think interfaces should be allowed.
> It's just as easy to break "instanceof" using class inheritance (as I
> showed in Example 1) as it would be to break it using interface
> overrides. In Java this isn't an issue of course because of overloading.
> Does anyone have any other suggestions for this? I agree that radically
> breaking signatures in subclasses is probably not "good practice" but in
> light of the fact that PHP doesn't support method overloading, I don't
> really see an alternative. My take on it is that this is just a
> limitation of PHP -- and I'm fine with that. I think to be consistent
> it would be good if interfaces supported the same behavior -- again,
> agreeing all the while that academically it's not the "best" design.
You can still emulate that by doing your typechecking inside the function
if you really need that - here again PHP choose the easy way. The way which
people can easily understand. We don't want to have a second Java or C++.
--
Best regards,
Marcus mailto:helly@php.net
