Java 可以覆盖私有方法吗

让我们首先考虑以下Java程序，作为覆盖或运行时多态性的一个简单例子。

class Base {
  public void fun() {
     System.out.println("Base fun");    
  }
}
   
class Derived extends Base {
  public void fun() {  // overrides the Base's fun()
     System.out.println("Derived fun");    
  }
  public static void main(String[] args) {
      Base obj = new Derived();
      obj.fun();
  } 
}

基类引用’obj’指的是一个派生类对象（见表达式 “Base obj = new Derived()”）。当对obj调用fun()时，是根据被引用对象的类型来调用的，而不是根据引用。

预测以下程序的输出结果， 是否可以用私有方法覆盖？

class Base {
  private void fun() {
     System.out.println("Base fun");    
  }
}
   
class Derived extends Base {
  private void fun() {
     System.out.println("Derived fun");    
  }
  public static void main(String[] args) {
      Base obj = new Derived();
      obj.fun();
  } 
}

我们得到的编译器错误是 “fun()在基类中有私有访问权”（见此）。所以编译器试图调用基类函数，而不是派生类，这意味着fun()没有被重载。

一个内类可以访问其外类的私有成员。如果我们扩展一个内类并在内类中创建fun()呢？
一个内类可以访问其外类的私有成员，例如在下面的程序中，内类的fun()访问了私有数据成员msg，这对编译器来说是好的。

/* Java program to demonstrate whether we can override private method
   of outer class inside its inner class */
class Outer {
     private String msg = "GeeksforGeeks";
     private void fun() {
          System.out.println("Outer fun()");
     }
 
     class Inner extends Outer {
         private void fun()  {
               System.out.println("Accessing Private Member of Outer: " + msg);
         }
     }
 
     public static void main(String args[])  {
 
          // In order to create instance of Inner class, we need an Outer
          // class instance. So, first create Outer class instance and then
          // inner class instance.
          Outer o = new Outer();
          Inner  i   = o.new Inner();
           
          // This will call Inner's fun, the purpose of this call is to
          // show that private members of Outer can be accessed in Inner.
          i.fun(); 
 
          // o.fun() calls Outer's fun (No run-time polymorphism).
          o = i;
          o.fun();
     }
}

输出:

Accessing Private Member of Outer: GeeksforGeeks
Outer fun()

在上面的程序中，我们创建了一个外层类和一个内层类。我们从Outer扩展了Inner，并在Outer和Inner中都创建了一个方法fun()。如果我们观察我们的输出，那么很明显，方法fun()没有被重载。之所以如此，是因为 私有方法是在编译时绑定的，是引用变量的类型–而不是它所引用的对象的类型–决定了要调用的方法。 顺便提一下，由于静态绑定，私有方法在性能上可能会更好（与非私有和非最终方法相比）。

与C++的比较
1) 在Java中，内层类被允许访问外层类的私有数据成员。这一行为与C++相同（见此）。

2）在Java中，声明为私有的方法永远不能被重写，事实上它们在编译时被绑定。这种行为与C++不同。在C++中，我们可以有虚拟的私有方法（见此）。