1

抽象クラス A と抽象クラス B があるとします。

abstract class A {
    public void doA(){
        //some stuff
    }
}

abstract class B{
    public void doB(){
        //some stuff
    }
}

今、私は次の状況を達成したいと考えています:

クラスCにはだけ A
の機能があります クラスにはだけDの機能があります クラスには と の両方の機能があります B
E AB

どうすればいいですか？複数のクラスを拡張できないため、Javaでも可能ですか?

4

4 に答える 4

2

Java は多重継承をサポートしていません。A と B の両方の機能が必要な場合は、少なくとも 1 つをインターフェイスとして宣言する必要があります。

A だけの機能を取得するには、たとえば次のようにします。

public class C extends A {
    //your methods
}

他の人が言ったように、両方のクラスの機能を持つ Facade パターン

抽象クラスをインスタンス化できないため、A と B は抽象ではないと仮定します。

public class Facade {
    private A mA = new A();
    private B mB = new B();

    private void doB() {
        mB.doB();
    }

    private void doA() {
        mA.doA(); // as long as these are visible
    }    
}
于 2013-02-19T19:40:05.710 に答える
1

ポリモーフィズムの状況です。これを実現するには、インターフェイスとアダプター パターンを使用する必要があります。あなたのdoB()anddoA()が抽象クラスの最終メソッドであることを確認してください。

interface IA {
    public void doA();
}

interface IB {
    public void doB();}
}

abstract class A implements IA {
    public final void doA() { ... }
}

abtstract class B implements IB {
    public final void doB() { ... }
}

class C extends A {
}

class D extends B {
}

class E implements IA, IB {
    IA a = new C();
    IB b = new D();
    public void doA() { a.doA(); }
    public void doB() { b.doB(); }
}
于 2013-02-19T19:47:30.277 に答える
1

これは他の回答と非常に似ていますが、抽象クラスをインスタンス化しようとしないという点で異なります。

似ている 3 つの回答はすべて、Composition を使用して問題を解決しています。ある人はそれをファサードと呼び、別のアダプターと呼びます。私はそれをプロキシと呼んでいます。どちらが正しいかはわかりません。3 つすべてにおいて重要な事実は、継承の代わりに合成を使用することです。

インターフェイスを作成することから始めます。例えば：

public interface iA
{
  public void doA();
}

public interface iB
{
  public void doB();
}

抽象クラスを変更してこれらのインターフェースを実装する

abstract class A implements iA
{
  public void doA()
  {
    ... blah ...
  }
}

abstract class B implements iB
{
  public void doB()
  {
    ... blah ...
  }
}

A と B の具体的なバージョンを作成し (ここでは C の内部クラスとしてこれを行います)、C で両方のインターフェイスを実装し、C クラスからの呼び出し doA() と doB() を具体的な実装にプロキシします。

public class C implements iA, iB
{
  private ConcreteA cA = new ConcreteA();
  private ConcreteB cB = new ConcreteB();

  public void doA()
  {
    cA.doA();
  }

  public void doB()
  {
    cB.doB();
  }


  private class ConcreteA extends A
  {
    public doA()
    {
      ... blah ...
    }
  }

  private class ConcreteB extends B
  {
    public doB()
    {
      ... blah ...
    }
  }
于 2013-02-19T19:55:33.427 に答える
1 
abstract class A {
    public void doA(){
        // some stuff
    }
}

abstract class B{
    public void doB(){
        // some stuff
    }
}
class C {
    private A a; // assume getter/setter methods or constructor for initialization
    public void doA()
    {
        a.doA();
    }
}
class D {
    private B b;// assume getter/setter methods or constructor for initialization
    public void doB(){
        b.doB();
    }
}
class E{
    private A a;// assume getter/setter methods or constructor for initialization
    private B b;// assume getter/setter methods or constructor for initialization
    public void doAB(){
        a.doA();
        b.doB();
    }
}

抽象クラスとインターフェースについてもっと勉強することをお勧めします。上記のコードを理解するには、「戦略パターン」を理解する必要があります。「戦略パターン」を読んだ後、指定されたコードをより詳細なレベルで変更できるようになります。理解するのがより複雑になるため、インターフェイスのコーディングは行っていません。

「Head First Design Pattern」の「Strategy Pattern」を読む

于 2013-02-19T20:07:46.350 に答える