Extension de deux classes

Comment puis-je faire ceci:

public class Main extends ListActivity , ControlMenu 

De plus, j'aimerais savoir que cette approche est correcte, car j'ai créé les menus en classe qui est ControlMenu et j'étends le reste des activités.

Vous ne pouvez étendre qu'une seule classe. Et implémentez des interfaces à partir de nombreuses sources.

L'extension de plusieurs classes n'est pas disponible. La seule solution à laquelle je peux penser n'est pas d'hériter de l'une ou l'autre des classes, mais plutôt d'avoir une variable interne de chaque classe et de faire plus d'un proxy en redirigeant les requêtes vers votre objet vers l'objet vers lequel vous voulez qu'elles aillent.

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

c'est la meilleure solution que j'ai trouvée. Vous pouvez obtenir la fonctionnalité des deux classes et toujours être d'un seul type de classe.

L'inconvénient est que vous ne pouvez pas entrer dans le moule de la classe interne à l'aide d'un moulage.

Pourquoi ne pas utiliser une classe intérieure (imbrication)

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

Comme tout le monde l'a dit. Non, tu ne peux pas. Cependant, même si les gens ont dit à plusieurs reprises au fil des ans que vous devriez utiliser plusieurs interfaces, ils ne sont pas vraiment entrés dans la façon dont. J'espère que cela aidera.

Dites que vous l'avez fait class Fooet class Barque vous voulez tous les deux essayer de vous étendre dans un fichier class FooBar. Bien sûr, comme vous l'avez dit, vous ne pouvez pas faire:

public class FooBar extends Foo, Bar

Les gens ont déjà exploré les raisons dans une certaine mesure. Au lieu de cela, écrivez interfacespour les deux Fooet en Barcouvrant toutes leurs méthodes publiques. Par exemple

public interface FooInterface {

    public void methodA();

    public int methodB();

    //...
} 

public interface BarInterface {

    public int methodC(int i);

    //...
}

Et maintenant, créez Fooet Barimplémentez les interfaces relatives:

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

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

Maintenant, avec class FooBar, vous pouvez mettre en œuvre à la fois FooInterfaceet BarInterfacetout en gardant un Fooet l' Barobjet et juste passer les méthodes directement à travers:

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

    //...

}

Le bonus de cette méthode est que l' FooBarobjet s'adapte aux moules des deux FooInterfaceet BarInterface. Cela signifie que c'est parfaitement 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);

J'espère que cela clarifie comment utiliser les interfaces au lieu de plusieurs extensions. Même si j'ai quelques années de retard.

Vous voudrez utiliser des interfaces. Généralement, l'héritage multiple est mauvais à cause du problème du diamant:

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 ++ et d'autres ont plusieurs façons de résoudre ce problème, par exemple

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

mais Java n'utilise que des interfaces.

Les Java Trails ont une excellente introduction sur les interfaces: http://download.oracle.com/javase/tutorial/java/concepts/interface.html Vous voudrez probablement suivre cela avant de plonger dans les nuances de l'API Android.

Oui, comme tout le monde l'a écrit, vous ne pouvez pas faire d'héritage multiple en Java. Si vous avez deux classes à partir desquelles vous souhaitez utiliser du code, vous en sous-classerez généralement une (disons classe A). Pour la classe B, vous résumez les méthodes importantes de celui-ci dans une interface BInterface(nom moche, mais vous avez l'idée), puis dites Main extends A implements BInterface. À l'intérieur, vous pouvez instancier un objet de classe Bet implémenter toutes les méthodes de BInterfaceen appelant les fonctions correspondantes de B.

Cela change la relation «est-un» en une relation «a-a», car vous Mainêtes maintenant un A, mais a un B. Selon votre cas d'utilisation, vous pouvez même rendre cette modification explicite en supprimant le BInterfacede votre Aclasse et en fournissant à la place une méthode pour accéder directement à votre objet B.

Créez une interface. Java n'a pas d'héritage multiple.

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

Java ne prend pas en charge l'héritage multiple, mais vous pouvez essayer d'implémenter deux interfaces ou plus.

Oui. slandau a raison. Java n'autorise pas l'extension de plusieurs classes.

Ce que vous voulez, c'est probablement public class Main extends ListActivity implements ControlMenu. Je suppose que vous essayez de faire une liste.

J'espère que cela pourra aider.

Comme une autre alternative, vous pouvez peut-être utiliser une interface avec une implémentation par défaut d'une méthode. Cela dépend bien sûr de ce que vous voulez faire.

Par exemple, vous pouvez créer une classe abstraite et une 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.
    }
}

Ainsi, après cela, vous pouvez étendre et implémenter les deux classes et utiliser les deux méthodes.

public class extends FatherClass implements InterfaceWithDefaultsMethods {

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

J'espère que cela vous aidera ...

L'extension à partir de plusieurs classes n'est pas autorisée en java .. pour empêcher Deadly Diamond of Death !

c'est possible

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

//blah
}

Les créateurs de java ont décidé que les problèmes d'héritage multiple l'emportaient sur les avantages, ils n'incluaient donc pas l'héritage multiple. Vous pouvez en savoir plus sur l'un des plus gros problèmes d'héritage multiple (le problème du double diamant) ici .

Les deux concepts les plus similaires sont l'implémentation d'interface et l'inclusion d'objets d'autres classes en tant que membres de la classe actuelle. L'utilisation de méthodes par défaut dans les interfaces est presque exactement la même chose que l'héritage multiple, mais il est considéré comme une mauvaise pratique d'utiliser une interface avec uniquement des méthodes par défaut.

vous ne pouvez pas faire d'héritage multiple en java. envisagez d'utiliser des interfaces:

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

ou classes internes:

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