class Demo
{
class A
{
  private void print()
  {
   System.out.println("A、private()");
  }
}
class B extends A
{
  private void print()
  {
   System.out.println("B、private()");
  }
}
public static void main(String[] args)
{
  B b = new B();
}
}
编译错误：Noname7.java:19: 无法从静态上下文中引用非静态 变量 this
                B b = new B();
这是什么意思？A中没有定义静态变量啊，这个this怎么冒出来的，怎么理解这个错误提示？我将main语句中的static删除后编译通过
但是运行Demo后抛出异常Exception in thread "main" java.lang.NoSuchMethodError:main
               
于是乎，我修改代码 定义一个类C，在C中对B实例化并调用B的private方法                     
class Demo
{
class A
{
  private void print()
  {
   System.out.println("A、private print()");
  }
}
class B extends A
{
  private void print()
  {
   System.out.println("B、private print()");
  }
}
public void ab()
{
  B b = new B();
  b.print();
  System.out.println("Demo、 void ab()") ;
}
public static  void main(String[] args)
{
  Demo d = new Demo();
  d.ab();
}
}              
结果：打印：B、private
                     Demo、void ab(); 这是不是可以证明父类的private其实是可以被子类重写的，但是却不能在静态的函数中对子类进行实例化呢？                 
                     

我的理解如下:
首先你要搞清楚 main()不是Demo类里的成员方法,它只是程序的入口,所以你在直接调用Demo的内部类A/B时.它无法找到this.
可以这么改写:new Demo().new B();   编译报错解决
实际上你第二种写法同上

首先静态方法不能调用非静态方法我想非静态内部类也一样。
main方法先于Demo类加载。
main方法不属于Demo本身,所以私有内部类是不能被外部方法直接调用的。
把main方法的static关键字去掉就不是入口函数了，所以会报找不到入口错误；
父类的private被子类重写的只限与这两个类在同一各类中吧

1. class Demo
   
2. {
   
3. class A
   
4. {
   
5.   private void print()
   
6.   {
   
7.    System.out.println("A、private print()");
   
8.   }
   
9. }
   
10. class B extends A
    
11. {
    
12.   private void print()
    
13.   {
    
14.    System.out.println("B、private print()");
    
15.   }
    
16. }
    
17. public void ab()
    
18. {
    
19.   B b = new B();
    
20.   b.print();
    
21.   System.out.println("Demo、 void ab()") ;
    
22. }
    
23. public static  void main(String[] args)
    
24. {
    
25.   Demo d = new Demo();
    
26.   d.ab();
    
27. }
    
28. }

复制代码

1.纠正你的测试代码的错误，因为你是要测试子父类继承的内容，所以你要把子父类及其用来测试的主函数所在的类要分开。
2.为什么你的代码可以实现呢，因为你将类A类B都定义在了主函数所在的类中，那么类A和类B就是主函数的2个内部类，外部类的方法是可以访问内部类中的私有成员的，只要建立内部类对象就可以。你的测试代码已经不是在做子父类了，变成外部类和内部类的关系了。
3.正确的做法就是将类A类B移出主函数所在类，你再试试子类是不可以继承父类中被private修饰的变量或方法的。

你的代码错在创建内部类对象那。创建内部类对象：外部类名称.内部类名称 a=new 外部类（）.new 内部类（）;这是内部类非静态时创建方法。
                                                               外部类名称.内部类名称 a=new 外部类.内部类（）;这是内部类为静态时创建方法。下面是修改后的代码。
为什么你下面那段代码是对的呢？
第一：第一段代码是在主函数中建立的对象，根据静态只能访问静态，所以在主函数中建立非静态内部类对象时要像在外部其他类中建立内部类对象一样建立。方法如上。
         如果你不改在主函数建立对象的方法你可以把内部类改为静态，如下：

1. class Demo{
   
2.         static class A{
   
3.           private void print(){
   
4.                   System.out.println("A、private()");
   
5.           }
   
6.         }
   
7.         static class B extends A{
   
8.           private void print(){
   
9.            System.out.println("B、private()");
   
10.           }
    
11.         }
    
12.         public static void main(String[] args){
    
13.           B b = new B();
    
14.           b.print();
    
15.         }
    
16. }

复制代码

第二：第二段代码因为又多定义一个非静态的外部类函数，所以这个函数持有外部类的引用，所以他要访问内部类中的成员时是可以直接建立
        内部类对象的——方法：内部类 x=new 内部类（）；例子如你第二段代码。
下面只是改了一下在主函数中建立对象的那句代码。你测试感悟一下，希望帮到你。

1. class Demo{
   
2.         class A{
   
3.           private void print(){
   
4.                   System.out.println("A、private()");
   
5.           }
   
6.         }
   
7.         class B extends A{
   
8.           private void print(){
   
9.            System.out.println("B、private()");
   
10.           }
    
11.         }
    
12.         public static void main(String[] args){
    
13.           Demo.B b = new Demo().new B();
    
14.           b.print();
    
15.         }
    
16. }
    
17. //还有就是“结果：打印：B、private
    
18. 
    
19.                      Demo、void ab(); 这是不是可以证明父类的private其实是可以被子类重写的，但是却不能在静态的函数中对子类进行实例化呢？ ”     这句话是错误的，只要被private封装的方法，在其他类中是不能看到的。至于子类是否继承了父类的private修饰的方法，这个是可以的，但是子类不能使用，也就不能覆写。
    

复制代码

恩，谢谢！我再去多写一些程序验证一下，应该没什么问题了

论坛知识和能人无处不在，多逛逛对知识更巩固