Verlengen vanaf twee lessen

Hoe kan ik dit doen:

public class Main extends ListActivity , ControlMenu 

Ik zou ook graag willen weten of deze benadering oké is dat ik de menu’s in de klas heb gemaakt, namelijk ControlMenu, en ik breid ze uit in de rest van de activiteiten.

Antwoord 1, autoriteit 100%

Je kunt maar één les verlengen. En implementeer interfaces uit vele bronnen.

Het verlengen van meerdere lessen is niet mogelijk. De enige oplossing die ik kan bedenken is om geen van beide klassen over te nemen, maar in plaats daarvan een interne variabele van elke klasse te hebben en meer een proxy te doen door de verzoeken naar uw object om te leiden naar het object waarnaar u ze wilt laten gaan.

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

dit is de beste oplossing die ik heb bedacht.
Je kunt de functionaliteit van beide klassen krijgen en toch maar van één klassetype zijn.

Het nadeel is dat je met een gipsverband niet in de Mold of the Internal klasse kunt passen.

Antwoord 2, autoriteit 32%

Waarom geen innerlijke klasse gebruiken (nesten)

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

Antwoord 3, autoriteit 28%

Zoals iedereen al heeft gezegd. Nee, dat kan niet. Hoewel mensen in de loop der jaren vaak hebben gezegd dat je meerdere interfaces moet gebruiken, hebben ze niet echt ingegaan op hoe. Hopelijk helpt dit.

Stel dat je class Fooen class Barhebt die je allebei wilt proberen uit te breiden tot een class FooBar. Natuurlijk, zoals je zei, kun je het volgende niet doen:

public class FooBar extends Foo, Bar

Mensen zijn al tot op zekere hoogte ingegaan op de redenen hiervoor. Schrijf in plaats daarvan interfacesvoor zowel Fooals Bardie al hun openbare methoden dekken. Bijv.

public interface FooInterface {
    public void methodA();
    public int methodB();
    //...
} 
public interface BarInterface {
    public int methodC(int i);
    //...
}

En laat nu Fooen Barde relatieve interfaces implementeren:

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

Nu, met class FooBar, kun je zowel FooInterfaceals BarInterfaceimplementeren terwijl je een Fooen Barobject en geef de methoden gewoon door:

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

De bonus voor deze methode is dat de FooBarObject past bij de mallen van beide FooInterfaceen BarInterface. Dat betekent dat dit prima is:

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

Ik hoop dat dit verduidelijkt hoe je interfaces gebruikt in plaats van meerdere extensies. Zelfs als ik een paar jaar te laat ben.

4, Autoriteit 22%

U wilt interfaces gebruiken. Over het algemeen is meerdere overerving slecht vanwege het diamantprobleem:

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++ en anderen hebben een paar manieren om dit op te lossen, bijvoorbeeld

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

Maar Java gebruikt alleen interfaces.

De Java-routes hebben een geweldige introductie op interfaces: http: // download.oracle.com/javase/tutorial/java/concepts/interface.html
Je zult dat waarschijnlijk willen volgen voordat je in de nuances in de Android-api duikt.

5, Autoriteit 6%

Maak een interface. Java heeft geen meerdere erfenis.

http://csis.pace.edu/~berggin/patterns/multipleInharge en .html

6, Autoriteit 3%

JAVA ondersteunt niet meerdere overerving, maar u kunt proberen twee of meer interface te implementeren.

7, Autoriteit 2%

Ja. SLANDAU IS JUIST. Java staat niet toe om uit te breiden vanuit verschillende klassen.

Wat u wilt is waarschijnlijk public class Main extends ListActivity implements ControlMenu. Ik vermoed dat je probeert een lijst te maken.

Ik hoop dat dat helpt.

8, Autoriteit 2%

Als een ander alternatief, kunt u misschien een interface gebruiken met een standaard implementatie van een methode.
Dat hangt natuurlijk af van wat je wilt doen.

U kunt bijvoorbeeld een abstracte klasse en een interface maken:

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

Dus, daarna kunt u beide klassen en implementeren en implementeren
gebruik beide methoden.

public class extends FatherClass implements InterfaceWithDefaultsMethods {
    void methode() {
        methodInherit();
        anotherMethod();
    }
}

Ik hoop dat dit je helpt …

9

Uitbreiding van meerdere klassen is niet toegestaan ​​in Java ..
Om !

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

De makers van Java besloten dat de problemen van meerdere overerving opwegen tegen de voordelen, dus ze hebben geen meerdere overerving opgenomen. Je kunt lezen over een van de grootste problemen van meerdere overerving (het dubbele diamantprobleem) hier .

De twee meest vergelijkbare concepten zijn interface-implementatie en inclusief objecten van andere klassen als leden van de huidige klasse. Het gebruik van standaardmethoden in interfaces is bijna precies hetzelfde als meerdere erfenis, maar wordt beschouwd als een slechte praktijk om een interface te gebruiken met alleen standaardmethoden.

12

U kunt niet meerdere overerving in Java doen. Overweeg interfaces te gebruiken:

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

of binnenklassen:

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