The creators of java decided that the problems of multiple inheritance outweigh the benefits, so they did not include multiple inheritance. You can read about one of the largest issues of multiple inheritance (the double diamond problem) here.
The two most similar concepts are interface implementation and including objects of other classes as members of the current class. Using default methods in interfaces is almost exactly the same as multiple inheritance, however it is considered bad practice to use an interface with only default methods.
Extending from multiple classes is not allowed in java.. to prevent Deadly Diamond of death !
Like another alternative, maybe you can use an interface with a default implementation of a method. That depends of course of what you want to do.
For example, you can create an abstract class and an interface:
public abstract class FatherClass {
abstract void methodInherit() {
//... do something
}
}
public interface InterfaceWithDefaultsMethods {
default void anotherMethod() {
//... do something
//... maybe a method with a callable for call another function.
}
}
So, after that, you can extend and implements both classes and use both methods.
public class extends FatherClass implements InterfaceWithDefaultsMethods {
void methode() {
methodInherit();
anotherMethod();
}
}
Hope this helps you...
you can't do multiple inheritance in java. consider using interfaces:
interface I1 {}
interface I2 {}
class C implements I1, I2 {}
or inner classes:
class Outer {
class Inner1 extends Class1 {}
class Inner2 extends Class2 {}
}
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.
it is possible
public class ParallaxViewController<T extends View & Parallaxor> extends ParallaxController<T> implements AbsListView.OnScrollListener {
//blah
}
Yea, as everyone else wrote, you cannot do multiple inheritance in Java.
If you have two classes from which you'd like to use code, you'd typically just subclass one (say class A
). For class B
, you abstract the important methods of it to an interface BInterface
(ugly name, but you get the idea), then say Main extends A implements BInterface
. Inside, you can instantiate an object of class B
and implement all methods of BInterface
by calling the corresponding functions of B
.
This changes the "is-a" relationship to a "has-a" relationship as your Main
now is an A
, but has a B
. Depending on your use case, you might even make that change explicit by removing the BInterface
from your A
class and instead provide a method to access your B object directly.
Why Not Use an Inner Class (Nesting)
class A extends B {
private class C extends D {
//Classes A , B , C , D accessible here
}
}
Make an interface. Java doesn't have multiple inheritance.
http://csis.pace.edu/~bergin/patterns/multipleinheritance.html
You will want to use interfaces. Generally, multiple inheritance is bad because of the Diamond Problem:
abstract class A {
abstract string foo();
}
class B extends A {
string foo () { return "bar"; }
}
class C extends A {
string foo() {return "baz"; }
}
class D extends B, C {
string foo() { return super.foo(); } //What do I do? Which method should I call?
}
C++ and others have a couple ways to solve this, eg
string foo() { return B::foo(); }
but Java only uses interfaces.
The Java Trails have a great introduction on interfaces: http://download.oracle.com/javase/tutorial/java/concepts/interface.html You'll probably want to follow that before diving into the nuances in the Android API.
Yes. slandau is right. Java does not allow extending from several classes.
What you want is probably public class Main extends ListActivity implements ControlMenu
. I am guessing you are trying to make a list.
Hope that helps.
Java does not support multiple inheritance, but you can try to implement two or more interface.
Source: Stackoverflow.com