Si estende da due classi

Come posso fare questo:

public class Main extends ListActivity , ControlMenu 

Inoltre, vorrei sapere che questo approccio va bene per il fatto che ho creato i menu in classe che è ControlMenu e che sto estendendo nel resto delle attività.

Puoi estendere solo una singola classe. E implementare interfacce da molte fonti.

L'estensione di più classi non è disponibile. L'unica soluzione a cui riesco a pensare non è ereditare nessuna delle due classi ma avere invece una variabile interna di ciascuna classe e fare più di un proxy reindirizzando le richieste al tuo oggetto sull'oggetto a cui vuoi che vadano.

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

questa è la soluzione migliore che ho trovato. Puoi ottenere la funzionalità da entrambe le classi e in realtà è ancora solo di un tipo di classe.

Lo svantaggio è che non puoi inserirti nello stampo della classe interna usando un cast.

Perché non usare una classe interna (Nesting)

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

Come hanno detto tutti gli altri. No, non puoi. Tuttavia, anche se nel corso degli anni le persone hanno affermato che dovresti usare più interfacce, non hanno ancora capito come. Spero che questo possa aiutare.

Di 'che hai class Fooe class Barche entrambi vuoi provare ad estenderti in a class FooBar. Naturalmente, come hai detto, non puoi fare:

public class FooBar extends Foo, Bar

Le persone hanno già approfondito le ragioni di ciò. Invece, scrivi interfacesper entrambi Fooe Barcopre tutti i loro metodi pubblici. Per esempio

public interface FooInterface {

    public void methodA();

    public int methodB();

    //...
} 

public interface BarInterface {

    public int methodC(int i);

    //...
}

E ora crea Fooe Barimplementa le relative interfacce:

public class Foo implements FooInterface { /*...*/ }

public class Bar implements BarInterface { /*...*/ }

Ora, con class FooBar, è possibile implementare entrambiFooInterface e BarInterfacemantenendo un Fooe Baroggetto e passando semplicemente i metodi attraverso:

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

    //...

}

Il vantaggio di questo metodo è che FooBar oggetto si adatta agli stampi di entrambi FooInterfacee BarInterface. Ciò significa che va benissimo:

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

Spero che questo chiarisca come utilizzare le interfacce anziché più estensioni. Anche se sono in ritardo di qualche anno.

Ti consigliamo di utilizzare le interfacce. In genere, l'ereditarietà multipla è negativa a causa del 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 ++ e altri hanno un paio di modi per risolvere questo problema, ad es

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

ma Java utilizza solo interfacce.

I Java Trails hanno una grande introduzione sulle interfacce: http://download.oracle.com/javase/tutorial/java/concepts/interface.html Probabilmente vorrai seguirlo prima di immergerti nelle sfumature dell'API di Android.

Sì, come hanno scritto tutti gli altri, non è possibile eseguire l'ereditarietà multipla in Java. Se hai due classi da cui desideri utilizzare il codice, in genere ne devi solo una sottoclasse (ad esempio classe A). Per la classe B, astratti i metodi importanti di esso su un'interfaccia BInterface(brutto nome, ma ottieni l'idea), quindi dici Main extends A implements BInterface. All'interno, è possibile creare un'istanza di un oggetto di classe Be implementare tutti i metodi BInterfacechiamando le corrispondenti funzioni diB .

Questo cambia la relazione "is-a" in una relazione "has-a" come Mainora è una A, ma ha una B. A seconda del tuo caso d'uso, potresti persino rendere esplicito quel cambiamento rimuovendo BInterfacedalla tua Aclasse e invece fornire un metodo per accedere direttamente al tuo oggetto B.

Crea un'interfaccia. Java non ha ereditarietà multipla.

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

Java non supporta l'ereditarietà multipla, ma puoi provare a implementare due o più interfacce.

Sì. Slandau ha ragione. Java non consente l'estensione da più classi.

Quello che vuoi è probabilmente public class Main extends ListActivity implements ControlMenu . Immagino che tu stia cercando di fare un elenco.

Spero che aiuti.

Come un'altra alternativa, forse puoi usare un'interfaccia con un'implementazione predefinita di un metodo. Dipende ovviamente da quello che vuoi fare.

Ad esempio, puoi creare una classe astratta e un'interfaccia:

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

Quindi, in seguito, è possibile estendere e implementare entrambe le classi e utilizzare entrambi i metodi.

public class extends FatherClass implements InterfaceWithDefaultsMethods {

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

Spero che questo ti aiuti ...

L'estensione da più classi non è consentita in java .. per prevenire Deadly Diamond of death !

è possibile

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

//blah
}

I creatori di Java hanno deciso che i problemi dell'ereditarietà multipla superano i benefici, quindi non hanno incluso l'ereditarietà multipla. Puoi leggere uno dei più grandi problemi di eredità multipla (il problema del doppio diamante) qui .

I due concetti più simili sono l'implementazione dell'interfaccia e includono oggetti di altre classi come membri della classe corrente. L'uso di metodi predefiniti nelle interfacce è quasi identico a quello dell'ereditarietà multipla, tuttavia è considerato una pratica errata utilizzare un'interfaccia con solo metodi predefiniti.

non puoi fare l'ereditarietà multipla in java. considerare l'utilizzo di interfacce:

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

o classi interne:

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