Java内部类扩展了外部类

Question

在Java中，有时内部类扩展外部类。

例如java.awt.geom.Arc2D.Float是java.awt.eom.Arc2D的内部类，并且还扩展了Arc2D。(c.f。http://download.oracle.com/javase/6/docs/api/java/awt/geom/Arc2D.Float.html)

此外，sun.org.mozilla.javascript.internal.FunctionNode.Jump扩展了sun.org.muzilla.javascript.internal.Node，它是FunctionNode的一个超类。(抱歉…找不到javadoc的链接(

对我来说，这似乎很奇怪。然后你能创建这些吗？

new Arc2D.Float.Float() //n.b. I couldn't get this to compile in Intellij IDEA;
new FunctionNode.Jump.Jump.Jump(1); // I could get this to compile

将子类嵌套为超类的内部类有什么用途？

我想知道这是否是为了访问超类中的某些内容，但如果你想访问父类中的任何变量/方法，你可以使用

super.variable;

或

super.method();

编辑1:詹吉建议保持逻辑不变。在这种情况下，你为什么不写一个文件com.mypackage.AbstractTest:

abstract class AbstractTest {
  abstract String getString();
}
class ExtensionTest extends AbstractTest {
  @Override
  String getString() {
    return "hello world";
  }
}

而不是：

abstract class AbstractTest {
  abstract String getString();
  class ExtensionTest extends AbstractTest {
    @Override
    String getString() {
      return "hello world";
    }
  }
}

编辑2：有人正确地指出，我之前编辑中的建议是有缺陷的，因为无法在包之外构建ExtensionTest。然而，我在周末对此进行了进一步的思考，那么以下内容呢：

abstract class Test {
  public class ExtensionTest extends AbstractTest {
    @Override
    String getString() {
      return "hello world";
    }
  }
  private abstract class AbstractTest {
    abstract String getString();
  }
} 

本质上，到目前为止我看到的最好的答案是，让内部类扩展其外部类可以将逻辑分组在一起。然而，我认为这可以在没有延期的情况下完成。

在我看来，一个类中嵌套了无限多个相同的子类，这似乎是一种糟糕的设计

看看Java的Point2D。它有两个内部类，它们是它的子类

需要注意的是，它们是static内部类。这与普通内部类有着完全不同的含义。就像静态方法一样，静态类是在类级别而不是对象级别定义的。

在Point2D的情况下，这样做是为了逻辑地耦合类及其逻辑。它帮助abstract类型Point2D的用户找到他们可以使用的实现。

作为对您编辑的回应，我想指出一个重要的事实。一个Java文件只能包含一个公共类，除了公共内部类。虽然您的两个示例都可以编译，但它们不允许公众访问这些类。如果要在一个文件中向某人呈现多个公共类，则必须使用公共静态内部类。

内部类有两种情况：

• 静态内部类。内部类不保持对外部类的引用。

• 非静态内部类。内部类确实保留了对外部类的引用。

静态内部类扩展外部类的情况不像非静态内部类延伸外部类那样有趣。

后者的情况是：要创建内部类，需要对外部类的引用。但是，由于内部类是外部类的实例，它也接受对内部类的另一个实例的引用，用作外部类。

让我们看看一些代码：

Outer a = new Outer();
Outer.Inner b = a.new Inner();
// Only possible when Inner extends Outer:
Outer.Inner c = a.new Inner().new Inner();

如果您知道builder模式，则可以使用它的OOP版本：

public abstract class Command {
    // Not possible to create the command, else than from this file!
    private Command() {
    }
    public abstract void perform();
    public static class StartComputer extends Command {
        public void perform() {
            System.out.println("Starting Computer");
        }
    }
    public class OpenNotepad extends Command {
        public void perform() {
            Command.this.perform();
            System.out.println("Opening Notepad");
        }
    }
    public class ShutdownComputer extends Command {
        public void perform() {
            Command.this.perform();
            System.out.println("Shutting Computer");
        }
    }
}

用作：new Command.StartComputer().new OpenNotepad().new ShutdownComputer().perform();。

第一个在我的IntelliJ上编译得很好。

严格来说，静态成员类不是内部类。它们被称为嵌套类。