Extending from two classes
You can only Extend a single class. And implement Interfaces from many sources.
Extending multiple classes is not available. The only solution I can think of is not inheriting either class but instead having an internal variable of each class and doing more of a proxy by redirecting the requests to your object to the object that you want them to go to.
public class CustomActivity extends Activity {
private AnotherClass mClass;
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mClass = new AnotherClass(this);
}
//Implement each method you want to use.
public String getInfoFromOtherClass()
{
return mClass.getInfoFromOtherClass();
}
}
this is the best solution I have come up with. You can get the functionality from both classes and Still only actually be of one class type.
The drawback is that you cannot fit into the Mold of the Internal class using a cast.
As everyone else has said. No, you can't. However even though people have said many times over the years that you should use multiple interfaces they haven't really gone into how. Hopefully this will help.
Say you have class Foo
and class Bar
that you both want to try extending into a class FooBar
. Of course, as you said, you can't do:
public class FooBar extends Foo, Bar
People have gone into the reasons for this to some extent already. Instead, write interfaces
for both Foo
and Bar
covering all of their public methods. E.g.
public interface FooInterface {
public void methodA();
public int methodB();
//...
}
public interface BarInterface {
public int methodC(int i);
//...
}
And now make Foo
and Bar
implement the relative interfaces:
public class Foo implements FooInterface { /*...*/ }
public class Bar implements BarInterface { /*...*/ }
Now, with class FooBar
, you can implement both FooInterface
and BarInterface
while keeping a Foo
and Bar
object and just passing the methods straight through:
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);
}
//...
}
The bonus for this method, is that the FooBar
object fits the moulds of both FooInterface
and BarInterface
. That means this is perfectly fine:
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);
Hope this clarifies how to use interfaces instead of multiple extensions. Even if I am a few years late.