Como todos los demás han dicho. No puedes. Sin embargo, a pesar de que las personas han dicho muchas veces a lo largo de los años que debería usar múltiples interfaces, realmente no han explicado cómo. Esperemos que esto ayude.
Digamos que sí class Fooy class Barque ambos quieren intentar extenderse a a class FooBar. Por supuesto, como dijiste, no puedes hacer:
public class FooBar extends Foo, Bar
La gente ya ha entrado en las razones de esto hasta cierto punto. En cambio, escriba interfacespara ambos Fooy Barcubra todos sus métodos públicos. P.ej
public interface FooInterface {
public void methodA();
public int methodB();
//...
}
public interface BarInterface {
public int methodC(int i);
//...
}
Y ahora crea Fooe Barimplementa las interfaces relativas:
public class Foo implements FooInterface { /*...*/ }
public class Bar implements BarInterface { /*...*/ }
Ahora, con class FooBar, se puede implementar tanto FooInterfacey BarInterfacemientras se mantiene una Fooy Barobjeto y de paso los métodos directamente a través de:
public class FooBar implements FooInterface, BarInterface {
Foo myFoo;
Bar myBar;
// You can have the FooBar constructor require the arguments for both
// the Foo and the Bar constructors
public FooBar(int x, int y, int z){
myFoo = new Foo(x);
myBar = new Bar(y, z);
}
// Or have the Foo and Bar objects passed right in
public FooBar(Foo newFoo, Bar newBar){
myFoo = newFoo;
myBar = newBar;
}
public void methodA(){
myFoo.methodA();
}
public int methodB(){
return myFoo.methodB();
}
public int methodC(int i){
return myBar.methodC(i);
}
//...
}
La ventaja de este método es que el FooBarobjeto se ajusta a los moldes de ambos FooInterfacey BarInterface. Eso significa que esto está perfectamente bien:
FooInterface testFoo;
testFoo = new FooBar(a, b, c);
testFoo = new Foo(a);
BarInterface testBar;
testBar = new FooBar(a, b, c);
testBar = new Bar(b, c);
Espero que esto aclare cómo usar interfaces en lugar de múltiples extensiones. Incluso si llego unos años tarde.