🚀 go-pugleaf

> > That's not too bad. Except that there's no way to get back from the
> > Intf1 to the original myClass object. I'm not sure you should ever
> > want to, but I still feel alienated by this somehow.
> >
>
> You could do this if you really wanted to do.  What you'd have to do is
> enhance all your interfaces with an extra method:
>
>     Object getContainingObject();
>
> and then implement it this way within the anonymous call:
>
>     Intf1  getIntf1()
>         {
>         return new Intf1()
>         {
>             public void X()
>             {
>                 intf1X();
>             }
>             public Object getContainingObject() {
>                 return <Name of Containing Class>.this;
>             }
>         };
>     }
>
> Admittedly not as easy as in a direct implementation, but it seems to
work.
>
> Wayne

This is one of the main differences between having one class implement all
the interfaces, and having the class delegate some or all of the interfaces
to inner classes. This "dislocation" might have unfortunate effects. Not
only can't you "get back" to the object, but you also can't get to any of
the other *interfaces* that that object is supposed to implement.

As usual I can't think of a good concrete example of why this would be a
problem. I guess a problem could arise if some method took an object
parameter and expected that object to implement more than one interface (ie
to be of a certain co-type). The object itself might use "facets", but the
calling method won't know that. All it would know is "here is an object, and
I expect it to implement these interfaces. I'll do some typecasting to the
interfaces I need".  Name-resolution of some sort would allow the *single*
object to implement all of the required interfaces.

This doesn't convince me, however, because it is much safer for that method
to state which interfaces it needs in its signature - unless, of course, it
is a third party method...

Basically I now think that the problems related to multiple interfaces are
more theoretical than real, and that you can find workarounds when you need
them. Still, it does annoy me that you would *have* to use such workarounds
in some cases.

By the way, does anyone know if there is a "base" interface type -
equivalent of Object? I don't believe there is, but just want to make sure.

Tristan.