this关键字笔记

this关键字

this的介绍

如果有两个同类型的对象，分别叫作a 和b，那么您也许不知道如何为这两个对象同时调用一个 f()方法：

class Banana { void f(int i) { /* ... */ } }

Banana a = new Banana(), b = new Banana();

a.f(1);

b.f(2);

若只有一个名叫f()的方法，它怎样才能知道自己是为 a 还是为 b 调用的呢？

为了能用简便的、面向对象的语法来书写代码——亦即“将消息发给对象”，编译器为我们完成了一些幕后

工作。其中的秘密就是第一个自变量传递给方法f()，而且那个自变量是准备操作的那个对象的句柄。所以

前述的两个方法调用就变成了下面这样的形式：

Banana.f(a,1);

Banana.f(b,2);

这是内部的表达形式，我们并不能这样书写表达式，并试图让编译器接受它。但是，通过它可理解幕后到底

发生了什么事情.

this 关键字（注意只能在方法内部使用)可为已调用了其方法的那个对象生成相应的句柄。可像对待其他任何对象句柄一样对待这个句柄。但要注意，假若准备从自己某个类的另一个方法内部调用一个类方法，就不必使用this。只需简单地调用那个方法即可。当前的this 句柄会自动应用于其他方法。

this 关键字只能用于那些特殊的类——需明确使用当前对象的句柄。例如，假若您希望将句柄返回给当前对象，那么它经常在return 语句中使用。

如下：

package com.xu.javaoop;

//: Leaf.java
// Simple use of the "this" keyword
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();
        x.increment().increment().increment().print();
    }
} ///:~

结果：

i = 3

Process finished with exit code 0

由于increment()通过 this 关键字返回当前对象的句柄，所以可以方便地对同一个对象执行多项操作。

在构建器里调用构建器

若为一个类写了多个构建器，那么经常都需要在一个构建器里调用另一个构建器，以避免写重复的代码。可

用this 关键字做到这一点。

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

package com.xu.javaoop;

//: Flower.java
// Calling constructors with "this"
public class Flower {
    private int petalCount = 0;
    private String s = new String("null");

    Flower(int petals) {
        petalCount = petals;
        System.out.println(

                "Constructor w/ int arg only, petalCount= "
                        + petalCount);
    }

    Flower(String ss) {
        System.out.println(
                "Constructor w/ String arg only, s=" + ss);
        s = ss;
    }

    Flower(String s, int petals) {
        this(petals);
//! this(s); // Can't call two!
        this.s = s; // Another use of "this"
        System.out.println("String & int args");
    }

    Flower() {
        this("hi", 47);
        System.out.println(
                "default constructor (no args)");
    }

    void print() {
//! this(11); // Not inside non-constructor!
        System.out.println(
                "petalCount = " + petalCount + " s = " + s);
    }

    public static void main(String[] args) {
        Flower x = new Flower();
        x.print();
    }
} ///:~

运行结果：

Constructor w/ int arg only, petalCount= 47
String & int args
default constructor (no args)
petalCount = 47 s = hi

Process finished with exit code 0

其中，构建器Flower(String s,int petals)向我们揭示出这样一个问题：尽管可用this 调用一个构建器，

但不可调用两个。除此以外，构建器调用必须是我们做的第一件事情，否则会收到编译程序的报错信息。

这个例子也向大家展示了this 的另一项用途。由于自变量s 的名字以及成员数据s 的名字是相同的，所以会

出现混淆。为解决这个问题，可用 this.s 来引用成员数据。

static 的含义

理解了 this 关键字后，我们可更完整地理解 static（静态）方法的含义。它意味着一个特定的方法没有

this。我们不可从一个 static 方法内部发出对非 static 方法的调用（注释②），尽管反过来说是可以的。

而且在没有任何对象的前提下，我们可针对类本身发出对一个 static 方法的调用。事实上，那正是 static

方法最基本的意义。它就好象我们创建一个全局函数的等价物（在C 语言中）。除了全局函数不允许在 Java

中使用以外，若将一个 static 方法置入一个类的内部，它就可以访问其他static 方法以及static 字段。

②：有可能发出这类调用的一种情况是我们将一个对象句柄传到static 方法内部。随后，通过句柄（此时实

际是this），我们可调用非 static 方法，并访问非static 字段。但一般地，如果真的想要这样做，只要制

作一个普通的、非 static 方法即可。

对象初始化过程

要总结一下对象的创建过程。请考虑一个名为 Dog 的类：

(1) 类型为 Dog 的一个对象首次创建时，或者 Dog 类的static 方法／static 字段首次访问时，Java 解释器

必须找到Dog.class（在事先设好的类路径里搜索）。

(2) 找到Dog.class 后（它会创建一个 Class 对象，这将在后面学到），它的所有 static 初始化模块都会运

行。因此，static 初始化仅发生一次——在 Class 对象首次载入的时候。

(3) 创建一个new Dog()时，Dog 对象的构建进程首先会在内存堆（Heap）里为一个 Dog 对象分配足够多的存

储空间。

(4) 这种存储空间会清为零，将Dog 中的所有基本类型设为它们的默认值（零用于数字，以及 boolean 和

char 的等价设定）。

(5) 进行字段定义时发生的所有初始化都会执行。

(6) 执行构建器。