Extendiéndose desde dos clases

Cómo puedo hacer esto:

public class Main extends ListActivity , ControlMenu 

Además, me gustaría saber que si este enfoque está bien, hice los menús en clase, que es ControlMenu, y los estoy ampliando en el resto de las actividades.

Solo puede extender una sola clase. E implementar interfaces de muchas fuentes.

Extender múltiples clases no está disponible. La única solución que se me ocurre es no heredar ninguna de las clases, sino tener una variable interna de cada clase y hacer más de un proxy redirigiendo las solicitudes a su objeto al objeto al que desea que vayan.

 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();
     }
 }

Esta es la mejor solución que se me ocurrió. Puede obtener la funcionalidad de ambas clases y aún así, en realidad, solo puede ser de un tipo de clase.

El inconveniente es que no puedes encajar en el molde de la clase interna usando un yeso.

¿Por qué no utilizar una clase interna (anidamiento)

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

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.

Querrás usar interfaces. En general, la herencia múltiple es mala debido al problema del diamante:

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 ++ y otros tienen un par de formas de resolver esto, p. Ej.

string foo() { return B::foo(); }

pero Java solo usa interfaces.

Los senderos de Java tienen una excelente introducción a las interfaces: http://download.oracle.com/javase/tutorial/java/concepts/interface.html Probablemente quieras seguir eso antes de sumergirte en los matices de la API de Android.

Sí, como todos los demás escribieron, no se puede hacer herencia múltiple en Java. Si tiene dos clases de las cuales le gustaría usar el código, normalmente solo subclase una (por ejemplo, clase A). Para la clase B, abstraes los métodos importantes de la misma en una interfaz BInterface(nombre feo, pero entiendes la idea), luego dices Main extends A implements BInterface. En el interior, puede crear una instancia de un objeto de clase Be implementar todos los métodos BInterfacellamando a las funciones correspondientes de B.

Esto cambia la relación "es-a" a una relación "tiene-a" como su Mainahora es un A, pero tiene un B. Dependiendo de su caso de uso, incluso puede hacer que ese cambio sea explícito eliminando el BInterfacede su Aclase y en su lugar proporcionar un método para acceder a su objeto B directamente.

Haz una interfaz. Java no tiene herencia múltiple.

http://csis.pace.edu/~bergin/patterns/multipleinheritance.html

Java no admite herencia múltiple, pero puede intentar implementar dos o más interfaces.

Si. Slandau tiene razón. Java no permite extender desde varias clases.

Lo que quieres es probablemente public class Main extends ListActivity implements ControlMenu. Supongo que estás tratando de hacer una lista.

Espero que ayude.

Como otra alternativa, tal vez pueda usar una interfaz con una implementación predeterminada de un método. Eso depende, por supuesto, de lo que quieras hacer.

Por ejemplo, puede crear una clase abstracta y una interfaz:

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

Entonces, después de eso, puede extender e implementar ambas clases y usar ambos métodos.

public class extends FatherClass implements InterfaceWithDefaultsMethods {

    void methode() {
        methodInherit();
        anotherMethod();
    }
}

Espero que esto te ayude...

Extender desde múltiples clases no está permitido en Java ... ¡para evitar el Diamante mortal de la muerte !

es posible

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

//blah
}

Los creadores de Java decidieron que los problemas de la herencia múltiple superan los beneficios, por lo que no incluyeron la herencia múltiple. Puede leer sobre uno de los mayores problemas de herencia múltiple (el problema del doble diamante) aquí .

Los dos conceptos más similares son la implementación de la interfaz y la inclusión de objetos de otras clases como miembros de la clase actual. El uso de métodos predeterminados en las interfaces es casi exactamente lo mismo que la herencia múltiple, sin embargo, se considera una mala práctica usar una interfaz solo con métodos predeterminados.

no puedes hacer herencia múltiple en java. considere usar interfaces:

interface I1 {}
interface I2 {}
class C implements I1, I2 {}

o clases internas:

class Outer {
    class Inner1 extends Class1 {}
    class Inner2 extends Class2 {}
}