相关疑难解决方法(0)

VarHandle显示以下错误 -

Exception in thread "main" java.lang.NoSuchMethodError: VarHandle.compareAndSet(VarHandleExample,int,int)void
    at java.base/java.lang.invoke.MethodHandleNatives.newNoSuchMethodErrorOnVarHandle(MethodHandleNatives.java:492)
    at java.base/java.lang.invoke.MethodHandleNatives.varHandleOperationLinkerMethod(MethodHandleNatives.java:445)
    at java.base/java.lang.invoke.MethodHandleNatives.linkMethodImpl(MethodHandleNatives.java:378)
    at java.base/java.lang.invoke.MethodHandleNatives.linkMethod(MethodHandleNatives.java:366)
    at j9.VarHandleExample.update(VarHandleExample.java:23)
    at j9.VarHandleExample.main(VarHandleExample.java:14)

我的计划是:

import java.lang.invoke.MethodHandles;
import java.lang.invoke.VarHandle;

public class VarHandleExample {
    public int publicTestVariable = 10;
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {
        VarHandleExample e= new VarHandleExample();
        e.update();
    }
    public void update() throws NoSuchFieldException, IllegalAccessException {
        VarHandle publicIntHandle = MethodHandles.lookup()
              .in(VariableHandlesTest.class)
              .findVarHandle(VarHandleExample.class, "publicTestVariable", int.class);
        publicIntHandle.compareAndSet(this, 10, 100); // CAS
    }
}

根据我的理解 anonymous classes,总是final:

这已在具体提到 JLS 15.9.5

但是,当我运行以下代码来检查它是否显示Inner该类不是final.

    public class Test{
    static class A<T> {
    }
    public static void main(String arg[]) {
        A<Integer> obj = new A() {
        };
        if ((obj.getClass().getModifiers() & Modifier.FINAL) != 0) {
            System.out.println("It is a final  " + obj.getClass().getModifiers());
        } else {
            System.out.println("It is not final " + obj.getClass().getModifiers());
        }
    }
}

上述计划的输出是:

It is not final 0

请清除我的疑问,因为我无法理解这种行为.

根据JLS:

15.9.5匿名类声明编译器自动从类实例创建表达式派生匿名类声明.

匿名类永远不是抽象的(第8.1.1.1节).匿名类始终是内部类(第8.1.3节); 它永远不会是静态的(§8.1.1,§8.5.2). 匿名类总是隐式最终的(§8.1.1.2).

这似乎是一个特定的设计决定,所以它有可能有一些历史.

如果我选择这样的课程:

SomeType foo = new SomeType() {
    @Override
    void foo() {
        super.foo();
        System.out.println("Hello, world!");
    }
};

如果我选择的话,为什么我不允许再次继承它？

SomeType foo = new SomeType() {
    @Override
    void foo() {
        super.foo();
        System.out.println("Hello, world!");
    }
} {
    @Override
    void foo() {
        System.out.println("Hahaha, no super foo for you!");
    }
};

我不是说我一定想要,或者甚至可以想到我会这样做的原因.但我很好奇为什么会这样.

我想知道为什么java中的匿名内部类被标记为final.我已阅读这篇 文章,但无法理解这个概念.甚至JLS指定所有匿名内部类都是隐式最终的.有人可以详细说明这个概念吗？