Question

假设我有一个抽象类A和一个抽象类B：

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

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

现在我想完成以下情况：

班级C的功能为 A 课程D的功能为 B class E的功能为 A和B。

我该怎么做？这在Java中是否可行，因为无法扩展多个类？

Answer 1

Java不支持多重继承。如果你想要同时拥有A和B的功能，你必须至少声明其中一个作为接口。

获得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
    }    
}

Answer 2

这是多态性的情况。您应该使用接口和适配器模式来实现此目的。 Mkae确保您的doB()和doA()是抽象类中的最终方法。

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

Answer 3

这与其他答案非常相似，但不同之处在于它不会尝试实例化抽象类。

三个相似的答案都是使用Composition来解决问题。一个称为外观，另一个适配器。我叫它代理。我不确定哪个（如果有的话）是正确的。这三个中的重要事实是我们使用Composition而不是继承。

首先创建接口。例如：

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中实现两个接口，并将调用doA（）和doB（）从C类代理到具体实现。

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

Answer 4

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 Patter”中的“策略模式”

从两个类获取功能

4 个答案: