class Super {
int i = 0;
public Super(String a) {
  System.out.println("A");
  i = 1;
}
public Super() {
  System.out.println("B");
  i += 2;
}
}
class Other_Demo extends Super {
public Other_Demo(String a) {
  // super();
  System.out.println("C");
  i = 5;
}
public static void main(String[] args) {
  int i = 4;
  Super d = new Other_Demo("A");
//d.i这个i访问的应该是父类中的i，但是打印是子类中的i,为什么?变量不是不存在覆盖的吗？
  System.out.println(d.i);
}

输出的的确是父类中的 i 的值。你看你的变量定义，你只在主函数中和父类中有定义变量i，子类中根本没有定义i变量。所以子类执行语句的时候，在子类中，i = 5; 其实是父类中的变量 i 赋值为5，所以你在输出，调用d.i的时候输出的是父类中定义的i的值。
你要想看到你变量不能覆盖的效果的话，代码如下：

1. /**
   
2. *
   
3. */
   
4. package A;
   
5. 
   
6. 
   
7. class Super
   
8. {
   
9.   int i = 0;
   
10.   public Super(String a)
    
11.   {
    
12.      System.out.println("A");
    
13.      i = 1;
    
14. }
    
15.   public Super()
    
16.   {
    
17.     System.out.println("B");
    
18.     i += 2;
    
19.   }
    
20. }
    
21. class Other_Demo extends Super
    
22. {
    
23.      public Other_Demo(String a)
    
24.      {
    
25.         // super();
    
26.         System.out.println("C");
    
27.         int i = 5;  //这个是跟你的代码不同的地方。 在子类中定义一下变量i。只有父类和子类中有相同的变量的时候才会运行父类中的变量。
    
28.       }
    
29.      public static void main(String[] args)
    
30.      {
    
31.         Super d = new Other_Demo("A");
    
32.            //d.i这个i访问的应该是父类中的i，但是打印是子类中的i,为什么?变量不是不存在覆盖的吗？
    
33.         System.out.println(d.i);
    
34.      }
    
35. }

复制代码

class Super {
int i = 0;
public Super(String a) {
   System.out.println("A");
   i = 1;
}
public Super() {
   System.out.println("B");
   i += 2;
}
}
class Other_Demo extends Super {
public Other_Demo(String a) {
   // super();
   System.out.println("C");
   i = 5;
}
public static void main(String[] args) {
   int i = 4;
   Super d = new Other_Demo("A");
   //d.i这个i访问的应该是父类中的i，但是打印是子类中的i,为什么?变量不是不存在覆盖的吗？
  System.out.println(d.i);
}
首先我要告诉你，在具有继承关系的两个类中，子类自能调用父类变量，变量是不能重写的，在子类中调用父类的变量时，需要使用到super关键字，或者是用this，而你public Other_Demo(String a) {
   // super();
   System.out.println("C");
   i = 5;
}这一串代码中，i会直接报错的，因为你的从哪里来，是一个没用定义的动，如果要改，可以改成，super.i=5(注意super是系统关键字)或者是this.i=5，这样改了之后public static void main(String[] args) {
   int i = 4;
   Super d = new Other_Demo("A");
//d.i这个i访问的应该是父类中的i，但是打印是子类中的i,为什么?变量不是不存在覆盖的吗？
  System.out.println(d.i);
}main方法就会打印5

d.i是父类的,子类继承了它,当执行子类的构造,自动调用父类的无参构造,i的值变成了2,然后执行子类自己的构造,将i的值变成了5,所以输出的是5.
class Super {
        int i = 0;
        public Super(String a) {
                System.out.println("A");
                i = 1;
        }
        public Super() {
                System.out.println("B");
                i += 2;
        }
       
}
class Other_Demo extends Super {
        public Other_Demo(String a) {
                // super();
                System.out.println("C");
                i = 5;//这个i是从父类继承的
        }
}
class Test {
        public static void main(String[] args) {
                int i = 4;
                Super d = new Other_Demo("A");
                //
                System.out.println(d.i);
        }
}

package staticDemo;
class Super {
int i = 0;
public Super(String a) {
   System.out.println("A");
   i = 1;
}
public Super() {
   System.out.println("B");           
   i += 2;
}
}
class Other_Demo extends Super {
public Other_Demo(String a) {
   // super();                          
   System.out.println("C");
   i = 5;
}
public static void main(String[] args) {
   int i = 4;
   Super d = new Other_Demo("A");  //  一new子类对象，子类就找到自己构造函数，子类的构造函数前有引示的super()，如果父类构造函数已经构造了，是它需要的，
                                   //它就直接拿来用，如果是不需要的，子类再自己构造。这样就避免了重复构造。
   
//d.i这个i访问的应该是父类中的i，但是打印是子类中的i,为什么?变量不是不存在覆盖的吗？
   System.out.println(d.i);
}
}