1. abstract class Person
   
2. {
   
3.         public Person()
   
4.         {
   
5.         this.empt();
   
6.         }
   
7.         public abstract void empt();
   
8. }
   
9. class Students extends Person
   
10. {
    
11.         private int score = 20;
    
12.         public Students(int score)
    
13.         {
    
14.         this.score = score;
    
15.         }
    
16.         public void empt()
    
17.         {
    
18.                 System.out.println(" score = "+ score);
    
19.         }
    
20. }
    
21. class Demo
    
22. {
    
23.         public static void main(String[] args)
    
24.         {
    
25.                 Person per = new Students(6);
    
26.         }
    
27. }
    
28. 
    

复制代码

为什么没有回答这个呢。嘿嘿。我来。  说的不好。见谅。

我的理解是在new Students（6）时，在执行子类构造方法前会先执行父类构造方法，也就是先要执行empt（）方法输出score的值，因为score还没经过赋值，所以输出的是默认初始值0，而此后才会执行子类的构造代码块和构造方法，虽然score被赋了新值但因为不在调用empt所以不会再打印了。

abstract class Person
{
        public Person()
        {
                        this.empt();
        }
        public abstract void empt();
}
class Students extends Person
{
        private int score = 20;
        public Students(int score)
        {
                         super();  //这句代码是隐藏的，系统自动执行，表示调用父类的空参数构造函数
                                                //所以当你创建对象Person per = new Students(6);的时候调用的是这个构造方法
                                                //        但是要先执行super（）语句所以就会先执行父类的构造方法
                                                //        再通过父类的构造方法调用empt（）方法 来完成输出语句，而这个时候
                                                //还没有执行到this.score = score; 这句代码，所以你6根本就没有给score
                                                //赋值的，而对象中的成员变量都会有一个默认的初始化称为隐士初始化
                                                //显然先输出的是隐士初始化的结果 就是0；给你添加三句代码，就容易判断
                                                //结果是  0  aaa  6   bbb  从结果可以看出  第一次的子类的empt就没有执行
                                                //而通过父类的引用调用的父类中的empt()被子类覆盖的empty方法。
                                                //感觉最后这块分析的不是很清晰，不知道该怎么说，求高手帮忙分析下这块，该怎么
                                                //表达？
                         this.score = score;
                        System.out.println("aaa");
                         empt();
                         System.out.println("bbb");
        }
        public void empt()
        {               
                System.out.println(" score = "+ score);
                }
}

class Demo
{
        public static void main(String[] args)
        {
                Person per = new Students(6);
        }
}

因为每个子类构造函数的第一行都有一条隐式语句super（）；所以 new Students(6);调用父类的Person（）；
子类复写了父类的empt();所以Person（）执行子类的empt();此时输出的score是默认初始化值0，（score = 20；20是显示初始化值，此时并未加载到内存中）；
输出结果为 ：score = 0

class Students extends Person

{

        private int score = 20;

        public Students(int score)

        {

        this.score = score;
        this.empt();//楼主加上该条语句就应该能体会到每个子类构造函数的第一行都有一条隐式语句super（）；当初始化子类对象时首先初始化一个父类对象
        }

        public void empt()

        {

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

        }

}

1、创建student对象调用student的构造函数，
2、student构造函数的第一句默认包含了一句super（），即调用父类空参数构造函数，也就是this.score = score;执行之前会跳转到person的空参数构造函数，
3、person的构造函数调用person类自己的empt()方法。person类的构造方法执行完毕，语句跳转回student构造函数执行this.score = score
4、student类的构造函数执行完毕，student对象创建完成

abstract class Person
{
        public Person()
        {
         System.out.println("人");
        this.empt();
        }
        public abstract void empt();
}
class Students extends Person
{
        private int score = 20;
        public Students(int score)
        {
        
                System.out.println(this.score);
                this.score = score;
        }
        public void empt()
        {
                System.out.println(" score = "+ score);
        }
}
class Demo
{
        public static void main(String[] args)
        {
                Person per = new Students(6);
        per.empt();
        }
}
经过楼上几个回答，我对代码修改了一下，这就看得明白了，也知道是怎么一回事了。谢谢大家