Java学习笔记14---this作为返回值时返回的是什么

有时会遇到this作为返回值的情况，那么此时返回的到底是什么呢？

返回的是调用this所处方法的那个对象的引用，读起来有点绕口哈，有没有想起小学语文分析句子成份的试题，哈哈。

一点点分析的话，主干是“返回的是引用”；

什么引用呢？“那个对象的引用”；

哪个对象呢？“调用方法的那个对象”；

调用的哪个方法呢？“调用的是this所位于的方法”；这样就清楚了。

再总结一下就是，this作为返回值时，返回的是调用某方法的对象的引用，这个方法正是包含“return this;”这行命令的那个方法；更简单点说，就是谁调用返回的就是谁。由于返回的是对象引用，所以this不能用在静态成员方法中，只能在非静态成员方法中出现。

为了更清楚、直观的理解问题，下面以简单的例子说明。

作者： 蝉蝉

请尊重作者劳动成果，转载请在标题注明“转载”字样，并标明原文链接：

http://www.cnblogs.com/chanchan/p/7812166.html

追加（11.26）：

添加了下面5项测试代码：

(1).子类对象调用父类中返回this的方法，该方法未被子类重写

(2).子类对象调用父类中返回this的方法，该方法已被子类重写，且返回值类型与父类返回值类型一致

(3).父类对象引用指向子类对象时，即向上转型时，父类对象引用调用未被子类重写的返回this的方法

(4).向上转型时，父类对象引用调用被子类重写的返回this的方法，且返回值与父类返回值类型一致

(5).向上转型时，父类对象引用调用被子类重写的返回this的方法，且返回值类型为父类返回值类型的子类

分析见后文

(11.26)

包human中定义了Person类、Student类及测试类TestMain，其中Student是Person的子类。

Person类代码如下：

package human;
 
public class Person {
    String name;
    int age;
 
    public Person() {
 
    }
    public Person(String n, String g) {
        name = n;
        gender = g;
    }
 
    //test:this作返回值
    Person reThis1() {
        Person per = new Person("lu","female");
        System.out.println("reThis1 per:" + per.name);
        return this;
    }
    Person reThis2() {
        Person per = reThis1();
        System.out.println("reThis2 per:" + per.name);
        return this;
    }
    Person reThis3() {
        name = "ma";
        return this;
    }
    static void equRefer(Person per1, Person per2) {
        if(per1 == per2)
            System.out.println("per1指向的对象没有改变，仍与per2指向同一个对象");
        else
            System.out.println("per1指向的对象已改变，与per2指向不同的对象");
        System.out.println("per1:" + per1.name);
        System.out.println("per2:" + per2.name);
    }
 
    public static void main(String[] args) {
        Person per1 = new Person("liu","female");
        Person per2 = per1;
 
        per1 = per1.reThis1();
        Person.equRefer(per1, per2);
 
        per1 = per1.reThis2();
        Person.equRefer(per1, per2);
 
        System.out.println("调用reThis3之前，per1.name=" + per1.name);
        per1 = per1.reThis3();
        System.out.println("调用reThis3之后，per1.name=" + per1.name);
    }
}

Student类代码如下：

package human;
 
public class Student extends Person {
    String stuNumber;
    int score;
 
    public Student(String n, String g) {
        super(n,g);
    }
 
    Person reThis1() {
        Person per = new Person("luPS","female");
        System.out.println("reThis1 per S:" + per.name);
        return this;
    }
 
    Student reThis2() {
        Person per = reThis1();
        System.out.println("reThis2 per S:" + per.name);
        return this;
    }
 
}

TestMain类如下：

//http://www.cnblogs.com/chanchan/p/7812166.html
package human;
 
public class TestMain {
    public static void main(String[] args) {
 
        Person per1 = new Person("liuP","female");
        Person per2 = per1;
        Person per3;
        Person per4;
        Student stu1 = new Student("liuS","female");
        Student stu2 = stu1;
 
        //追加2017.11.25
        per1 = stu1.reThis3();
        if( per1 == stu1 )
            System.out.println("per1与stu1指向同一个子类对象");
        else
            System.out.println("per1与stu1指向不同的对象");
 
        per1 = stu1.reThis1();
        if( per1 == stu1 )
            System.out.println("per1与stu1指向同一个子类对象");
        else
            System.out.println("per1与stu1指向不同的对象");
 
        per3 = stu1;
        per4 = per3.reThis3();
        if( per4 == per3 )
            System.out.println("per4与per3指向同一个子类对象");
        else
            System.out.println("per4与per3指向不同的对象");
 
        per3 = stu1;
        per4 = per3.reThis1();
        if( per4 == per3 )
            System.out.println("per4与per3指向同一个子类对象");
        else
            System.out.println("per4与per3指向不同的对象");
 
                per3 = stu1;
        stu1 = (Student) per3.reThis2(); //向下转型
        if( stu1 == per3 )
            System.out.println("stu1与per3指向同一个子类对象");
        else
            System.out.println("stu1与per3指向不同的对象");
    }
 
}

输出结果如下：

 reThis1 per:lu
 per1指向的对象没有改变，仍与per2指向同一个对象
 per1:liu
 per2:liu
 reThis1 per:lu
 reThis2 per:liu
 per1指向的对象没有改变，仍与per2指向同一个对象
 per1:liu
 per2:liu
 调用reThis3之前，per1.name=liu
 调用reThis3之后，per1.name=ma

追加（11.26）

输出结果如下：

 per1与stu1指向同一个子类对象
 reThis1 per S:luPS
 per1与stu1指向同一个子类对象
 per4与per3指向同一个子类对象
 reThis1 per S:luPS
 per4与per3指向同一个子类对象
 reThis1 per S:luPS
 reThis2 per S:maP
 stu1与per3指向同一个子类对象

（11.26）

逐句分析执行过程：

(1).第1句：Person per1 = new Person("liu","female");

创建一个Person对象，将name初始化为“liu”，gender初始化为“female”，并让per1指向该对象。

(2).第2句：Person per2 = per1;

定义一个Person类的对象引用，并与per1指向同一个对象；具体内存分配见图1：

(3).第3句：per1 = per1.reThis1();

由per1调用reThis1()方法，并将返回值赋给per1；reThis1()方法体内定义了一个局部变量per，并创建一个对象，由per指向它；具体内存分配见图2：

紧接着输出reThis1 per:lu；最后返回this，并把返回的值赋给per1。

(4).第4句：Person.equRefer(per1, per2);

调用equRefer(per1,per2)来验证per1的值并未改变；根据下面的输出结果也可知per1仍与per2指向原来的对象，也就是说此时this的值与per1的值是一致的；也可以说，谁调用的返回的就是谁。

输出结果：

per1指向的对象没有改变，仍与per2指向同一个对象
per1:liu
per2:liu

此时的内存图如图3：

(5).第5句：per1 = per1.reThis2();

per1调用reThis2()，由(4)可推测，此时per1的值也不会变，是由per1调用的this所处的方法，所以返回的也是per1；具体来分析的话，reThis2()定义了一个局部变量per，并给其赋值为reThis1()，也就是说reThis2()调用了reThis1()，由(3)、(4)可推知，此时的内存结构是下面这样的：

局部变量per指向的对象与per1是一致的，因为调用reThis1的对象是per1所指的对象，所以返回值也是per1。

此处的输出结果为：

reThis1 per:lu
reThis2 per:liu

(6).第6句：Person.equRefer(per1, per2);

验证上面的结论，per1指向没变，此时的内存分配图如图4所示：

(7).第7、8、9句：

System.out.println("调用reThis3之前，per1.name=" + per1.name);
per1 = per1.reThis3();
System.out.println("调用reThis3之后，per1.name=" + per1.name);

per1调用reThis3()；reThis3()中修改了namer的值，由"liu"改为"ma"，然后返回this。

调用前后的内存结构分别如图6、图7所示：

输出结果：

调用reThis3之前，per1.name=liu
调用reThis3之后，per1.name=ma

再一次验证了上述的结论。

追加（11.26）

结果分析：

从结果可以看到，返回值与调用方法的对象引用是一致的，是指向同一个子类对象的；

也就是说，即使是由子类来调用父类的返回this的方法，不论子类有没有重写该方法，返回值都是指向调用该方法的子类对象的；

当由指向子类对象的父类对象引用来调用返回this的方法时，同样的，返回值也都指向了 调用该方法的 父类对象引用 所指向的子类对象；

当子类重写了父类的返回this的方法时，且返回值类型是父类返回值类型的子类，这时返回值同上，不过这里涉及到向下转型，代码中已标出，有疑问可以参考笔记15。

综上，这些情况下也适用“谁调用返回谁”。

（11.26）

关于为什么使用this，我是这么理解的：由于定义类的时候尚未创建对象，所以不能确定对象到底叫什么，就用this来统一表示，等到具体调用时就可以知道对象的名字了，然后就用对象的引用替换this；所以为了便于记忆，可以理解成谁调用返回的就是谁。

至于返回this有什么意义，我的理解是：记返回this的方法为A，可能A的方法体中对对象的属性做了某些操作或调用了某些方法完成了某些动作，总之，做完这些操作后就把原对象的引用返回，返回后的状态是对象最新的状态，可能与对象调用方法A前不同。