1

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

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

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

现在我想完成以下情况：

类C具有仅 A
类D的功能，具有仅 B
类E的功能，具有两者 A的功能B。

我该怎么做？这在java中是否可能，因为一个不能扩展多个类？

4

4 回答 4

2

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

要获得仅 A 的功能，例如。

public class C extends A {
    //your methods
}

正如其他人所说，您的外观模式具有两个类的功能

假设 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

这是多态的情况。您应该使用接口和适配器模式来实现这一点。Mkae 确保您的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

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

相似的三个答案都是用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 中实现这两个接口，并将 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 回答