Java：使用局部变量的匿名内部类

Question

如何在我的匿名内部子类中获取传递给此方法的 userId 值？

public void doStuff(String userID) {
    doOtherStuff(userID, new SuccessDelegate() {
        @Override
        public void onSuccess() {
            Log.e(TAG, "Called delegate!!!! "+ userID);
        }
    });
}

我收到此错误：

无法引用不同方法中定义的内部类中的非最终变量 userID

我很确定我不能将其分配为最终变量，因为它是一个具有未知值的变量。我听说这种语法确实以某种方式保留了范围，所以我认为一定有一个我不太了解的语法技巧。

Answer 1

正如这里其他人所说，局部变量必须是最终的才能被内部类访问。

这（基本上）是为什么......如果您编写以下代码（很长的答案，但是在底部，您可以获得简短的版本:-)：

class Main
{
    private static interface Foo
    {
        void bar();
    }

    public static void main(String[] args)
    {
        final int x;
        Foo foo;

        x = 42;
        foo = new Foo()
        {
            public void bar()
            {
                System.out.println(x);
            }
        };

        foo.bar();
    }
}

编译器大致如下翻译：

class Main
{
    private static interface Foo
    {
        void bar();
    }

    public static void main(String[] args)
    {
        final int x;
        Foo foo;

        x = 42;

        class $1
            implements Foo
        {
            public void bar()
            {
                System.out.println(x);
            }
        }

        foo = new $1();
        foo.bar();
    }
}

然后是：

class Main
{
    private static interface Foo
    {
        void bar();
    }

    public static void main(String[] args)
    {
        final int x;
        Foo foo;

        x = 42;
        foo = new $1(x);
        foo.bar();
    }

    private static class $1
        implements Foo
    {
        private final int x;

        $1(int val)
        {
           x = val;
        }

        public void bar()
        {
            System.out.println(x);
        }
    }
}

和最后：

class Main
{
    public static void main(String[] args) 
    {
        final int x;
        Main$Foo foo;

        x = 42;
        foo = new Main$1(x);
        foo.bar();
    }
}

interface Main$Foo
{
    void bar();
}

class Main$1
    implements Main$Foo
{
    private final int x;

    Main$1(int val)
    {
       x = val;
    }

    public void bar()
    {
        System.out.println(x);
    }
}

重要的一点是将构造函数添加到 $1 的位置。想象一下，如果您可以这样做：

class Main
{
    private static interface Foo
    {
        void bar();
    }

    public static void main(String[] args)
    {
        int x;
        Foo foo;

        x = 42;
        foo = new Foo()
        {
            public void bar()
            {
                System.out.println(x);
            }
        };

        x = 1;

        foo.bar();
    }
}

您会期望 foo.bar() 会打印出 1，但实际上会打印出 42。通过要求局部变量为最终变量，就不会出现这种令人困惑的情况。

Answer 2

当然你可以将它指定为最终的 - 只需将该关键字放在参数的声明中：

public void doStuff(final String userID) {
   ...

我不确定你的意思是它是一个具有未知值的变量；最终的意思是，一旦将值分配给变量，就不能重新分配它。由于您没有在方法中更改 userID 的值，因此在这种情况下将其确定为最终值是没有问题的。

Answer 3

在 Java 8 中，这种情况发生了一些变化。您现在可以访问实际上是最终的变量。相关片段和示例来自 Oracle 文档（强调我的）：

但是，从 Java SE 8 开始，本地类可以访问本地
封闭块的变量和参数是最终的或
有效最终。

有效最终： 非最终变量或参数，其值在初始化后从未改变，因此实际上是最终的。

例如，假设变量 numberLength 未声明为 Final，并且您
在 PhoneNumber 中添加突出显示的赋值语句
构造函数：

电话号码（字符串电话号码）{
    数字长度 = 7; // 来自 Kobit：这将是突出显示的行
    字符串 currentNumber = 电话号码.replaceAll(
        正则表达式, "");
    if (currentNumber.length() == numberLength)
        格式化电话号码 = 当前号码；
    别的
        格式化电话号码 = null;
}

由于这个赋值语句，变量numberLength不是
不再有效地最终。结果，Java 编译器生成一个
错误消息类似于“从内部引用的局部变量”
类必须是最终的或有效的最终”，其中内部类
PhoneNumber 尝试访问 numberLength 变量：

if (currentNumber.length() == numberLength)

从 Java SE 8 开始，如果在方法中声明本地类，它
可以访问方法的参数。例如，您可以定义
PhoneNumber 本地类中的以下方法：

public void printOriginalNumbers() {
    System.out.println("原号码为 " + PhoneNumber1 +
        " 和 " + 电话号码2);
}

方法printOriginalNumbers访问参数
validatePhoneNumber

方法的 phoneNumber1 和 phoneNumber2

Answer 4

将其设为final 有什么问题吗？

public void doStuff (final String userID)

Answer 5

声明方法

public void doStuff(final String userID)

值需要是最终的，以便编译器可以确保它不会改变。这意味着编译器可以随时将值绑定到内部类，而不必担心更新。

该值在您的代码中没有更改，因此这是一个安全的更改。