Unexpected Behavior wrt the final modifier

This is my code

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" ) ;
    }
}

I have found that with or without the final mdifer in A1.A11 the program compiles and runs.

I can understand that with开发者_运维问答out the final modifier, A1.A12 can see and thus override the fun method. It is private but they are in the same class so there is no visibility issue.

I can not understand why it works with the final modifier. Should not the overriding in A1.A12 be prohibited?

This is the output of the program with the final modifer in place

java alpha/A1
A11:    HelloHello

If it was simply ignoring the other fun method then

1. would not the compiler have complained about the super reference
2. the A11 would not be in the output

Your methods are private.

Change their visibility to protected to see expected behavior, that is, only when the method is protected, public or default visibility, the concept of overriding even exists.

Doing something like this --

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" ) ;
    }
}

will now throw the compile-time exception

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

For public, protected and package private/default access methods, final does indeed prevent a method being overridden.

However, all private methods are "non-virtual", so effectively final. A private method in a superclass makes no difference to the derived class. You aren't overriding, it's just that the method in the base class is ignored.

First edition Java Language Spec which the JVM is based around had no inner or nested classes, so private methods could be dealt with specially. Later versions of the language are bent around the JVM.

In bytecode terms, private methods are called with the invokespecial instead of invokevirtual.

Default access/package private final methods in different packages are also independent of one another. Within the same package can override one another and final makes a difference. In different packages, the matching methods do not override one another.