java 编程思想笔记之this关键字（包括一些对方法在内存中的分配的解析）

This 关键字：只能在方法内部使用，表示对“调用方法的那个对象”的引用。

Leaf.java

public class Leaf {
             private int i = 0;
            Leaf increment() {
                i++;
                 return this;
            }
             void print() {
                System.out.println( "i = " + i);
            }
             public static void main(String[] args) {
                Leaf x = new Leaf();
                 //increment方法被对象x调用，这方法内的this指向x对象。
                x.increment().increment().increment().print();
            }
}

 

通常，当我们说 this 的时候，都是指 “ 这个对象 ” 或者 “ 当前对象 ” 。而且它本身会产生当前对象的一个引用。在一个构建器中，若为其赋予一个参数列表，那么 this 关键字会具有不同的含义：它会对与那个参数列表相符的构建函数进行明确的调用。这样一来，我们就可通过一条直接的途径来调用其他构建函数。

City.java

public class City {
         private double code;
         private String name;    
         //构造函数
         public City( double code) {
             this.code = code;
        }
         public City(String name){
             this.name = name;
        }
         public City( double code, String name) {
             this(code);
             //在一个构造函数中只能通过this调用一次其他构造函数
             this(name); //将会报错
             this.name = name;
        }        
         //get方法
         public double getCode() {
             return code;
        }        
         public String getName() {
             return name;
        }
        
         public static void main(String[] args){
             String str = "凤山";
             City city1 = new City(str);
             City city2 = new City(str);
//方法在内存中只保存有一份。那怎样知道getName方法是被哪个对象调用？通过this知道。当city1调用getName方法时，this就相当于city1的引用，当city2调用getName方法时，this就相当于city2的引用。
             System.out.println(city1.getName());
             System.out.println(city2.getName());
        }
}

由于以上例子说到了方法在内存中只保存有一份，这里就解析一下方法的存储（个人理解） ： 一个程序所占用的的内存，分为存储代码片段，存储数据片段和程序申请分配的内存（堆和栈）。方法作为程序代码片段，是不存在任何申请分配的问题的，因此既不会在堆中，也不会在堆栈中。

以下再截个图上来好理解（此图出自尚学堂视频）：

现在知道了方法做为代码片段是存储在一个专门存储代码片段的内存中的，所以对于多个实例对象，它们共享这个方法代码片段。既然这样，对于上述例子中的 getName() 方法被 city1 和 city2 两个实例调用， getName() 方法是如何判断到底是哪个实例调用它的 name 值的呢？对了，它是通过 this 关键字来判断的。其实在 getName() 的方法中它隐藏了 this 关键字，它的写法可以是以下这样：

         public String getName() {
             return this.name;
        }

在笔记开始我就写了 this 关键字表示对“调用方法的那个对象”的引用。现在明白了吧，当 city1 调用 getName 方法时， this 就相当于 city1 的引用，当 city2 调用 getName 方法时， this 就相当于 city2 的引用。所以虽然方法片段只有一份，但它可以通过 this 来区分引用。

总结： 1. this 关键字只能在方法内部使用，表示对“调用方法的那个对  象”的引用。

         2. 在一个构造函数中只能通过 this 调用一次其他构造函数。

3. 方法片段在内存中只保存有一份，所以不同的实例调用方法时是通过 this 关键字来区分方法中的属性。