Method return type to fulfill multiple interfaces

Question

Is it possible to specify a method which returns a object that implements two or multiple interfaces?

Say we have the following interfaces:

interface FooBar {
    [Foo] & [Bar] getFooBar();
}

interface Foo {
    void doFoo();
}

inteface Bar {
    void doBar();
}

Implementors of FooBar need to provide the method getFooBar() that returns an instance of a type which fullfills Foo as well as Bar.

What I tried so far is to do it with generics:

interface FooBar {
    <T extends Foo & Bar> T getFooBar()
}

class SomeImplementor implements FooBar {
    private FooAndBarImpl fSomeField;

    public <T extends Foo & Bar> T getFooBar() {
        return fSomeField;
    }

}

Given that FooAndBarImpl is some type provided by a framework or library and implements Foo and Bar this I think should work. However, it doesn't, because "FooAndBarImpl cannot be converted to T". Why is that? The contract implied by getFooBar() is not broken as I see it.

Another solution would be to define a new interface that extends Foo and Bar and to use that as return type. I just don't see much sense in returning a empty wrapper for the fSomeField in the getFooBar() implementation.

EDIT:

Would appreciate it if someone could explain why the generics approach doesn't work. I just don't see it.

Answer 1

You can make T a class parameter:

class SomeImplementor<T extends Foo & Bar> implements FooBar {
    private T fSomeField;

    public T getFooBar() {
        return fSomeField;
    }

}

As to why your generics approach didn't work. Lets create the following two classes that implement Foo and Bar:

class A implements Bar, Foo{
   private int a;
   ...
}
class B implements Bar, Foo{
   private String b;
   ...
}
class SomeImplementor implements FooBar {
   private A someField;
   public <T extends Foo & Bar> T getFooBar() {
      return someField;
   }
}

So we should now be able to execute the following:

SomeImplementor s = new SomeImplementor();
A a = s.getFooBar();
B b = s.getFooBar();

Although getFooBar() returns an object of type A, which has no valid cast to type B (where will the String member come from?), even though B fulfills the requirement of <T extends Foo & Bar>, i.e. is a valid T.

In short, the compiler (remember, generics is a compile-time mechanism) can't guarantee that every T of type <T extends Foo & Bar> can have an assignment to it of type A. Which is exactly the error you see - the compiler can't convert the given A to every valid T.

Answer 2

Another solution would be to define a new interface that extends Foo and Bar and to use that as return type.

I would say go for this option.