Home » Android » java – Extending from two classes

java – Extending from two classes

Posted by: admin March 10, 2020 Leave a comment


How can I do this:

public class Main extends ListActivity , ControlMenu 

Also, I would like to know that is this approach is okay that I have made the menus in class which is ControlMenu and I am extending in rest of the activities.

How to&Answers:

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) {
         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.


Why Not Use an Inner Class (Nesting)

class A extends B {
    private class C extends D {
        //Classes A , B , C , D accessible here 


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(){

    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.


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.


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.


Make an interface. Java doesn’t have multiple inheritance.



Java does not support multiple inheritance, but you can try to implement two or more interface.


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.


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() {

Hope this helps you…


Extending from multiple classes is not allowed in java..
to prevent Deadly Diamond of death !


it is possible

public class ParallaxViewController<T extends View & Parallaxor> extends ParallaxController<T> implements AbsListView.OnScrollListener {



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.


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 {}