1. public class Test2 {
   
2. 
   
3.         /**
   
4.          * @param args
   
5.          */
   
6. 
   
7.         int a;
   
8.         Test2( double a ){
   
9.                 this.a=(int)a;
   
10.         }
    
11.         Test2( int a ){
    
12.                 this( "hello" );
    
13.                
    
14.         }
    
15.         Test2( String s ){
    
16.                 this();  //这样也可以编译通过？
    
17.                 System.out.println(s);
    
18.         }
    
19.         Test2(){
    
20.                 System.out.println("good-bye");
    
21.         }
    
22.         public static void main(String[] args) {
    
23.                 Test2 t = new Test2(5);
    
24.         }
    
25. 
    
26. }
    
27. 
    
28. 
    
29. 编译通过，运行结果是
    
30. good-bye
    
31. hello
    
32. 对于这个结果，我表示很混乱...

复制代码

实例化对象时传递一个int类型的参数，值为5，
调用 Test2( int a ){  this( "hello" ); }这个构造方法，构造方法中this( "hello" ); 调用一个类型是Stirng参数的构造方法，就是
Test2( String s ){
this();
System.out.println(s);
}，
这个构造方法先调用一个无参数的构造方法，就是
Test2(){System.out.println("good-bye");}
打印出good-bye
然后这个构造方法输出s。也就是传递进来的字符串“Hello”，

李海晓 发表于 2012-6-12 18:56
实例化对象时传递一个int类型的参数，值为5，
调用 Test2( int a ){  this( "hello" ); }这个构造方法，构 ...

哦，了解了，我就是一直对于那个 “hello” 是怎么来的没搞明白，听你这么一说大致知道了一点，我再研究研究

首先，你new一个Test2的对象，传递了一个int型的数据，那么就会调用对应的构造函数:
   Test2( int a ){
            this( "hello" );        
    }
可以看到你在构造函数中又调用了this("hello"),就使得调用对应的构造函数:
    Test2( String s ){
            this();
            System.out.println(s);
    }
这里面会首先调用一下无参构造函数，并打印字符串，那么很显然结果就是
good-bye
hello
因为你写了无参构造函数，this()当然不会报错。很明显，你前面那个this("hello")不也没有
报错吗，还不是因为有一个对应的字符串作为参数的构造函数。。

Test2( int a ){
              this( "hello" );  //这里调用的接收字符串的构造函数
说实话我刚刚开始看的时候，也蒙了。。。

不过你仔细看。这里调用的是下面这
Test2( String s ){

               this();  //这样也可以编译通过？

               System.out.println(s);

        }

而这个里面又调用了无参的构造函数。所以就先打印good-bye

然后才是hello

this();  //这样也可以编译通过？
这个代表空参数的构造方法  
程序调用过程   1 int参数类型构造  2调用 this( "hello" )即Stirng参数类型的构造方法  3调用this（） 即空参数的构造方法  打印good-bye  4回到String类型构造方法执行
System.out.println(s)  打印s参数  即传入的hello。

你这个就涉及到this指针的使用问题.this()这里其实就是调用了无参的构造函数matchs()，因为this不仅可以表示当前对象的引用，还可以指向构造函数。如果你改成：this(2)、this(2.2)this指向的构造函数有分别是matchs(int a)和matchs(double a)。

public class Test2 {

        /**

         * @param args

         */

        int a;

        Test2( double a ){

                this.a=(int)a;
        }

        Test2( int a ){//------------------步骤1

                this( "hello" );               
        }

        Test2( String s ){//---------------步骤2

                this();  //这样也可以编译通过？

                System.out.println(s);//this()执行完后，在执行该语句
        }

        Test2(){//---------------步骤3

                System.out.println("good-bye");
        }

        public static void main(String[] args) {
                /*
                 *这里实例化后，因为传的是一个整型的参数5，所以java编译器就会寻找带参构造函数是int类型的：Test2( int a ),而你又在该构造函数里用 this( "hello" )指向带参                          *数为字符串的构造函数，所以java编译器也同样也去寻找与之相匹配的带参的构造函数：Test2( String s )，在Test2( String s )有用this()指向无参的构造函数，
                 *所以java编译器也去寻找这个无参的构造函数。
                 */

                Test2 t = new Test2(5);
        }
}

{:soso_e110:}谢谢了，一下走进了思维误区，现在明白了

构造函数的调用顺序为Test2( int a ) --- Test2( String s ) ---- Test2()，在Test2( String s )执行是先调用Test2()打印good-bye，最后在打印s也就是hello，构造函数调用构造函数是第一个语句必须是this，而且只能调用一次，所以代码是可以通过编译的

this();  //这样也可以编译通过？
要先明白this的两个作用：区别局部变量和构造函数间的相互调用。
构造函数间的相互调用代码格式：this（参数列表），调用空参数构造函数时当然就是：this();  

楼主要先明白 this在构造函数中的应用。在重载的构造函数中 this()用来调用已定义的构造方法。
对于这题，暂且将四个构造函数称为：构造-double,构造-int，构造-String,构造-空。

主函数中：Test2 t = new Test2(5);  分析：：首先是调用：构造-int， 而构造-int中有语句“this("hello")”,说明这句又调用了： 构造-String,  但是这里又有：Test2(String s)this.();   System.out.println(s);   。this()语句又调用了 ：构造-空。              
  构造-空 输出“good-bye”,  然后再原路返回执行为执行的语句，输出 hello

不知道楼主明白否

这个问题首先要搞清楚构造方法中this的作用——调用该类中的构造方法。
明白了这一点事情就非常简单了，例如看你的例子：
Test2 t = new Test2(5);之后首先调用： Test2( int a ){  this( "hello" );} 这个构造方法，而这个构造方法调用了

1. Test2( String s ){
   
2.                 this();
   
3.                 System.out.println(s);
   
4.         }

复制代码

这个，而Test2（String s）通过this（）调用了无参的构造方法，这使得System.out.println("good-bye");执行输出good-bye，然后再执行
Test2( String s )中的System.out.println(s);输出hello。
希望对你有用，求加分