java - 理解内部类(为什么存在内部类)

Question

关闭。这个问题是 opinion-based 。目前不接受答案。

---

想要改进这个问题吗？更新问题，以便 editing this post 可以用事实和引文来回答它。 .

已关闭 7 年前。

Improve this question

我正在阅读Thinking in Java，了解内部类为何存在以及它们帮助解决什么问题。

这本书试图给出的最令人信服的理由是:

Each inner class can independently inherit from an implementation. Thus, the inner class is not limited by whether the outer class is already inheriting from an implementation.

请帮忙回顾一下我的理解:

内部类的存在是因为Java不支持多重继承。这(多重继承)可以在内部类中完成，即 Outer class可以有多个内部类，并且每个内部类可以继承自不同的类。这样，就可以实现多重继承了。我能想到的另一个原因是内部类解决了OOP设计原则composition better than inheritance 。

已更新

我找到的大部分解释就像下面的答案一样。例如，GUI框架中使用内部类来处理事件处理程序。书中没有提到引用的原因。我并不是说下面的答案不好。实际上。我真的很感激他们(+1)。我只是想知道这本书有问题吗？

Answer 1

在阅读了您从书中引用的最令人信服的理由后，您为什么会想到多重继承的想法，这有点令人费解。当一个类(无论是否是内部类)想要从多个具体实现继承行为时，多重继承就会出现问题。因此，与其他一些语言不同，在 Java 中，您不能定义如下类:

class Child extends Father, Mother {
   // Child wants to inherit some behavior from Father and some from Mother
}

正如您所看到的，只有内部类所做的任何事情都无法以简单的方式纠正或解决此 Java 决定(不支持多重继承)。

那么您可能想知道它们为什么存在!嗯，在 Java 中，每个类要么是顶级的，要么是内部的(也称为嵌套的)。在另一个类中定义的任何类都是内部类，任何不是这样的类都是顶级类。

自然地，人们可能想知道为什么要在其他类中定义类(即行为)。顶级类(class)还不够吗？

答案是肯定的。 Java 总是只有顶级类。但想法(也许)是没有充分的理由限制类成为其他类的成员!就像任何预定义类型(例如 Integer、String 等)都可以是类的成员:

class Person {
  private String name; // a field the models a Person's name
}

程序员应该能够在类中定义自己感兴趣的行为:

class Person {
  private String name; // a field the models a Person's name
  private Address address; // address is a type defined here
  static class Address {
    String street; 
    String city;
  }
}

这里发生了很多事情，特别是像 private、static 等被称为修饰符的东西。关于它们有很多技术细节，但让我们稍后再讨论它们。基本思想是能够将行为定义为另一个类的一部分。 Address 类可以在Person 类的外部定义为顶级类吗？当然。但拥有这个设施会派上用场。

现在，自从引入此功能以来，它开始服务于另一个目的，该目的称为提供代码作为数据。这就是设计模式的出现方式，直到大约 10 年前，人们才认为可以使用内部类以代码的形式提供数据。也许这对你来说有点令人困惑。考虑一下我几乎逐字从 JDK 类中获取的以下代码:java.lang.String.java:

public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                     = new CaseInsensitiveComparator();
private static class CaseInsensitiveComparator
        implements Comparator<String> {

    public int compare(String s1, String s2) {
        int n1 = s1.length();
        int n2 = s2.length();
        // details excluded for brevity
        // return -1, 0, 1 appropriately
    }
}

这里发生了什么？

我们需要一种方法来将一个字符串与另一个字符串进行比较，并且我们需要能够进行不区分大小写的比较。因此，我们在外部类中创建了 Comparator 接口(interface)的实现:String!这不是很方便吗？如果内部类不存在，则必须是:

public class String {
  // ... the whole String class implementation

}
class CaseInsensitiveComparator
            implements Comparator<String> {
   // implements the comparator method
}

这本身并不是“坏”，但它意味着很多类污染了 namespace 。内部类将行为范围限制为外部类。正如您可能会看到的那样，这很有用。本例中的数据是 Comparator 接口(interface)的实现，并且代码是相同的，因为我们正在_new_我们定义的内部类。

直到 Java 7 之前，使用匿名内部类(特别是在您希望代码充当数据的情况下)进一步利用了此功能，并且它们被 Java 8 中的 Lambda 表达式有效取代。如今，您可能看不到任何使用匿名内部类的新代码(换句话说，语言不断发展)。