大神给解释下这道程序的运行结果

袁梦希

本帖最后由 kimi 于 2013-5-31 01:11 编辑

class Person
{
public Person(){
this.print();
}
public void print(){}
}
class Student extends Person
{
private int score=90;
public Student(int score){
this.score = score;
}
public void print(){
System.out.println("score="+this.score);
}
}
public class Test
{
public static void main(String[] args){
Student stu = new Student(98);
}
}

复制代码

运行结果是0，这是为嘛啊

江南雨 · 江南雨

呵呵，我也是菜鸟。。确实好奇怪，我认什么都没有输出

画饼 · 画饼

stu.print(); 调用方法，就可以打印出，你要的数字

画饼 · 画饼

说Student继承了父类的构造方法。或者有一个父类的对象。在new Student的时候，你打印出来的值。是父类那个构造方法的prin。应该是先在Student对象里面创建了一个父类对象。或者先调用了父类的构造方法，而prin方法被你重写了的原因。。个人猜测。基础不牢。各位勿喷。

喜欢流浪 · 喜欢流浪

class Person
{
public Person(){
this.print();
}
public void print(){}
}
class Student extends Person
{
private int score=90;
public Student(int score ){
this.score = score;
System.out.println("score="+this.score);
}
public void print(){
System.out.println("score="+this.score);
}
}
public class Test
{
public static void main(String[] args){
Student stu = new Student(98);
}
}

复制代码

楼主在 Student() 下插入一句System.out.println("score="+this.score);
你在看结果
score=0
score=98
先打印的是score= 0 在结合楼上解释，你肯定会更明白的！你打印的是重写之后的父，也就是Person()下print，当然为0 了

王靖远 · 王靖远

画饼发表于 2013-5-26 12:51
说Student继承了父类的构造方法。或者有一个父类的对象。在new Student的时候，你打印出来的值。是父类那个 ...

正解。new的对象还没有调用方法。打印的0是new对象时调用父类构造函数打印出来的。

江南雨 · 江南雨

画饼发表于 2013-5-26 12:51
说Student继承了父类的构造方法。或者有一个父类的对象。在new Student的时候，你打印出来的值。是父类那个 ...

其实我想问一下的是，创建子类的对象时是会执行父类的构造方法，即会创建父类的对象，那构造方法（person构造方法）里面的this代表的是student的一个对象还是person的一个对象？

江南雨 · 江南雨

王靖远发表于 2013-5-26 14:35
正解。new的对象还没有调用方法。打印的0是new对象时调用父类构造函数打印出来的。 ...

new的对象还没有调用方法，你指的方法是？

王靖远 · 王靖远

江南雨发表于 2013-5-26 15:13
new的对象还没有调用方法，你指的方法是？

指的是，子类复写的print方法。

First · First

本帖最后由 First 于 2013-5-26 15:28 编辑

这是一个对象的初始化问题。
class A {
static int a1 = 1;
int a2 = 2;
A(){
System.out.println("基类A的构造函数：init A");
System.out.println();
}
static {
a1 = 10;
System.out.println("基类A的静态代码块：static block a1 = " + a1);
}
{
a2 = 20;
System.out.println("基类A的代码块：block a2 = " + a2);
}
static void showA(){
System.out.println("static showA = " + a1);
}
}
class B extends A{
static int b1 = getB1();
int b2 = getB2();
B(){
System.out.println("父类B的构造函数：init B");
System.out.println();
}
static {
b1 = 110;
System.out.println("父类B的静态代码块：static block b1 = " + b1);
}
{
b2 = 220;
System.out.println("父类B的代码块：block b2 = " + b2);
}
static void showB(){
System.out.println("static showB = " + b1);
}
static int getB1(){
System.out.println("父类B的静态成员初始化赋值函数：static getB1");
return 11;
}
int getB2(){
System.out.println("父类B的成员初始化赋值函数：getB2");
return 22;
}
}
class C extends B{
static int c1 = getC1();
int c2 = getC2();
C(){
System.out.println("子类C的构造函数：init C");
}
static {
c1 = 1110;
System.out.println("子类C的静态代码块：static block c1 = " + c1);
System.out.println();
}
{
c2 = 2220;
System.out.println("子类C的代码块：block c2 = " + c2);
}
static void showC(){
System.out.println("static showC = " + c1);
}
static int getC1(){
System.out.println("子类C的静态成员初始化函数：static getC1");
return 111;
}
int getC2(){
System.out.println("子类C的成员初始化函数：getC2");
return 222;
}
}
public class Demo
{
public static void main (String[] args){
C c = new C();
}
}
/* 输出结果：
基类A的静态代码块：static block a1 = 10
父类B的静态成员初始化赋值函数：static getB1
父类B的静态代码块：static block b1 = 110
子类C的静态成员初始化函数：static getC1
子类C的静态代码块：static block c1 = 1110
基类A的代码块：block a2 = 20
基类A的构造函数：init A
父类B的成员初始化赋值函数：getB2
父类B的代码块：block b2 = 220
父类B的构造函数：init B
子类C的成员初始化函数：getC2
子类C的代码块：block c2 = 2220
子类C的构造函数：init C
//**************
* 结论：
* 静态成员函数-->静态成员变量-->静态代码块
*
* 成员函数-->成员变量-->代码块-->构造函数
*
* 因为成员变量是在赋值之前开辟的并被赋值为默认值 0，false，null;
*
* 因此对象初始化顺序为：
* 1.为成员变量开辟空间并赋值为默认值
* 2.调用构造函数（为执行方法体）
* 3.调用父类构造函数
* 4.给成员变量赋初始值
* 5.执行代码块
* 6.执行构造函数方法体。
*
* 因此你的函数出现0的情况是因为
* 步骤1 执行后 score = 0；
* 步骤3 执行时 score = 0；并被打印了；
* 步骤4 执行时 socre = 90；才会执行。
*
*/

复制代码

萌小子 · 萌小子

你运行下这段代码就知道运行顺序了
创建子类对象时，默认先调用父类的无惨构造方法，如果父类构造方法只有有参的，子类必须使用super调用父类构造方法。像这个例子，父类和子类都有静态代码块，创建子类对象时，先调用父类的静态代码块，其次调用子类的静态代码块，然后父类的构造方法，最后子类的构造方法。

class P {
static{
System.out.println("代码块P");
}
P(){
System.out.println("构造方法p");
}
}
public class C extends P{
static{
System.out.println("代码块C");
}
C(){
System.out.println("构造方法c");
}
public static void main(String[] args) {
new C();
}
}

复制代码

运行结果：
代码块P
代码块C
构造方法p
构造方法c

zjd · zjd

不要忘记子类中的构造函数有一个隐藏的super();语句，而这个语句一定要是函数内部的第一行语句，所以说在你创建对象的时候，初始化对象的时候，他要先运行super（）这个语句，进入父类调用父类中的this.print（）；而本身这个创建的这个对象是子类的，因此会调用子类中的print（），在这是很没有执行this.core=core语句，所以没有对this.core赋值，所以这是的this.core是系统默认值0

江南雨 · 江南雨

zjd 发表于 2013-5-26 15:27
不要忘记子类中的构造函数有一个隐藏的super();语句，而这个语句一定要是函数内部的第一行语句，所以说在你 ...

在子类中不是有core=90吗；我是菜鸟，对于编译，运行时不太懂？

First · First

对象初始化顺序为：

134.* 1.为成员变量开辟空间并赋值为默认值

135.* 2.调用构造函数（为执行方法体）

136.* 3.调用父类构造函数

137.* 4.给成员变量赋初始值

138.* 5.执行代码块

139.* 6.执行构造函数方法体。

140.*

141.* 因此你的函数出现0的情况是因为

142.* 步骤1 执行后 score = 0；

143.* 步骤3 执行时 score = 0；并被打印了；

144.* 步骤4 执行时 socre = 90；才会执行。

具体情况10楼

zjd · zjd

江南雨发表于 2013-5-26 16:39
在子类中不是有core=90吗；我是菜鸟，对于编译，运行时不太懂？

你这问题提的不错，确实子类中有core=90，如果这个子类是个独立的类的话确实会先运行成员变量，之后再运行构造函数，但是这是个子类，如果是子类是不是要先将父类加载到内存中在运行子类的语句，没有父亲哪来的孩子，说的这些都只适合非静态的，静态的除外，如果将子类中的private int core=90改成private static int core=90那么结果就会使就九十了，实在不理解就记下来，如果是非静态的就按照一般的父类上下执行，要是还不行告诉你个笨法用eclipse调试一下看看到底是怎么运行的，不就o了

江南雨 · 江南雨

zjd 发表于 2013-5-26 18:08
你这问题提的不错，确实子类中有core=90，如果这个子类是个独立的类的话确实会先运行成员变量，之后再运 ...

确实你是对的，理解很深入啊

zjd · zjd

江南雨发表于 2013-5-26 18:42
确实你是对的，理解很深入啊

你要是能给点评分就好了，看我那可怜的技术分呀

殇_心。 · 殇_心。

如果问题已解决，请及时修改分类，否则继续提问，谢谢合作！

帐号		自动登录	找回密码
密码			加入黑马

大神给解释下这道程序的运行结果

评分

17 个回复

评分

黑马骑士勋章