Question

我正在阅读“Head First Java”这本书，并且在某些时候它提到内部类实例必须绑定到我已经知道的外部类实例，但有一个例外：

非常特殊的情况 - 在静态方法中定义的内部类。但你可能会在没有遇到其中一个的情况下完成整个Java生活这些

我很确定最后一个语句确实是正确的，但如果编译器允许它发生，则意味着它存在是有原因的，否则它将是非法的Java。有人能告诉我一个有用的例子吗？

Answer 1

可能不是特别的，也可能不是。

您正在查看方法中可用的本地课程：

class Foo {
    static void bar(){
       class MyRunnable implements Runnable {
           public void run() {
               System.out.println("No longer anonymous!");
           }    
        };
       Thread baz = new Thread(new MyRunnable());
    }

}

我见过使用匿名的内部类，如：

class Foo {
    static void bar(){
        Thread baz=new Thread(new Runnable(){
            public void run(){
                System.out.println("quux");
            }
        }
    }
}

这在技术上是一个内部类（虽然是匿名的）并在静态方法中定义。我个人会创建一个实现Runnable的静态嵌套类，并执行：

baz = new Thread(new MyRunnable());

其中MyRunnable定义为：

class Foo {
    static void bar(){
       // SNIP
    }
    static class MyRunnable implements Runnable {
        public void run() {
            System.out.println("No longer anonymous!");
        }    
    }
}

Answer 2

有些人认为对于这样一个人来说，班级的内在美不会非常重要。

Answer 3

这是静态方法中内部类的制作示例。可以声称

不需要在静态方法之外声明，因为在其他地方不需要

它应该是一个命名类（即非匿名），因为它被多次使用

class Race {
    public static void main(String[] args) throws Exception{
        class Runner implements Runnable {
            final String name;
            long time = -1;
            Runner(String name) { this.name = name; }
            public void run() {
                try {
                    long start = System.currentTimeMillis();
                    time = -2;
                    System.out.printf("Start %s\n", name);
                    for (int i = 0; i < 10; i++) {
                        Thread.sleep(1000);
                    }
                    System.out.printf("End %s\n", name);
                    this.time = System.currentTimeMillis() - start;
                } catch (InterruptedException e) {
                    time = -3;
                }
            }
            long time() { return time; }
        }                
        Runner r1 = new Runner("One");
        Runner r2 = new Runner("Two");
        Thread one = new Thread(r1);
        Thread two = new Thread(r2);
        one.start();
        two.start();
        one.join();
        two.join();
        System.out.printf("One: %s, Two: %s\n", r1.time(), r2.time());
        System.out.printf("%s wins\n", r1.time() < r2.time() ? "one" : "two");
    }
}

Answer 4

我不知道完整的上下文，但是闭包（即Guava的Function实现）和实用程序类中定义的实现可能是一个例子。

然而，在搜索了一段时间之后，我还没有在Guava本身找到匿名闭包示例。

在静态方法中定义内部类的目的是什么？

4 个答案: