难倒我的两个简单程序。大家看看。

Question

本帖最后由 guoxu0524 于 2009-06-29 09:48:14 编辑

Answer 1

第一个运行结果
What a pleasure!
I am Tom
How do you do?
构造函数先调用父类的构造函数。
this是本类的一个实例
super是父类的一个实例

Answer 2

我的理解是，子类调用的是父类中的有参数的构造函数，为什么无参数的也能被调用，从而显示出来 what a pleasure!

Answer 3

自己又想了一下，清楚了，是因为有this（）；调用了无参数的构造方法TT（）。谁能帮我解释一下第二个代码呢？
输出结果是：i=0
continue inner
i=1
continue inner
i=2
continue
i=3
break
i=4
continue inner
i=5
continue inner
i=6
continue inner
i=7
continue outer
i=8
break outer
只有k=3时才会有“continue inner”，为什么结果中每次输出都有呢？

Answer 4

我的理解是，子类调用的是父类中的有参数的构造函数，为什么无参数的也能被调用，从而显示出来 what a pleasure!....因为在父类中的有参数的构造函数中，调用了父类自己的无参数的构造函数：this()，要是去掉这句的话，就没有what a pleasure!了

Answer 5

回楼主第二个问题：因为每次进入k的那个循环的时候，for语句里都新定义一个k来做为判断，每次都会遇到k==3的情况的

Answer 6

for(int k=0;k<5;k++)   //k循环都会重新开始，你没有跳出去的语句（也就是0，1，4，5，6）执行结束后，都会执行这句话
                        {
                            if(k==3)
                            {
                                System.out.println("continue inner");
                                continue inner;
                            }
                        }

Answer 7

K是第3层循环 
在循环前面 没有执行break continue 都会输出 。
break（continue） ： 标识  是指跳出（或继续）标识处的循环构建一个对象先生成父类对象
这里指定了父类的带字符串的构造方法， 未指定会调用默认的；
所以先调用
public TT(String s)
    {
        this();
        System.out.println("I am "+s);
    }
this（） 会调用
public TT()
    {
        System.out.println("What a pleasure!");
    }
所以输出
What a pleasure!
I am Tom最后才是How do you do?

Answer 8

谢谢了，第二个我明白了，但是第一个又有了新的问题。我修改了一下代码public class T extends TT {
public static void main(String[] args)
{
T t=new T();
}
public T(String s)
{
super(s);
System.out.println("How do you do?");
}
public T()
{
//this("I am Tom");
}
}
class TT
{
public TT()
{
System.out.println("What a pleasure!");
}
public TT(String s)
{
this();
System.out.println("I am "+s);
}
}为什么只输出what a pleasur！

Answer 9

this是本身对象的一个引用，super是在有继承关系中对父类的引用。
当运行T t=new T("Tom");时，根据继承规则，会在调用自己的构造方法中，第一时间调用父类构造方法。也就是
public T(String s)
    {
        super(s);
        System.out.println("How do you do?");
    }方法中的super(s);显示调用父类的
public TT(String s)
    {
        this();
        System.out.println("I am "+s);
    }
构造方法。而this();调用自己的
  public TT()
    {
        System.out.println("What a pleasure!");
    }
无参数构造方法，打印What a pleasure！
然后从this()方法往后执行，打印I am Tom
最后回到super()方法往后继续执行，打印How do you do?
总结一点：在类继承关系中，子类初始化时一定会在子类构造函数中第一时间调用父类构造函数。

Answer 10

我的理解是：break退出当前循环，continue 退出本次循环（也就是继续下一个循环（如果条件符合）），continue outer也就相当于跳转到outer重新执行outer循环，break outer是终止outer循环。这样理解就是楼主的结果相符了

Answer 11

补充一下：
for(;true;)
            {
                inner:
                    for(;i<10;i++)
我认为这样的循环嵌套式不可取的，外面的循环什么都没做就进入内循环，而且内循环并没有用到外循环的循环变量（外循环也没有循环变量）。一般循环嵌套肯定内循环会设计到外循环的变量或者外循环先判断完 自己的变量后符合条件再进入内循环。

Answer 12

回9楼的，T（string s）这个方法没有执行么？

Answer 13

    public Test()
    {
        //this("I am Tom");
    }
会自动的调用super(),父类的无参构造函数

Answer 14

我也不明白第一个，为什么调用了父类的TT(String s)方法
执行了 this();方法，却没执行System.out.println("I am "+s);呢？
很不解。
当我注释this();方法时运行结果是：
I am Tom
How do you do?
当我不注释this();而注释 super(s);时结果
What a pleasure!
How do you do?
说明调用了TT(String s)的方法，但为什么不会执行System.out.println("I am "+s);呢？