为什么我们使用内部类？

Question

我想问你为什么我们需要内部类以及为什么我们使用它们？
我知道如何使用内部类，但我不知道为什么..

Answer 1

一些内部类是公开公开的（例如Java中的Map.Entry），但这只是例外而不是常态。

内部类基本上是一个实现细节。

例如，Swing 广泛使用内部类作为事件侦听器。如果没有它们，您最终会用一堆您不需要看到的类来污染全局名称空间（这可能会使它们的目的更难确定）。

本质上，内部类是范围的一种形式。包访问从包外部隐藏了类。私有内部类向该类外部隐藏该类。

Java 中的内部类还可以替代函数指针或方法委托（C# 中的）或闭包的缺失。它们是将一个函数传递给另一个函数的方法。例如，在 Executor 类中，您有：

void execute(Runnable r);

因此您可以传入一个方法。在 C/C++ 中，可以通过以下方式实现：

void execute(void (*run)());

作为指向函数的指针。

Answer 2

这篇来自 wikipedia 的文章可能会帮助您理解为什么我们需要一个内部类：

普通类或顶级类的实例可以自己存在。相比之下，内部类的实例如果不绑定到顶级类就无法实例化。

让我们采用四轮汽车的抽象概念。我们的车轮有一个特定的功能，它是我们汽车的一部分。该概念并不将车轮表示为可以作为车辆的一部分的更一般形式的车轮。相反，它代表了特定于此的它们。我们可以使用内部类来模拟这个概念，如下所示：

我们有顶级的汽车。 Car 类的实例由 Wheel 类的四个实例组成。 Wheel 的这种特定实现是特定于汽车的，因此代码不会对 Wheel 的一般概念进行建模，最好将其表示为顶级类。因此，它在语义上与 Car 类相关，并且 Wheel 的代码以某种方式与其外部类耦合。

内部类为我们提供了一种准确建模此连接的机制。我们说我们的车轮类是Car.Wheel，Car是顶级类，Wheel是内部类。

内部类因此允许程序的某些部分面向对象，否则这些部分不会封装到类中。

Answer 3

Java 中的匿名内部类是使用适配器模式的一种方式。

interface Bar
{
  public void bar();
}

class Foo
{
  public void foo()
  {
    // do something relevant
  }

  // it happens that foo() defines the same contract (or a compatible one) as
  // Bar.bar(); with an anonymous inner class we can adapt Foo to the Bar
  // interface
  public Bar asBar()
  {
    // return an instance of an anonymous inner class that implements
    // the Bar inteface
    return new Bar()
    {
      public void bar()
      {
        // from an inner class, we can access the enclosing class methods
        // as the "this pointers" are "linked"
        foo();
      }
    };
  }
}

在 Java 中，请确保您了解内部类和嵌套类之间的区别类：

内部类与
其封闭类的实例和
可以直接访问该对象的
方法和字段

C# 没有 Java 意义上的内部类，只有嵌套类。

另请参阅此内部类示例。

Answer 4

大多数时候我使用内部类是因为内部类是最接近闭包概念的东西。 有其他语言版本。这使得能够创建和使用内部嵌套作用域的对象，该对象可以访问其外部作用域的变量。这在创建回调（例如，在 Swing 中定义各种Listener）等方面通常很有用。

Answer 5

我使用它们来确定范围，例如，如果我有 ebook 类并且有 ebookPrice，我会将 ebookPrice 包含在 ebook 类之间，因为它与其相关并且只能在其中使用（至少在概念上）。

ebookPrice 可以继承自 Price，Price 处于更高的范围，并且与所有其他类相关。

（只是我的两分钱）。

Answer 6

有些语言将内部类提升到相当不同的水平，例如 Beta 和 Newpeak。在这些语言中，类的嵌套充当包装（即没有包）。

要详细了解这一愿景，请参阅 “我们需要多少个模块概念？”。另请参阅 Gilad Bracha 在他的博客上的作品...

Answer 7

面向对象的优势

在我看来，内部类最重要的特性是它允许你将通常不会变成对象的东西变成对象。这使得您的代码比没有内部类时更加面向对象。

我们来看看会员等级。由于它的实例是其父实例的成员，因此它可以访问父实例中的每个成员和方法。乍一看，这似乎并不算多；但实际上，这并不算什么。我们已经可以从父类的方法中进行这种访问。然而，成员类允许我们从父类中取出逻辑并将其对象化。例如，树类可能具有一个方法和许多执行树搜索或遍历的辅助方法。从面向对象的角度来看，树就是一棵树，而不是一种搜索算法。但是，您需要深入了解树的数据结构才能完成搜索。

内部类允许我们删除该逻辑并将其放入自己的类中。因此，从面向对象的角度来看，我们将不属于它的功能取出来，并将其放入自己的类中。通过使用内部类，我们成功地将搜索算法与树解耦。现在，要更改搜索算法，我们只需换入一个新类即可。我可以继续说下去，但这使我们的代码能够享受到面向对象技术提供的许多优点。

组织优势

面向对象设计并不是每个人都喜欢的，但幸运的是，内部类提供了更多。从组织的角度来看，内部类允许我们通过使用命名空间来进一步组织包结构。类可以进一步嵌套在类中，而不是将所有内容都转储到平面包中。明确地，如果没有内部类，我们将受到以下层次结构的限制：

package1
   class 1
      class 2
      ...
      class n
...
package n

使用内部类，我们可以执行以下操作：

package 1
   class 1
   class 2
      class 1
      class 2
      ...
      class n

仔细使用，内部类可以提供更自然地适合您的类的结构层次结构。

回调优势

内部成员类和匿名类都提供了定义回调的便捷方法。最明显的例子与 GUI 代码有关。然而，回调的应用可以扩展到许多领域。

大多数 Java GUI 都有某种组件来发起 actionPerformed() 方法调用。不幸的是，大多数开发人员只是让他们的主窗口实现 ActionListener。因此，所有组件共享相同的 actionPerformed() 方法。为了确定哪个组件执行了该操作，actionPerformed() 方法中通常有一个巨大且丑陋的开关。

这是一个整体实现的示例：

public class SomeGUI extends JFrame implements ActionListener {

    protected JButton button1;
    protected JButton button2;
    //...
    protected JButton buttonN;

    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == button1) {
        // do something
        } else if (e.getSource() == button2) {
            //... you get the picture
        }
    }
}

每当您看到开关或大型 if/if else 块时，您的脑海中应该开始响起响亮的警钟。一般来说，这样的构造是不好的面向对象设计，因为代码的一个部分的更改可能需要 switch 语句中的相应更改。内部成员类和匿名类允许我们摆脱切换的actionPerformed()方法。

相反，我们可以定义一个内部类，为我们想要监听的每个组件实现 ActionListener。这可能会导致许多内部类。但是，我们可以避免使用大型 switch 语句，并获得封装操作逻辑的额外好处。此外，该方法可以提高性能。在有 n 次比较的 switch 中，我们可以预期在平均情况下会有 n/2 次比较。内部类允许我们在动作执行者和动作监听者之间建立 1:1 的对应关系。在大型 GUI 中，此类优化会对性能产生重大影响。匿名方法可能如下所示：

public class SomeGUI extends JFrame {
    //  ... button member declarations ...

    protected void buildGUI() {
        button1 = new JButton();
        button2 = new JButton();
        //...
        button1.addActionListener(
                new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent e) {
                // do something
            }
        });
// .. repeat for each button
    }
}

使用内部成员类，相同的程序将如下所示：

public class SomeGUI extends JFrame
{
   ... button member declarations ...
   protected void buildGUI()
   {
      button1 = new JButton();
      button2 = new JButton();
      ...
      button1.addActionListener(
         new java.awt.event.ActionListener()
         {
            public void actionPerformed(java.awt.event.ActionEvent e)
            {
               // do something
            }
         }
      );
      .. repeat for each button

由于内部类可以访问父级中的所有内容，因此我们可以将出现在整体 actionPerformed() 实现中的任何逻辑移动到内部类。

我更喜欢使用成员类作为回调。然而，这是个人喜好的问题。我只是觉得太多的匿名类会使代码变得混乱。我还认为，如果匿名类超过一两行，它们可能会变得笨重。

缺点？

与其他任何事情一样，你必须兼顾好与坏。内部类有其缺点。从维护的角度来看，没有经验的Java开发人员可能会觉得内部类很难理解。使用内部类也会增加代码中类的总数。此外，从开发的角度来看，大多数 Java 工具对内部类的支持都有些不足。例如，我使用 IBM 的 VisualAge for Java 进行日常编码。虽然内部类将在 VisualAge 中编译，但没有内部类浏览器或模板。相反，您必须简单地将内部类直接键入到类定义中。不幸的是，这使得浏览内部类变得困难。键入也很困难，因为当您键入类定义或使用内部类时，您会丢失 VisualAge 的许多代码完成辅助功能