A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 韩伟 中级黑马   /  2012-7-16 08:00  /  1584 人查看  /  7 人回复  /   1 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 韩伟 于 2012-7-16 11:39 编辑

在做练习时,看到这样一段代码,有点不太理解,请高手给解释一下:
public class Hello
{
        public static void main(String[] args)
        {
                new Hello(3L);
        }
        public Hello(long x)
        {
                this ((int) x);
                System.out.println("a");
        }
        public Hello(int x)
        {
                this();
                System.out.println("b");
        }
        public Hello()
        {
                System.out.println("c");
        }
}
这个代码运行结果是“cba”,发现this用法比较特殊,这里的this是直接调用了函数吗?

评分

参与人数 1技术分 +1 收起 理由
韦念欣 + 1 赞一个!

查看全部评分

7 个回复

倒序浏览
是的,这里的this调用的其他构造函数,具体流程如图所示。

无标题.png (18.08 KB, 下载次数: 18)

无标题.png

评分

参与人数 1技术分 +1 收起 理由
韦念欣 + 1 这张图简单明了!

查看全部评分

回复 使用道具 举报
我知道很多朋友都和我一样:在JAVA程序中似乎经常见到“this”,自己也偶尔用到它,但是到底“this”该怎么用,却心中无数!很多人一提起它,就说“当前对象”,可到底什么是当前对象,是什么当前对象,他自己也不清楚。现在让大家看一个小例子,给你分享一下JAVA中“this”的用法!

/**
* @author fengzhi-neusoft
*  * 本示例为了说明this的三种用法!
*/
package test;
public class ThisTest {
private int i=0;

    //第一个构造器:有一个int型形参
    ThisTest(int i){
       this.i=i+1;//此时this表示引用成员变量i,而非函数参数i
       System.out.println("Int constructor i——this.i:  "+i+"——"+this.i);
       System.out.println("i-1:"+(i-1)+"this.i+1:"+(this.i+1));
       //从两个输出结果充分证明了i和this.i是不一样的!
}

    //  第二个构造器:有一个String型形参
    ThisTest(String s){
       System.out.println("String constructor:  "+s);
    }
    //  第三个构造器:有一个int型形参和一个String型形参
    ThisTest(int i,String s){
       this(s);//this调用第二个构造器
       //this(i);
       /*此处不能用,因为其他任何方法都不能调用构造器,只有构造方法能调用他。
       但是必须注意:就算是构造方法调用构造器,也必须为于其第一行,构造方法也只能调

       用一个且仅一次构造器!*/

       this.i=i++;//this以引用该类的成员变量

       System.out.println("Int constructor:  "+i+"\n"+"String constructor:  "+s);

    }

    public ThisTest increment(){

       this.i++;

       return this;//返回的是当前的对象,该对象属于(ThisTest)

    }

    public static void main(String[] args){

       ThisTest tt0=new ThisTest(10);

       ThisTest tt1=new ThisTest("ok");

       ThisTest tt2=new ThisTest(20,"ok again!");

      

       System.out.println(tt0.increment().increment().increment().i);

       //tt0.increment()返回一个在tt0基础上i++的ThisTest对象,

       //接着又返回在上面返回的对象基础上i++的ThisTest对象!

    }

}



运行结果:



Int constructor i——this.i:  10——11

String constructor:  ok

String constructor:  ok again!

Int constructor:  21

String constructor:  ok again!

14


细节问题注释已经写的比较清楚了,这里不在赘述,只是总结一下,其实this主要要三种用法:

1、表示对当前对象的引用!

2、表示用类的成员变量,而非函数参数,注意在函数参数和成员变量同名是进行区分!其实这是第一种用法的特例,比较常用,所以那出来强调一下。

3、用于在构造方法中引用满足指定参数类型的构造器(其实也就是构造方法)。但是这里必须非常注意:只能引用一个构造方法且必须位于开始!

还有就是注意:this不能用在static方法中!所以甚至有人给static方法的定义就是:没有this的方法!虽然夸张,但是却充分说明this不能在static方法中使用!

评分

参与人数 1黑马币 +30 收起 理由
刘笑 + 30

查看全部评分

回复 使用道具 举报
这段代码是构造函数重载,这里用到了this 其中的一种用法:构造函数间互相调用,要用this();并且此语句只能放在构造函数的第一行。
因为初始化动作要先执行,若初始化里还有初始化,就要先把最里面的初始化执行完,再执行外面的初始化。
所以这段代码结果是cba,解析如下:
public class Hello
{
        public static void main(String[] args)
        {
                new Hello(3L);//给对象初始化,把3L传给有参构造函数的(long x)
        }
        public Hello(long x)
        {
                this ((int) x); //这个构造函数初始化当前对象时,又调用了带(int x)的构造函数,this()这种格式就是构造函数里再调用另一个构造函数
                System.out.println("a");//所以这句话没执行,程序直接跳转到下一个构造函数。
        }
        public Hello(int x)//执行此构造函数,给当前对象初始化
        {
                this();//发现这个又用this调用了底下的一个无参构造函数,跳转到下一个无参构造函数
                System.out.println("b");//这句话同样也没执行
        }
        public Hello()//程序执行这个构造函数给当前对象初始化
        {
                System.out.println("c");//这里没有再调用构造函数了,只有一个输出语句,就把c输出了,此构造函数执行完,接着就执行前一个构造函数输出b,再执行最前一个就输出a,所以结果是cba
        }
}

下面是我学习时总结的this用法,希望能帮到你
1、        this修饰符用于区分成员变量和函数变量重名的情况。因为如果函数里的参数(局部变量)与类里的成员变量重名了,此时程序会先找局部变量。
例:
class Person
{
        private String name;
       
        Person(String name)
        {
                this.name = name;
        }
        public void speak()
        {
                System.out.println("name="+name);
        }
}
class PersonDemo
{
        public static void main(String[] args)
        {
                Person p = new Person("lisi");
                p.speak();
       
        }
}
如果在成员变量name前面不加this修饰符,此代码运行后的结果是name=null;而不是lisi,因为局部变量与成员变量重名了,程序运行后,是把局部变量的null值赋给了name。this代表它所在函数所属对象的引用,也就是说哪个对象在调用this所在的函数,this就代表哪个对象。

2、        构造函数间互相调用,要用this();并且此语句只能放在构造函数的第一行。因为初始化动作要先执行,若初始化里还有初始化,就要先把最里面的初始化执行完,再执行外面的初始化。
class Person
{
        private String name;
        private int age;
        Person(String name)
        {
                this.name = name;
                System.out.print("name");
        }
        Person(String name,int age)
        {
                this(name);//构造函数之间互相调用用这种格式且必须放在构造函数里的第一行,一般函数调用用Person(name);
                this.age = age;
        }
}
class PersonDemo
{
        public static void main(String[] args)
        {
                Person p = new Person("lisi");
               
        }
}


总结:当定义类中功能(函数)时,该函数内部要用到调用该函数的对象时,这时用this来表示这个对象。只要本类功能内部使用到了本类对象,都用this表示。一般函数是不能直接调用构造函数的,因为this不能用于一般函数,只在构造函数间调用。

评分

参与人数 1技术分 +1 收起 理由
刘笑 + 1 讲的比较透彻

查看全部评分

回复 使用道具 举报
本帖最后由 jeffreyno1 于 2012-7-16 08:47 编辑

这个知识点考察的是对构造函数和this的理解。

代码的执行顺序如下:
1.new Hello(3L); //实参为long类型的值,构造函数将调用Hello(long)
2.进入到Hello(long x)中,执行到this((int)x); //这里的(int)x,将形参转型为int类型,于是构造函数在此要调用Hello(int x)
3.进入到Hello(int x)中,执行this()
4.进入到Hello()中,执行System.out.println("c"); //打印c
5.Hello()执行完后,返回到Hello(int x)中
6.在Hello(int x)中,继续往下执行System.out.println("b"); //打印b
7.Hello(int x)执行完后,返回到Hello(long x)中
8.在Hello(long x)中,继续向下执行System.out.println("a"); //打印a

最终结果就是:
c
b
a

评分

参与人数 1技术分 +1 收起 理由
韦念欣 + 1 整个调用过程的文字描述,准确!.

查看全部评分

回复 使用道具 举报
我给你贴出我前几天对this,super的总结,希望你好好看看呀
this,super关键字总结

一、this
         Java关键字this只能用于方法体内。当一个对象创建后,Java虚拟机(JVM)就会给这个对象分配一个引用自身的指针,这个指针的名字就是this。因此,this只能在类中的非静态方法中使用,静态方法和静态的代码块中绝对不能出现this,并且this只和特定的对象关联,而不和类关联,同一个类的不同对象有不同的this。下面给出一个使用this的综合例子。


public class Test6 {

private int number;
private String username;
private String password;

private int x = 100;

public Test6( int i, String username, String password ) {
   
   // 成员变量和参数同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
   this.username = username;
   this.password = password;
   
}

//*************************//
// 默认不带参数的构造方法


public Test6() {
   this(0, "x", "null"); // 通过this调用另一个构造方法
}

//********************************//
public Test6(String name) {
   this(1, name, "null"); // 通过this调用另一个构造方法
}


//******************************//
public static void main(String args[]) {
   
   
   Test6 t1 = new Test6();
   Test6 t2 = new Test6("123");
   
   t1.outinfo(t1);
   t2.outinfo(t2);
   
}

//*****************************//
private void outinfo(Test6 t) {
   
   System.out.println("-----------");
   System.out.println(t.number);
   System.out.println(t.username);
   System.out.println(t.password);
   f(); // 这个可以写为: this.f();
}


//********************************//
private void f() {
   
   // 局部变量与成员变量同名,成员变量被屏蔽,用"this.成员变量"的方式访问成员变量.
   int x;
   x = this.x++;
   System.out.println(x);
   System.out.println(this.x);
}

//*************************************//
//返回当前实例的引用
   private Test6 getSelf() {
   return this;
}
}
总结:  

   第一、通过this调用另一个构造方法,用法是this(参数列表),这个仅仅在类的构造方法中,别的地方不能这么用。
          第二、函数参数或者函数中的局部变量和成员变量同名的情况下,成员变量被屏蔽,此时要访问成员变量则需要用“this.成员变量名”的方式来引用成员变量。当然,在没有同名的情况下,可以直接用成员变量的名字。
         第三、在函数中,需要引用该函数所属类的当前对象时候,直接用this。





二,super

super关键和this作用类似,是被屏蔽的成员变量或者成员方法或变为可见,或者说用来引用被屏蔽的成员变量和成员成员方法。
不过super是用在子类中,目的是访问直接父类中被屏蔽的成员,注意是直接父类(就是类之上最近的超类)。下面是一个综合运用super的例子,有两个类:一个Father类,一个Father类的子类Son,通过这两个类完全演示了super的用法 .


public class Father {

public String v = "Father";

public String x = "输出了Father类的public成员变量x!!!";


public Father() {
            System.out.println("Father构造方法被调用!");

}


public Father(String v){
   
   this.v="Father类的带参数构造方法!运行了.";

}

public void outinfo(){
   
   System.out.println("Father的outinfo方法被调用");

}

public static void main(String[] args) {
   
   // TODO 自动生成方法存根

}

}

class Son extends Father{

  public String v="Son";


   public Son() {
   
    super();      //调用超类的构造方法,只能放到第一行.
   
    System.out.println("Son无参数构造方法被调用!");
   
    //super();      //错误的,必须放到构造方法体的最前面.

   }


  public Son(String str){
   
    super(str);
   
    System.out.println("Son带参数构造方法被调用!");

   }

   //覆盖了超类成员方法outinfo()

   public void outinfo(){
        
    System.out.println("Son的outinfo()方法被调用");

   }  

   public void test(){
   
         
    String v="哈哈!";   //局部变量v覆盖了成员变量v和超类变量v
   
   
    /*
     System.out.println("------1-----");
   
    System.out.println(v);   //输出局部变量v
   
    System.out.println(this.v);  //输出(子类)成员变量v

    System.out.println(super.v); //输出超类成员变量v
   */
   
          /*
    System.out.println("------2-----");
   
    System.out.println(x);   //输出超类成员变量v,子类继承而来
   
    System.out.println(super.x); //输出超类成员变量v
           */
         
    System.out.println("------3-----");

    outinfo();   //调用子类的outinfo()方法
   
    this.outinfo();  //调用子类的outinfo()方法
   
    super.outinfo(); //调用父类的outinfo()方法
         

   }

  public static void main(String[] args) {
   
    new Son().test();

  }
}


  

说明:次例子仅仅为了说明super的用法,实际在设计类的时候一般都尽可能私有(private)化。

总结:

        第一、在子类构造方法中要调用父类的构造方法,用“super(参数列表)”的方式调用,参数不是必须的。同时还要注意的一点是:“super(参数列表)”这条语句只能用在子类构造方法体中的第一行。
         第二、当子类方法中的局部变量或者子类的成员变量与父类成员变量同名时,也就是子类局部变量覆盖父类成员变量时,用“super.成员变量名”来引用父类成员变量。当然,如果父类的成员变量没有被覆盖,也可以用“super.成员变量名”来引用父类成员变量,不过这是不必要的。
         第三、当子类的成员方法覆盖了父类的成员方法时,也就是子类和父类有完全相同的方法定义(但方法体可以不同),此时,用“super.方法名(参数列表)”的方式访问父类的方法。

// **************************************************//
public class Father {

public Father() {
   
            System.out.println("Father构造方法被调用!");

}
}

class Son extends Father{

  public Son() {
   
    super();      //调用超类的构造方法,只能放到第一行.
   
    System.out.println("Son无参数构造方法被调用!");

   }
     
   public static void main(String[] args) {
   
    new Son();

  }
}
回复 使用道具 举报
黄昆 中级黑马 2012-7-16 09:30:22
7#
public class Hello
{
         public static void main(String[] args)
         {
                 new Hello(3L);
         }
         public Hello(long x)
         {
                 this ((int) x);
                 System.out.println("a");
         }
         public Hello(int x)
         {
                 this();
                 System.out.println("b");
         }
         public Hello()
         {
                 System.out.println("c");
         }
}


这个其实很好理解的,按着毕老师的说法就是:构造函数间的调用用this语句。

1、new Hello(3L);此时会掉用Hello(long x)这个构造方法,
2、 public Hello(long x)
         {
                 this ((int) x);//此时会调用 Hello(int x)这个构造方法。
                 System.out.println("a");
         }
3、public Hello(int x)
         {
                 this();//再掉用 Hello()的构造方法。
                 System.out.println("b");
         }

打印结果就是:
c
b
a
回复 使用道具 举报
韩伟 中级黑马 2012-7-16 11:38:08
8#
明白了,多谢各位英雄.....
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马