11

在 Java 中存在一些内部类扩展外部类的情况。

例如，java.awt.geom.Arc2D.Float 是 java.awt.geom.Arc2D 的一个内部类，也扩展了 Arc2D。（参见http://download.oracle.com/javase/6/docs/api/java/awt/geom/Arc2D.Float.html）

此外，sun.org.mozilla.javascript.internal.FunctionNode.Jump 扩展了 sun.org.mozilla.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：jjnguy 建议将逻辑保持在同一个地方。在这种情况下，你为什么不写一个文件 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();
  }
}

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

在我看来，拥有一个可以嵌套无数相同子类的类似乎是糟糕的设计。（上下文：这是在尝试为代码完成实用程序生成字典时出现的，并抛出了 StackOverflowException。我找到了一种解决方法，但我无法理解为什么它是这样设计的。）

4

3 回答 3

15

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

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

在这种Point2D情况下，将类及其逻辑进行逻辑耦合。它可以帮助该abstract类型的用户Point2D找到他们可以使用的实现。

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

于 2011-08-19T17:30:51.410 回答
9

内部类有两种情况：

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

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

扩展外部类的静态内部类的情况不如扩展外部类的非静态内部类有趣。

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

让我们看一些代码：

Outer a = new Outer();
Outer.Inner b = a.new Inner();

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

如果您知道构建器模式，则可以使用它来获得它的 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();。

于 2011-08-19T17:45:37.893 回答
2

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

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

于 2011-08-19T17:45:38.403 回答