扩展抽象类——实现抽象方法答案

【问题标题】：Extending an abstract class - implementing abstract methods扩展抽象类——实现抽象方法
【发布时间】：2013-08-21 14:58:26
【问题描述】：

问候和问候！

我目前有一个抽象类 A，以及许多类的子类。我放入 oneMethod() 中的所有子类共有的代码，以及我放入两个抽象方法中的每个实现的特定代码。

public abstract class AbstractA {
     public oneMethod() {
          //do some intelligent stuff here
          abstractMethodOne();
          abstractMethodTwo();
     }
     protected abstract void abstractMethodOne();
     protected abstract void abstractMethodTwo();
}

我有一个覆盖 oneMethod() 方法的类。

public class B extends AbstractA {
     @Override
     public oneMethod() {
          //do some other intelligent stuff here
     }
}

有没有办法跳过子类中两个抽象方法的存根实现？我的意思是它们被使用的唯一地方是在被覆盖的方法中。

感谢任何帮助！

【问题讨论】：

标签： java inheritance

【解决方案1】：

没有。如果你扩展一个抽象类，你必须要么使子类抽象，要么它必须满足父类的契约。

作为设计观察，我建议您尝试将 oneMethod() 设为最终的或抽象的。很难维护允许以您实现它的方式进行扩展的程序。使用其他抽象方法将子类挂钩到 oneMethod() 的功能中。

【讨论】：

【解决方案2】：

您必须为所有抽象方法提供一个实现。即使现在程序的任何部分都没有调用它们，将来也可以创建一个调用它们的类，或者超类的实现可能会改变。即使只是为了二进制兼容性，也需要存根。

【讨论】：

【解决方案3】：

您可以将oneMethod 拉入超类：

public abstract class AbstractC {
  public void oneMethod() {
  }
}

public abstract class AbstractA extends AbstractC {
  @Override
  public void oneMethod() {
    //do some intelligent stuff here
    abstractMethodOne();
    abstractMethodTwo();
  }

  protected abstract void abstractMethodOne();

  protected abstract void abstractMethodTwo();

}

public class B extends AbstractC {
  @Override
  public void oneMethod() {
    //do some other intelligent stuff here
  }
}

现在看看你在AbstractC 中的需要是什么。

【讨论】：

伊克。多层次的抽象类？我不会走那条路。
@EricStein - 如果您不喜欢抽象，它可能是 interface。

【解决方案4】：

只要让 B 类也抽象。

public abstract class B extends AbstractA {

【讨论】：

这将解决编译问题，但我还需要稍后实例化该类，因此无论如何都需要存根。
这与不制作 AbstractA 抽象并具有空方法体相同。或者你可以在最后做：new B() { @Override public void abstractMethodOne() {...} ... }.
考虑到存根数量因此减少到只有 2 个，而不是 (#of subclasses that override the oneMethod)*2，这实际上对我来说效果更好。
是否有任何注释或方法可以将超类中的存根标记为“嘿，如果您可以覆盖这些方法，那就太好了”子类，但不一定显示编译器错误？跨度>
也许您正在寻找代理类。一个代理类可以以一种通用的方式实现一个或多个接口，而不需要每个方法都有。

【解决方案5】：

由于 abstractMethodOne() 和 abstractMethodTwo() 是特定于实现的，但您知道您将始终调用它们，因此您可以像这样使用组合：

public interface SomeInterface {
    void abstractMethodOne();
    void abstractMethodTwo();
}

并像这样创建一个类：

public class SomeClass {
    public void executeThem(SomeInterface onSomeObject) {
        onSomeObject.abstractMethodOne();
        onSomeObject.abstractMethodTwo();
    }
}

然后你可以在你的任何类中编写它，你应该像这样调用这些方法：

public class SomeImplementation implements SomeInterface {

    public void abstractMethodOne() {
        // ...
    }
    public void abstractMethodTwo() {
        // ...
    }

    public void executeThem() {
        new SomeClass().executeThem(this);
    }
}

这样您就完全摆脱了继承，您可以在实现SomeInterface 的类中更加灵活。

【讨论】：

这实际上很聪明，但是我仍然有一些来自超类的参数需要在子类中访问，因此据我所知需要继承。
你的意思是超类有一些你需要访问的字段？

【解决方案6】：

如果你的类 B 和 A 必须实现它们自己的 oneMethod 可能是因为没有继承链接，但它们应该实现相同的接口？

【讨论】：

【解决方案7】：

好吧，如果 abstractMethodTwo 和 abstractMethodOne 是特定于实现的，为什么要将这些方法放在基本抽象类中？也许您正在寻找一个通用的界面或一些特定的设计模式！

【讨论】：

因为 oneMethod 需要调用它们。