2つのクラスからの拡張

これどうやってするの：

public class Main extends ListActivity , ControlMenu 

また、ControlMenuであるクラスでメニューを作成し、残りのアクティビティを拡張していることは、このアプローチで問題ないことを知りたいと思います。

拡張できるクラスは1つだけです。そして、多くのソースからのインターフェースを実装します。

複数のクラスを拡張することはできません。私が考えることができる唯一の解決策は、どちらのクラスも継承せず、代わりに各クラスの内部変数を用意し、オブジェクトへのリクエストを宛先のオブジェクトにリダイレクトすることで、より多くのプロキシを実行することです。

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

これは私が思いついた最高のソリューションです。両方のクラスから機能を取得できますが、実際のクラスタイプは1つだけです。

欠点は、キャストを使用して内部クラスのモールドに適合できないことです。

内部クラスを使用しない理由（ネスト）

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

他の皆が言ったように。いいえ、できません。しかし、人々は何年にもわたって何度も複数のインターフェースを使用するべきだと言ってきましたが、実際にはどのように使用されていないのでしょう。うまくいけば、これが役立ちます。

あなたが持っclass Fooてclass Barいて、両方にを拡張してみたいと思ったとしますclass FooBar。もちろん、あなたが言ったように、あなたはできません：

public class FooBar extends Foo, Bar

人々はすでにこの理由にある程度取り組んでいます。代わりに、書き込みinterfacesの両方のためにFooとBar自分のパブリックメソッドのすべてをカバーします。例えば

public interface FooInterface {

    public void methodA();

    public int methodB();

    //...
} 

public interface BarInterface {

    public int methodC(int i);

    //...
}

そして今、相対インターフェースを作成FooしてBar実装します：

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

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

これで、とオブジェクトを保持し、メソッドを直接通過させるだけでなく、class FooBar両方FooInterfaceを実装できます。BarInterfaceFooBar

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

    //...

}

この方法のためのボーナスは、ということであるFooBarオブジェクトは、両方の金型にフィットFooInterfaceとしBarInterface。つまり、これはまったく問題ありません。

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

これにより、複数の拡張機能の代わりにインターフェースを使用する方法が明確になることを願っています。数年遅れても。

あなたはインターフェースを使いたいでしょう。一般的に、ダイアモンド問題のために多重継承は良くありません：

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 ++などには、これを解決する方法がいくつかあります。

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

しかし、Javaはインターフェースのみを使用します。

Javaのトレイルは、インターフェイス上の偉大な導入を持っている：http://download.oracle.com/javase/tutorial/java/concepts/interface.htmlは おそらくAndroidのAPIでニュアンスにダイビングの前のことをフォローしたいでしょう。

ええ、他の誰もが書いたように、Javaで多重継承を行うことはできません。コードを使用するクラスが2つある場合、通常は1つだけをサブクラス化します（たとえば、class A）。classのB場合、その重要なメソッドをインターフェイスに抽象化しBInterface（醜い名前ですが、アイデアはわかります）、次にと言いMain extends A implements BInterfaceます。内部では、の対応する関数を呼び出すことにより、クラスのオブジェクトをインスタンス化し、のBすべてのメソッドを実装できます。BInterfaceB

これは、あなたのように「は、」関係する「で、」関係を変更しMain、今でAはなく、持っていますB。ユースケースによっては、クラスBInterfaceからを削除して変更を明示的にしA、代わりにBオブジェクトに直接アクセスするメソッドを提供することもできます。

インターフェイスを作成します。Javaには多重継承はありません。

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

Javaは多重継承をサポートしていませんが、2つ以上のインターフェースを実装してみることができます。

はい。slandauは正しいです。Javaでは、いくつかのクラスからの拡張は許可されていません。

あなたが望むのはおそらく public class Main extends ListActivity implements ControlMenuです。あなたがリストを作ろうとしていると思います。

お役に立てば幸いです。

別の代替案と同様に、メソッドのデフォルト実装でインターフェースを使用できる場合があります。もちろん、それはあなたが何をしたいかによります。

たとえば、抽象クラスとインターフェースを作成できます。

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

したがって、その後、両方のクラスを拡張して実装し、両方のメソッドを使用できます。

public class extends FatherClass implements InterfaceWithDefaultsMethods {

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

これがあなたに役立つことを願っています...

Deadly Diamond of Deathを防ぐために、Javaでは複数のクラスからの拡張は許可されていません。

可能です

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

//blah
}

Javaの作成者は、多重継承の問題がメリットを上回ると判断したため、多重継承は含まれていませんでした。多重継承の最大の問題の1つ（二重ひし形問題）については、ここで読むことができます。

最も類似した2つの概念は、インターフェースの実装と、現在のクラスのメンバーとして他のクラスのオブジェクトを含めることです。インターフェースでデフォルトのメソッドを使用することは、多重継承とほとんど同じですが、デフォルトのメソッドのみを使用してインターフェースを使用することは悪い習慣と見なされています。

Javaでは多重継承はできません。インターフェイスの使用を検討してください：

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

または内部クラス：

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