🚀 go-pugleaf

Steve Horsley wrote:
> On Tue, 18 Jun 2002 19:40:17 +0100, "Coho (Richard Swain)"
> <vibron@krang.f9.co.uk> wrote:
> 
> 
>>Use Facets.
>>
>>interface Intf1{
>>    public void X();
>>}
>>
>>interface Intf2{
>>    public void X();
>>}
>>
>>class MyClass
>>{
>>     private void intf2X()
>>     {
>>        // do interface 2 X() implementation
>>     }
>>
>>     private void intf1X()
>>     {
>>        // do interface 1 X() impementation
>>     }
>>
>>    Intf1  getIntf1()
>>    {
>>       return new Intf1()
>>       {
>>          public void X()
>>          {
>>             intf1X();
>>          }
>>       };
>>    }
>>
>>    Intf2  getIntf2()
>>    {
>>       return new Intf2()
>>       {
>>          public void X()
>>          {
>>             intf2X();
>>          }
>>       };
>>    }
>>}
>>
>>Then you can use   myclassinstance.getIntf2().X() or 
>>myclassinstance.getIntf2().X() depending which you want to use/call.
>>> 
> 
> Hmm. I see the idea, but it's not exactly polymorphic, is it. You
> almost need to create a new interface:
> 
> interface ThingThatDoesIntf1AndIntf2 {
>     Intf1 getIntf1();
>     intf2 getIntf2();
> }
> 
> Except that you can't even pass this object round to a method that
> expects to be given an Intf1 or an Intf2.

But I don't see how using somekind of namespace resolution is 
polymorphic either. i.e to specify which method to call you *have*
to specify the interface the method is on. IMHO getIntfN() does that 
just as well as some kind of language trick.

You are right about specifying a new interface, but I would hope that 
practically all concrete classes are expressions of interfaces - to 
which those two methods can be added.

If a method takes a particular interface intf1 say you can always do

theMethod( myclass.getIntf1() );

and within that if you need to get hold of the other interface just do

    Intf2 f2 = ((ThingThatDoesIntf1AndIntf2)fi).getIntf2();

For your last point. If a method takes an object of type intf1 *or* 
intf2 I'm not quite sure how it suppose to know which X() is the one to 
be called internally unless they they are functionally equivalent and 
hence the same method, or unless the object being passed in is only an 
implementation of one of the interfaces, in which case no specific 
resolution is required.

Anyway, just to get it past the compiler you could change 
ThingThatDoesIntf1AndIntf2 to

interface ThingThatDoesIntf1AndIntf2 implements intf1 and intf2
{...

If you still have doubts (maybe I am missing something) a concrete 
example would be appreciated.

Rich.


> Steve



-- 
http://www.krang.f9.co.uk