访问内部匿名类成员

Question

除了使用反射来访问匿名内部类的成员之外，还有其他方法吗？

Answer 1

匿名内部类有类型但没有名称。

您可以访问未由指定超类型定义的字段。 然而，一旦分配给命名类型变量，该接口就会丢失。

显然，您可以从内部类本身访问这些字段。 添加代码的一种方法是通过实例初始化程序：

final AtomicInteger y = new AtomicInteger();
new Runnable() {
    int x;
    {
        x = 5;
        doRun(this);
        y.set(x);
    }
    public void run() {
        ... blah ...
    }
};

匿名内部类表达式返回的值具有匿名类型，因此您有一次机会在类本身之外使用它：

final int y = new Runnable() {
    int x;
    {
        x = 5;
        doRun(this);
    }
    public void run() {
        ... blah ...
    }
}.x;

您还可以通过类似于以下声明的方法传递它： :

<T extends Runnable> T doRun(T runnable);

Answer 2

您可以使用本地类而不是匿名类。 看：

public class Test {
    public static void main(String... args) {
        class MyInner {
            private int value = 10;
        }

        MyInner inner = new MyInner();
        System.out.println(inner.value);
    }
}

不过，您只能在方法主体中引用 MyInner 类型。 因此，在方法之外，您将无法使用未在其超类（本例中为 java.lang.Object ）或接口中声明的字段/方法。

Answer 3

public class AccessAnonymous {
    private Runnable runnable; // to have instance of the class

    public static void main(String[] args) throws Exception {
        AccessAnonymous a = new AccessAnonymous();
        a.a(); // init field

        Class clazz = a.runnable.getClass();
        Field field = clazz.getDeclaredField("i");
        field.setAccessible(true);

        int int1 = field.getInt(a.runnable);
        System.out.println("int1=" + int1);
    }

    public void a() {
        runnable = new Runnable() {
            private int i = 1;

            public void run() {
                i = 90;
            }

        };
        runnable.run();// change value
    }
}

Answer 4

对于匿名类，在类造成的混乱和匿名类的便利性之间也需要权衡。 复杂的类很少属于匿名类，而是属于命名的私有内部类。

在大多数匿名类中，我们只需要“喂食”知识并且可以在构造时完成。
在一些匿名类（例如，返回值载体）中，我们也关心一个返回值。

众所周知，数据成员不应该直接访问，而应该使用 getter setter 来访问。 如果您发现自己添加了很多 getter 和 setter，那么您可能做错了什么，并且不应该使用匿名类。

Answer 5

如果它实现接口或扩展现有类，则可以访问接口或基类中定义的成员。

Answer 6

Fooz 先生是对的，只是接口只能定义常量成员。 最好的方法是将 getter/setter 方法添加到您的界面，然后使用它们来获取您的值。 但是对于每个匿名类，您都必须定义这些方法（有点痛苦）。

Answer 7

如果您想要可读、可维护的代码，请不要使用匿名类。 如果您使用匿名类并且想要可读、可维护的代码，那么当您需要访问该内部类中的元素时，请勿使用匿名类。 有很多方法可以做到这一点，但我恳求您不要使用任何这些技巧。 可读性胜过所有其他美德。

Answer 8

这个问题已经有15年历史了，但我认为还有另一种方法可以做到这一点！

该示例涉及为 MyService 编写单元测试：

public class MyService {

    public Result doSomething() {
        Result result = new Result();
        result.setToday(today();
        return result;
    }

    // not private but package-private so it can be overridden
    Date today() {
        return new Date();
    }
}

以下是单元测试：

public class MyServiceTest {

    private Date capturedToday;

    // anonymous inner class
    private final MyService testSubject = new MyService() {

        @Override
        Date today() {
            // capture the Date instance created by MyService
            Date today = super.today();
            MyServiceTest.this.capturedToday = today;
            return today;
        }
    };

    @Test
    void myTest() {

        MyResult result = testSubject.doSomething();            
        assertSame(capturedToday, result.getToday());

在此示例中，MyService 在内部创建一个 Date 并根据其结果设置它。 为了检查这个逻辑，我创建了一个匿名内部类，它在创建实例时捕获实例并将其存储在 captureToday 字段中：

MyServiceTest.this.capturedToday = today;

此语法允许内部类访问其外部类的字段，从而公开其值。

Answer 9

如果使用 var，您可以从声明的块（或子块）内部访问匿名类的成员。 示例：

public static void main(String[] args) {
    var annon = new Object() {
        int field;
        void method() {
            System.out.println("method called with field=" + field);
        }
    };

    annon.field = 123;
    annon.method();  // prints "method called with field=123"
}

如果成员被声明为静态，这甚至可以工作。

如果我们声明了 Object annon = new Object() { ... 我们会得到编译错误，因为 Object 没有任何 field 或 <代码>method() 成员。