JavaSE基础知识(十)--Java的this关键字

Java SE 是什么，包括哪些内容(十)？

本文内容参考自Java8标准
前言：可看可不看
当年我决定自学Java的时候，这个this关键字曾经困扰了我很久，我怎么都没有办法理解"当前对象"等，都是"当前"…，后来我理解了，用"当前"表述其实没有什么问题，只是对于初学者来说，理解起来会有很大的问题。
下面的内容可能会有一点啰嗦
还是要从前面我写过的博文中的基础知识说起:
先来回顾一下Java的编程过程：
⑴、首先就是创建新的数据类型：类

// 创建新的数据类型：类
  //创建一个人类(Person)：比较通俗易懂
     public class Person{
          //表示人类的姓名：
          private  String  name；
          //表示人类的性别：
          //private  String  sex；
          //表示人类的年龄
          private  int  age；
          //如果有必要，创建构造方法。
          //也可以不创造构造方法，直接使用默认构造方法。
          public Person(){}
          //创建一些与人类行为有关的方法：
          //方法一：
              //...此处省略具体的方法内容。
          //方法二：
              //...此处省略具体的方法内容。
          //...可以有很多的方法
     }  

⑵、利用现成的类创建对象，按需改变变量的值或调用对应的方法来实现功能。
这里有一点很重要，就是能创建很多个对象，所以有很多书中会将this解释为是当前对象。

// 创建对象，改变变量，调用方法。
 //创建对象：
 Person p = new Person()；
 //改变变量：
 p.name = "小王"；
 //调用方法(假设有一个work()方法)：
 p.work()；
 //代码直至到这里都没有什么问题。

⑶、执行代码，得出结果。

来，我们再回顾一下⑵：你会发现在⑵中，首先是Person p = new Person()，然后利用p去修改的变量，利用p去调用的方法。那么p是什么呢？p是你创建当前Person对象的时候给这个对象的存储空间取的名称，这个对象的存储空间中拥有Person类中的所有变量和所有方法，所以你可以利用这个存储空间的名称p去修改变量和调用方法。以实现你需要的功能，同时p.name，p.work()正是Java面向对象编程的代码体现。
那么问题来了：

在⑴中，也就是你创建数据类型的过程中，会不会有类似p.name，p.work()这种代码的需要？答案很肯定，绝对会有，但是，你在创建类的时候，并没有创建对象(也就是没有代表对象的名称，例如p)，那么，怎么办？Java的创建者想到最后，用this吧。

如果你对上面的解释还是不明白，那我再用另外的方式解释一下：

this的作用就是在你创建对象之前(也就是Person p = new Person()之前)暂时代替p，说白了也就是在类中需要修改变量，需要调用方法的时候，暂时用this代替。待Person p = new Person()执行之后，再用p代替this，这样就达到了要求。如果你创建对象的时候取名是p1:Person p1 = new Person()，那么this代替的就是p1.

如果你对上面的解释还是不明白，那我再再用另外的方式解释一下：

在你创建对象，并为对象引用取了名称之后(Person p = new Person())，你使用的是引用的名称( p )，但是在你还未创建对象，没有对象引用名称来使用的时候，就使用this------因为在你编写类的时候，一样是利用的面向对象思想。所以，在类中，肯定会涉及到对象引用的需要。这个时候就用this。

如果你对上面的解释还是不明白，我再用生活中的一个例子举例：
不能保证完全贴切，但是比较形象：
一家餐饮店很有名，每天都爆满，座位很稀缺，那么肯定会出现占座的情况，于是店主就为先来的人提供了专门占座的东西(为朋友占座)—一个靠枕，那么这个靠枕代表的就是即将要来的这个人(还没有来，也就是没有具体的对象，所以这个靠枕就是this)，过了十五分钟，来了一个人，名字叫小王(这个时候通过Person p = new Person()创建了一个具体的对象，代表了小王)，那么很显然，这个靠枕代表的就是小王，如果来的是小李，那么这个靠枕代表的就是小李。所以，为什么说this代表的是当前对象了。
最后，再通过代码来解释一下this：

// 代码解释this:
    public class Person{
           //表示人类的姓名：
           private  String  name；
           //表示人类的性别：
           //private  String  sex；
           //表示人类的年龄
           private  int  age；
           //创空建构造方法。
           public Person(){}
           //创建有形式参数的构造方法：
           public Person(String name,String sex,int age){
               //这个方法体要实现的内容就是将实际参数赋值给类变量
               //那么类变量怎么表示？这个时候还没有具体的对象引用名称。
               //如果有就用具体的对象引用名称,问题是现在没有,只能用this暂时代替
               this.name = name;
               this.sex = sex;
               this.age = age;
               //当你创建对象的时候,具体的对象的name,sex,age的值
               //都会是你创建对象时实际输入的值。
               //Person p = new Person("小王","男",25);对象p的name,sex,age
               //分别是"小王","男",25.
               //Person p1 = new Person("小刘","女",23);对象p1的name,sex,age
               //分别是"小刘","女",23.
               //一一对应的。
           }
           //创建一些与人类行为有关的方法：
           //方法eat(),代表吃饭。
              public void eat(){
                 //方法体省略。
              }
           //方法work(),代表工作。
              public void work(){
                 //如果这个时候类中的work()方法想调用eat()方法如何操作呢？
                 //对,用this暂时代替实际的对象引用去调用。
                 this.eat();
                 //其他方法体内容省略...
              }
              
      }  

最后，简单总结一句：因为在创建类的时候，没有具体的对象，也就是没有具体的对象标识符，所以暂时用this代替！在创建类的时候，在你需要使用对象标识符的地方全部使用this！
以下内容为Java编程思想第四版中对this关键字的解释
如果有同一类型的两个对象，分别是a和b，你可能想知道，如何才能让这两个对象调用同一个方法呢(比如下面举例的peel()方法)？
代码举例：

// 代码举例
    class Banana{
        void peel(int i){
            //方法体
        }
    } 
    public class BananaPeel{
       public static void main(String[] args){
          Banana a = new Banana(),
                 b = new Banana();
          a.peel(1);
          b.peel(2);    
       }
    }

如果只有一个peel()方法，它如何知道是被a还是被b所调用的呢？
为了能用简便、面向对象的语法来编写代码--------即"发送消息给对象"，编译器做了一些幕后工作，它暗自把"所操作对象的引用"作为第一个参数传递给peel()，所以，在幕后，上述两个方法调用就变成了这样：
Banana.peel(a，1)；
Banana.peel(b，2)；
提示：个人认为，这是在编译以后，编译器做好的幕后工作。编译以后，编译器将所有的引用分别作为所有方法的第一个参数放进了方法中。
这是内部的表示形式，我们并不能这样书写代码，并试图通过编译。
假设你希望在方法内部获得对当前对象的引用，由于这个引用是由编译期"偷偷"传入的。所以没有标识符可用。但是，为此，有个专门的关键字：this。this关键字只能在方法内部使用，表示对"调用方法的那个对象"的引用。this的用法和其他对象引用并无不同。但要注意，如果在方法的内部调用同一个类的另一个方法，就不必使用this，直接调用既可，当前方法中的this引用会自动引用于同一个类的另一个方法。
代码示例：

// 同一个类中的方法互调
     //类名称Apricot
     public class Apricot{
        //方法pick();
        void pick(){}
        //方法pit()
        void pit(){
           //直接调用方法pick()，不用this.
           pick();
        }
     }

在pit()内部，你可以写this.pick()，但无此必要，编译器能帮你自动添加，只有当需要明确指出对当前对象的引用时，才需要使用this关键字，例如，当需要返回对当前对象的引用时，就常常在return语句里这样写：

// 返回当前对象的引用
     //类名称Leaf
     public class Leaf{
        //int类型变量i,初始化为0.
        int i = 0;
        //方法increment(),返回类型为Leaf.
        Leaf increment(){
           //i值+1.
           i++;
           //返回当前对象的引用.
           return this;
        }
        //方法print()
        void print(){
          //打印i值。
          Syatem.out.print("i="+i);
        }
        //程序执行入口方法main()
        public static void main(String[] args){
             //创建Leaf对象,名称为x。
             Leaf x = new Leaf();
             //多次调用方法increment()。
             //调用一次i值就+1.
             //因为调用increment()方法的结果就是返回当前对象。
             //所以可以进行多次调用.
             //也就是在同一条语句里对同一个对象执行多次操作。
             x.increment().increment().increment().print();
        }
     }

this关键字返回了对当前对象的引用，所以很容易在一条语句里对同一个对象执行多次操作。
this关键字对于将当前对象传递给其他方法也很有用：

// 将当前对象传递给其他方法
     //类Person
     class Person{
        //方法eat,带形式参数Apple类型。
        public void eat(Apple apple){
           //调用方法获得一个对象。
           Apple peeled = apple.getPeeled();
           //打印字符串"Yummy".
           System.out.print("Yummy");
        }
     }
     //类Peeler
     class Peeler{
         //静态类方法peel,带一个形式参数类型Apple.
         static Apple peel(Apple apple){
              //返回当前参数引用,也就是apple。
              return apple;
         }
     }
     //类Apple
     class Apple{
         //方法getPeeled,返回类型为Apple.
         Apple getPeeled(){
             //返回类型为Apple类型,Peeler.peel(this)返回的类型就是Apple。
             //将当前对象的引用作为实际参数传入(this代表的就是当前对象的引用)
             return Peeler.peel(this);
         }
         //Apple调用了外部的方法(Peeler的peel()方法),有的时候你必须这么做,
         //将执行由于某种原因而必须放在Apple外部的操作(比如你不想重复代码,
         //将一个功能专门写在了一个类中),为了将其自身传递给外部方法,
         //必须使用关键字this。
         //如果不懂上面的举例:可能存在一个工具类，专门接受对象的引用,
         //然后执行相应的代码。这种工具类都会是外部类,而并不是每次需要的时候
         //都写一遍。相对于每次写一遍,我们更愿意只传递一个引用。
     }
     //类PassingThis
     public class PassingThis{
         //程序执行入口方法main.
         public static void main(String[] args){
            //创建Person对象，调用eat方法,传入的实际对象是一个Apple对象。
            new Person().eat(new Apple());
            //解析一下执行结果,从这里开始梳理程序执行代码顺序。
            //首先是创建了Person对象,但是Person没有构造方法。
            //而是直接调用了eat()方法。eat()方法需要一个Apple类型的参数。
            //所以直接创建了一个Apple对象，Apple也没有构造方法。
            //直接进入了eat方法体。
            //Apple peeled = apple.getPeeled();通过Apple类型的getPeeled()
            //方法获得了一个Apple对象,引用名称是peeled.
            //进入Apple的getPeeled()方法:return Peeler.peel(this);
            //直接进入的是Peeler类的peel方法,同时传入了一个引用this，这个this
            //实际代表的就是new Person().eat(new Apple());里面的new Apple();
            //这个对象的引用。
            //Peeler的peel方法需要一个Apple类型的对象作为实际参数,
            //返回这个对象的引用。
            //这段代码就是为了演示而创建的。实际到最后就是返回了new 
            //Person().eat(new Apple());中new Apple()创建的这个对象的引用。
            //结果只会打印一个"Yummy"字符串。
         }
     }

结果示例：

PS：时间有限，有关Java SE的内容会持续更新！今天就先写这么多，如果有疑问或者有兴趣，可以加QQ：2649160693，并注明CSDN，我会就博文中有疑义的问题做出解答。同时希望博文中不正确的地方各位加以指正！