本地类 Java 的优势

Question

Java 或任何其他使用此功能的语言中的本地类有什么优势？

Answer 1

下面是一个匿名内部类、本地内部类和常规内部类如何出现在程序中的示例。该示例查看myMethod 方法和MyClass 类中存在的InnerClass 类。为了便于讨论，这些类都将实现Runnable 接口：

public class MyClass
{
    public void myMethod()
    {
        // Anonymous inner class        
        Runnable r = new Runnable() {
            public void run() {}
        };

        // Local inner class
        class LocalClass implements Runnable
        {
            public void run() {}
        }
    }

    // ... //

    // Inner class
    class InnerClass implements Runnable
    {
        public void run() {}
    }
}

匿名内部类可以用来简单地创建一个实现Runnable的类，而无需实际写出类并命名它，正如krosenvold在他的帖子中提到的那样，它在 Java 中被用作“穷人的闭包”。

例如，使用匿名内部类启动Thread 的一种非常简单的方法是：

new Thread(new Runnable() {
    public void run()
    {
        // do stuff
    }
}).start();

本地内部类可以用来创建一个在本地范围内的类——它不能被myMethod之外的其他方法访问。

如果有其他方法，并且我们尝试创建位于 myMethod 方法内的 LocalClass 实例，我们将无法这样做：

public void anotherMethod()
{
    // LocalClass is out of scope, so it won't be found,
    // therefore can't instantiate.
    new Thread(new LocalClass()).start();
}

内部类是内部类所在类的一部分。因此，例如，MyClass.InnerClass 可以从其他类访问内部类InnerClass。当然，这也意味着MyClass中的另一个方法也可以实例化一个内部类。

public void anotherMethod()
{
    // InnerClass is part of this MyClass. Perfectly instantiable.
    new Thread(new InnerClass()).start();
}

关于匿名内部类和本地内部类的另一件事是它将能够访问在myMethod 中声明的final 变量：

public void myMethod()
{
    // Variable to access from anonymous and local inner classes.
    final int myNumber = 42;

    // Anonymous inner class        
    Runnable r = new Runnable() {
        public void run()
        {
            System.out.println(myNumber); // Works
        }
    };

    // Local inner class
    class LocalClass implements Runnable
    {
        public void run()
        {
            System.out.println(myNumber); // Works
        }
    }

    // ... //

那么，有什么优势呢？使用匿名内部类和本地内部类而不是使用单独的成熟内部类或类将允许前者在声明它们的方法中访问final 变量，同时，这些类是方法本身是本地的，因此不能从外部类和同一类中的其他方法访问。

Answer 2

使用本地类可以做很多匿名内部类无法做到的事情。

• 因为类型有名称，所以您可以更有效地添加不在超类型中的成员
• 给定的名称可以使堆栈跟踪更容易跟踪（尤其是锁定对象）
• 子类型多个基本类型
• 在多个地方构造，以及多个构造函数

另一方面，它们使一些极其冗长的语法变得更加混乱。

Answer 3

它们允许您从父类中取出逻辑并将其对象化。这会从它不属于的地方删除功能并将其放入自己的类中。但是如果这个新对象只需要很短的时间，只需要一个代码块的持续时间呢？嗯，这就是本地类适合的地方。