覆盖（非）静态类中的私有方法

Question

我有这个测试代码示例：

public class Test {

    private static class Test3 {

        private void print1() {
            System.out.println("1");
        }
    }
    private static class Test4 extends Test3 {

        private void print1() {
            System.out.println("2");
        }
    }

    public static void main(String[] args) {
        System.out.println("Overriden call to private method ----------------");
        OuterTest.Test1 test1 = new OuterTest.Test1();
        OuterTest.Test2 test2 = new OuterTest.Test2();
        OuterTest.Test1 test12 = new OuterTest.Test2();

        test1.invokeOverriden();
        test2.invokeOverriden();
        test12.invokeOverriden();

        System.out.println("Call to private method from parent class ----------------");

        test1.invokeNotOverriden();
        test2.invokeNotOverriden();
        test12.invokeNotOverriden();

        System.out.println(" Some magic ----------------");

        Test3 test3 = new Test3();
        Test4 test4 = new Test4();
        Test3 test34 = new Test4();

        test3.print1();
        test4.print1();
        test34.print1();
    }
}

class OuterTest {

    public static class Test1 {
        public void invokeOverriden() {
            print1();
        }
        public void invokeNotOverriden() {
            print1();
        }

        private void print1() {
            System.out.println("1");
        }
    }

    public static class Test2 extends Test1 {

        @Override
        public void invokeOverriden() {
            print1();
        }
        private void print1() {
            System.out.println("2");
        }
    }
}

首先，一切都像我认为的那样工作：

Overriden call to private method ----------------
1
2
2

然后，如果我调用未实现的父方法，继承的类的私有方法就会消失。 可以解释为“所有私有方法都是最终的并且对派生类隐藏”，因此invokeNotOverriden()对 Test2 类中的方法一无所知：

Call to private method from parent class ----------------
1
1
1

最后，在静态类中，当我调用非静态私有方法时，突然出现了一些魔法：

Some magic ----------------
1
2
1

我预计这里是1 2 2 。 为什么我错了？

Answer 1

你在some magic部分有1 2 1 ，因为私有方法是在没有多态性的情况下解析的，编译器创建对包含在声明的类型变量中的方法的调用，在你的情况下Test3 。 在Test3 print1声明为非私有的（因此，在Test4因为它被禁止收紧方法的访问修饰符）并查看多态的作用，因此您将得到预期的1 2 2 。

---

考虑更短的例子：

class Test {

    private static class Test3 {
        private void print1() {
            System.out.println("non-polymorphic 1");
        }

        void polymorphic() {
            System.out.println("polymorphic 1");
        }
    }

    private static class Test4 extends Test3 {
        private void print1() {
            System.out.println("non-polymorphic 2");
        }

        void polymorphic() {
            System.out.println("polymorphic 2");
        }
    }

    public static void main(String[] args) {
        Test4 t4 = new Test4();
        t4.print1();
        t4.polymorphic();

        System.out.println("======");

        Test3 t34 = new Test4();
        t34.print1();
        t34.polymorphic();
    }
}

---

澄清...我对这个答案的评论：多态对于访问数据字段无效，仅对方法有效。 考虑：

private static class Test3 {
    int i = 1;
}

private static class Test4 extends Test3 {
    int i = 2;
}

public static void main(String[] args) {
    Test4 t4 = new Test4();
    System.out.println(t4.i);

    System.out.println("======");

    Test3 t34 = new Test4();
    System.out.println(t34.i);
}

尽管i声明为非私有，但t34.i值为1 。

Answer 2

私有方法仅适用于声明它们的类，而不适用于该类的子类。

如果您希望在子类中使用父类中的方法，则必须将其设置为protected 。

在您的最后一个案例中，您强制转换为 Test3，因此出于所有意图和目的，该类认为它是 Test3 并调用 Test3 的打印方法。 静态实例不是强制转换的（你总是用它们的限定名来调用它们），所以它们总是调用自己的私有方法。

Answer 3

就像你说的，你不能覆盖private方法，让它protected