🚀 go-pugleaf

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.


Rich.

Darryl L. Pierce wrote:
> On Mon, 17 Jun 2002 00:56:34 -0400, Tristan Reeves wrote:
> 
> 
>>Nothing in particular, it's a general observation related to custom
>>interfaces:
>>
>>interface Intf1{
>>    public void X();
>>}
>>
>>interface Intf2{
>>    public void X();
>>}
>>
>>class MyClass implements Intf1, Intf2{
>>    ????
>>}
> 
> 
> What's the problem with the above? In true multiple inheritance, where
> you're inheriting multiple _implementations_, the diamond-of-death occurs
> where you're not sure which _inherited_ implementation to invoke first,
> or whether it's desirable to invoke one first. With Java, you have
> multiple inheritance on at the _interface_ level, which alleviates the
> diamond-of-death problem: you only have one inherited implementation on
> _any_ method, and that solves the problem of "which inherited
> implementation to invoke first".
> 
> HTH.
> 



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