Erweiterung von zwei Klassen

Wie kann ich das machen:

public class Main extends ListActivity , ControlMenu 

Außerdem würde ich gerne wissen, dass dieser Ansatz in Ordnung ist, dass ich die Menüs in der Klasse ControlMenu erstellt habe und sie in den restlichen Aktivitäten erweitere.

Sie können nur eine einzelne Klasse erweitern. Und implementieren Sie Schnittstellen aus vielen Quellen.

Das Erweitern mehrerer Klassen ist nicht verfügbar. Die einzige Lösung, die ich mir vorstellen kann, besteht darin, keine der beiden Klassen zu erben, sondern stattdessen eine interne Variable jeder Klasse zu haben und mehr als Proxy zu fungieren, indem die Anforderungen an Ihr Objekt an das Objekt umgeleitet werden, zu dem sie gehen sollen.

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

Dies ist die beste Lösung, die ich mir ausgedacht habe. Sie können die Funktionalität von beiden Klassen erhalten und dennoch nur von einem Klassentyp sein.

Der Nachteil ist, dass Sie nicht mit einem Guss in die Form der internen Klasse passen können.

Warum nicht eine innere Klasse verwenden (Verschachtelung)

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

Wie alle anderen gesagt haben. Nein, das kannst du nicht. Obwohl die Leute im Laufe der Jahre oft gesagt haben, dass Sie mehrere Schnittstellen verwenden sollten, haben sie sich nicht wirklich damit befasst, wie. Hoffentlich hilft das.

Angenommen, Sie haben class Foound class Barmöchten beide versuchen, sich in eine zu erweitern class FooBar. Natürlich können Sie, wie Sie sagten, nicht Folgendes tun:

public class FooBar extends Foo, Bar

Die Gründe dafür sind bereits teilweise bekannt. Schreiben Sie stattdessen interfacesfür beide Foound Bardecken Sie alle öffentlichen Methoden ab. Z.B

public interface FooInterface {

    public void methodA();

    public int methodB();

    //...
} 

public interface BarInterface {

    public int methodC(int i);

    //...
}

Und jetzt machen Foound Barimplementieren Sie die relativen Schnittstellen:

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

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

Mit class FooBarkönnen Sie jetzt beides implementieren FooInterfaceund BarInterfacedabei ein Foound Bar-Orth behalten und die Methoden direkt durchlaufen:

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

    //...

}

Der Bonus für diese Methode ist, dass das FooBarObjekt in die Formen von beiden FooInterfaceund passt BarInterface. Das heißt, das ist vollkommen in Ordnung:

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

Ich hoffe, dies verdeutlicht die Verwendung von Schnittstellen anstelle mehrerer Erweiterungen. Auch wenn ich ein paar Jahre zu spät bin.

Sie möchten Schnittstellen verwenden. Im Allgemeinen ist die Mehrfachvererbung aufgrund des Diamantproblems schlecht:

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 ++ und andere haben einige Möglichkeiten, dies zu lösen, z

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

Java verwendet jedoch nur Schnittstellen.

Die Java-Trails bieten eine großartige Einführung in die Benutzeroberfläche: http://download.oracle.com/javase/tutorial/java/concepts/interface.html Sie sollten dies wahrscheinlich befolgen, bevor Sie sich mit den Nuancen in der Android-API befassen.

Ja, wie alle anderen geschrieben haben, können Sie in Java keine Mehrfachvererbung durchführen. Wenn Sie zwei Klassen haben, aus denen Sie Code verwenden möchten, unterteilen Sie normalerweise nur eine (z. B. Klasse A). Für den Unterricht Babstrahieren Sie die wichtigen Methoden zu einer Schnittstelle BInterface(hässlicher Name, aber Sie bekommen die Idee) und sagen dann Main extends A implements BInterface. Im Inneren können Sie ein Objekt der Klasse instanziieren Bund alle Methoden von implementieren, BInterfaceindem Sie die entsprechenden Funktionen von aufrufen B.

Dies ändert die "is-a" -Beziehung in eine "has-a" -Beziehung, da Ihre Mainjetzt eine ist A, aber eine hat B. Abhängig von Ihrem Anwendungsfall können Sie diese Änderung sogar explizit vornehmen, indem Sie die BInterfaceaus Ihrer AKlasse entfernen und stattdessen eine Methode bereitstellen, um direkt auf Ihr B-Objekt zuzugreifen.

Machen Sie eine Schnittstelle. Java hat keine Mehrfachvererbung.

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

Java unterstützt keine Mehrfachvererbung, Sie können jedoch versuchen, zwei oder mehr Schnittstellen zu implementieren.

Ja. Slandau ist richtig. Java erlaubt keine Erweiterung von mehreren Klassen.

Was Sie wollen, ist wahrscheinlich public class Main extends ListActivity implements ControlMenu. Ich vermute, Sie versuchen, eine Liste zu erstellen.

Hoffentlich hilft das.

Wie bei einer anderen Alternative können Sie möglicherweise eine Schnittstelle mit einer Standardimplementierung einer Methode verwenden. Das hängt natürlich davon ab, was Sie tun möchten.

Sie können beispielsweise eine abstrakte Klasse und eine Schnittstelle erstellen:

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

Danach können Sie beide Klassen erweitern und implementieren und beide Methoden verwenden.

public class extends FatherClass implements InterfaceWithDefaultsMethods {

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

Hoffe das hilft dir ...

Das Erweitern von mehreren Klassen ist in Java nicht erlaubt. Um den tödlichen Diamanten des Todes zu verhindern !

es ist möglich

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

//blah
}

Die Entwickler von Java entschieden, dass die Probleme der Mehrfachvererbung die Vorteile überwiegen, sodass sie die Mehrfachvererbung nicht beinhalteten. Sie können über eine der größten Fragen der Mehrfachvererbung (das doppelte Diamant - Problem) lesen Sie hier .

Die beiden ähnlichsten Konzepte sind die Schnittstellenimplementierung und das Einschließen von Objekten anderer Klassen als Mitglieder der aktuellen Klasse. Die Verwendung von Standardmethoden in Schnittstellen entspricht fast genau der Mehrfachvererbung. Es wird jedoch als schlechte Praxis angesehen, eine Schnittstelle nur mit Standardmethoden zu verwenden.

Sie können in Java keine Mehrfachvererbung durchführen. Erwägen Sie die Verwendung von Schnittstellen:

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

oder innere Klassen:

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