My name
is
Jon Skeet

Dynamic dispatch and access level of a method

Consider the following classes:

public class A {
    public void foo() {
        System.out.println("A.foo()");
    }

    public void bar() {
        System.out.println("A.bar()");
        foo();
    }
}

public class B extends A {
    public void foo() {
        System.out.println("B.foo()");
    }

    public static void main(String[]
    args) {
        A a = new B();
        a.bar();
    }
}

The output of this code is A.bar() and then B.foo(). I've noticed that if I change the method foo()'s access level from public to private the output is: A.bar() and then A.foo().

Why?

If A.foo() is private, then it can't be overridden by a subclass - any other class should basically be unaware of the existence of private members. You can't override a member you can't "see".

From section 8.4.8.1 of the JLS:

An instance method m_C declared in or inherited by class C, overrides from C another method m_A declared in class A, iff all of the following are true:

...

One of the following is true:

m_A is public.

m_A is protected.

m_A is declared with package access in the same package as C, and either C declares m_C or m_A is a member of the direct superclass of C.

m_A is declared with package access and m_C overrides m_A from some superclass of C.

m_A is declared with package access and m_C overrides a method m' from C (m' distinct from m_C and m_A), such that m' overrides m_A from some superclass of C.

See more on this question at Stackoverflow