最终修饰符的意外行为

Question

这是我的代码，

package alpha ;

class A1
{
    static class A11
    {
        private
            final // WHAT IS THE EFFECT OF THIS MODIFIER?
            void fun ( String caller )
            {
                System . out . println ( "A11:\t" + caller ) ;
            }
    }

    static class A12 extends A11
    {
        private void fun ( String caller )
        {
            super . fun ( caller + caller ) ;
        }
    }

    public static void main ( String [ ] args )
    {
        A12 a12 = new A12 ( ) ;
        a12 . fun ( "Hello" ) ;
    }
}

我发现无论有或没有 A1.A11 中的最终 mdifer，程序都会编译并运行。

我可以理解，如果没有final修饰符，A1.A12可以看到并因此覆盖fun方法。它是私有的，但它们位于同一类，因此不存在可见性问题。

我不明白为什么它与 Final 修饰符一起使用。是否应该禁止 A1.A12 中的覆盖？

这是带有最终修饰符的程序的输出

java alpha/A1
A11:    HelloHello

如果它只是忽略其他有趣的方法那么

1. 编译器不会抱怨超级引用
2. A11 不会出现在输出中

Answer 1

您的方法是私有的。

将它们的可见性更改为受保护以查看预期的行为，也就是说，仅当方法受保护、公共或默认可见性时，甚至存在重写的概念。

做这样的事情——

class A1
{
    static class A11
    {
        public
            final // WHAT IS THE EFFECT OF THIS MODIFIER?
            void fun ( String caller )
            {
                System . out . println ( "A11:\t" + caller ) ;
            }
    }

    static class A12 extends A11
    {
        public void fun ( String caller )
        {
            super . fun ( caller + caller ) ;
        }
    }

    public static void main ( String [ ] args )
    {
        A12 a12 = new A12 ( ) ;
        a12 . fun ( "Hello" ) ;
    }
}

现在会抛出编译时异常

fun(java.lang.String) in A1.A12 cannot override fun(java.lang.String) in A1.A11; overridden method is final

Answer 2

对于 public、protected 和包私有/默认访问方法，final 确实可以防止方法被重写。

但是，所有 private 方法都是“非虚拟”的，因此实际上是最终的。超类中的私有方法对派生类没有影响。您没有重写，只是忽略了基类中的方法。

JVM 所基于的第一版 Java 语言规范没有内部类或嵌套类，因此可以专门处理 private 方法。该语言的后续版本主要围绕 JVM 进行。

在字节码术语中，使用 private 方法rel="nofollow">invokespecial 而不是 invokevirtual。

不同包中默认的访问/包私有final方法也是相互独立的。在同一个包内可以相互覆盖，而 final 会有所不同。在不同的包中，匹配的方法不会相互覆盖。