class A{
int x;
public A(){
this.print() ;
}

public void print(){
System.out.println("x = " + x) ;
}
};
class B extends A{
int x = 100 ;

public B(int x){

super();
this.x = x ;

}
public void print(){
System.out.println("x = " + x) ;
}


};
public class TestJava{
public static void main(String args[]){
B a = new B(10) ;

}
};

你说的执行到执行不到很不清楚，不过这里教你分析的方法

1. class A
   
2.         {
   
3.                 int x;
   
4. 
   
5.                 public A()
   
6.                         {
   
7.                                 System.out.println("bbbbbbbbb");
   
8.                                 this.print();
   
9.                         }
   
10. 
    
11.                 public A(int x)                                  2、 从B中跳过来
    
12.                         {
    
13.                                 this.print();                                      3、this是B中的this，B中有同名同参的方法覆盖了父类的方
    
14. 
    
15.                                 System.out.println("aaaaa");
    
16.                         }
    
17. 
    
18.                 public void print()
    
19.                         {
    
20.                                 System.out.println("x = " + x);        4、执行打印
    
21.                         }
    
22.         }
    
23. 
    
24. class B extends A
    
25.         {
    
26.                 int x = 100;
    
27. 
    
28.                 public B(int m)
    
29.                         {
    
30. 
    
31.                                 super(m);                                          1、到这一步要跳到A类里面的构造方法中，都可以执行到，或者super（）都行
    
32.                                 this.x = m;
    
33.                                 System.out.println(x);                       5、最后执行这个 这个x是B中的变量，x的值是实例化的时候传递进来的值，也就是10
    
34. 
    
35.                         }                                                      
    
36. 
    
37.                 public void print()                     
    
38. 6、执行，但是因为 int x 还没有初始化，所以打印的是系统默认值
    
39.                         {
    
40.                                 System.out.println("x = " + x);
    
41.                         }
    
42.         }
    
43. 
    
44. class TestJava
    
45.         {
    
46.                 public static void main(String args[])
    
47.                         {
    
48.                                 B a = new B(10);
    
49. 
    
50.                         }
    
51.         }

复制代码

我看了半天都没看懂你写的什么，问问题也你简单吧问题整理下发啊，至少把2个类之间间隔开啊，本来就没书写格式了，连类都写在一起，那个叫难看啊～～～～～～～～～～～～汗～～～～～～～
我看了很久，大概猜了些，你这写得～～～
首先2点 ：一：super意思是使用该函数的该对象的替代的意思。简单来说就是super是个对象。一个对象后面你看到过（）么？？那是函数才能带的参数（）啊。
super(); 你的这个是什么？是个函数？？SUPER是一个对象啊，怎么可能又变成函数。
二：
public static void main(String args[]){
B a = new B(10) ;

}
你的主函数只建立了一个对象，但是没有任何输出，就算什么都对了，你CMD上能看到效果？？？

1. class A
   
2. {
   
3.         int x;
   
4.         public A()//第五步：初始化父类的构造方法
   
5.         {
   
6.                 this.print();  //第六步：又用到了this关键字，调用了本身的print()方法
   
7.         }
   
8.         public void print()
   
9.         {
   
10.                 System.out.println("x = " + x) ;//第七步：由于x是成员变量有初始化值，所以会输出x=0
    
11.         }
    
12. };
    
13. 
    
14. class B extends A
    
15. {
    
16.         int x = 100 ;
    
17.         public B(int x)//第三步：先执行子类的构造方法初始化，因为子类的构造方法默认的第一行会有super();给父类进行初始化
    
18.         {
    
19.                 super();//第四步：给父类的空参数进行初始化
    
20.                 this.x = x ;//第八步：父类初始化后将你传入的参数赋值给x;结束。。。。
    
21.         }
    
22.         public void print()
    
23.         {
    
24.                 System.out.println("x = " + x) ;
    
25.         }
    
26. };
    
27. 
    
28. public class TestJava
    
29. {
    
30.         public static void main(String args[])//第一步：JVM先从main入手
    
31.         {
    
32.                 B a = new B(10) ;//第二步：执行这里的时候，因为用到了new，所以JVM将B.class加载到内存，然后对类B初始化
    
33.         }
    
34. };//首先你对类的定义根本不了解，为什么这里要加分号呢？？？注意这里不需要;

复制代码