3.5 this关键字

1. this 是谁——"当前"由谁决定

3.3 学过"this 读作'我这个'"，但留了个尾巴：方法里的 this，凭什么知道自己是哪辆车？ 堆里明明停着 car1、car2 两辆，setPrice 只有一份代码，它怎么不装错车？

答案在上面那张图里：this 是方法自带的一个隐形参数，值 = 调用者的地址。

car1.setPrice(100);   // 执行 setPrice 时，this = car1（0xAA01）
car2.setPrice(200);   // 执行 setPrice 时，this = car2（0xBB02）

规则只有一条：谁调用，this 就是谁。同一份方法代码，每次执行时 this 换成不同的调用者——这就是"当前对象"的含义。

和 3.2 的栈/堆呼应：方法代码只有一份（跟着类走），但每个对象各有自己的属性格子（在堆里）。this 就是方法执行时拿到的"本人地址"，靠它操作到正确的格子——3.2 说的"钥匙开对应的车"，this 就是那把正在用的钥匙。

2. 用法一：this.属性——区分撞名（复习 + 收网）

3.3 讲过的内容，这里正式收网：

public class Car {
    private String brand;   // 属性

    public void setBrand(String brand) {   // 参数撞名了
        this.brand = brand;
        //     ↑属性     ↑参数（就近原则，直接写 brand 指参数）
    }
}

不撞名时 this. 可以省——但省不省不影响语义：

public void setPrice(double p) {
    this.price = p;   // 写全，等价于 price = p;
}

3. 用法二：this.方法()——喊本类的方法

方法里可以喊本类的其他方法：

public void run() {
    this.check();   // this. 可以省，写成 check() 一个意思
    System.out.println(brand + " 在跑");
}

同一个对象内部互喊方法，this. 通常省略——IDEA 里写了它还会提示你"冗余"。知道有这用法即可，重点在用法三。

4. 用法三：this(...)——构造方法互调（本节重点）

3.4 的 Car 类里，无参构造和带参构造各自干各的：

public Car() {
    this.brand = "未知品牌";    // 赋值逻辑写了一遍
}

public Car(String brand, double price) {
    this.brand = brand;          // 又写了一遍！
    this.setPrice(price);
}

问题：赋值/安检逻辑散在两个构造里，将来改一处忘一处就出 bug。解法——让一个构造方法调用另一个：

public class Car {
    private String brand;
    private double price;

    public Car() {
        this("未知品牌", 0);      // ← 把出生设置转发给带参构造，一行搞定
    }

    public Car(String brand, double price) {
        this.brand = brand;        // 真正的赋值逻辑只在这里写一遍
        this.setPrice(price);      // 安检也只走这一处
    }
}

this("未知品牌", 0); 读作："按带参的方式出生一次，参数是这两个"——无参构造不再自己干活，只当个"转发前台"。所有赋值和安检都收拢在带参构造一处，这正是 3.3"把变化圈在一处"的延续。

5. 什么时候用哪个——一张表

6. 动手部分：用 this(...) 收拢构造逻辑

第 1 步：在 IDEA02 里新建类 Employee（员工，换个人物练）：

public class Employee {
    private String name;
    private double salary;

    // 无参构造：只当转发前台，自己不干活
    public Employee() {
        this("未录入", 3000);       // 默认底薪 3000
    }

    // 只给名字：工资走默认
    public Employee(String name) {
        this(name, 3000);           // ← 转发给全参构造
    }

    // 全参构造：唯一的赋值现场
    public Employee(String name, double salary) {
        this.name = name;
        if (salary >= 0) {
            this.salary = salary;
        } else {
            System.out.println("工资不能为负，按 0 入职");
            this.salary = 0;
        }
    }

    public String getName() { return name; }
    public double getSalary() { return salary; }

    public void showInfo() {
        System.out.println("员工：" + name + "，工资：" + salary);
    }
}

第 2 步：新建测试类 TestEmployee：

public class TestEmployee {
    public static void main(String[] args) {
        Employee e1 = new Employee();
        Employee e2 = new Employee("波仔");
        Employee e3 = new Employee("老板", -50);

        e1.showInfo();   // 员工：未录入，工资：3000.0
        e2.showInfo();   // 员工：波仔，工资：3000.0
        e3.showInfo();   // 工资不能为负，按 0 入职 → 员工：老板，工资：0.0
    }
}

看到什么算成功：三行输出，其中 e3 先打印安检提示。注意 赋值和安检的代码全类只出现了一处（全参构造里）——这就是 this(...) 的价值。

三个 30 秒实验：

1. 把 this("未录入", 3000); 挪到构造方法的第二行（前面加一行打印）——编译报错"必须是构造器中的第一个语句"，亲眼确认铁律 1
2. 在 Employee() 里调 this(...)，同时在 Employee(String, double) 里也调 this()——报错"递归构造器调用"，确认铁律 2
3. showInfo 里的 name 前面补上 this.——照常运行，体会用法一"不撞名可省"

7. 常见误区

8. 自测题

9. 下一步学什么

• ☑ 3.5 this关键字 ✅ "我这个"从此有明确的主人：谁调用，this 就是谁
• ☑ 3.6 代码块 ✅ 已完成——三种 { } 的出场时机排好了队（静态一次 → 构造块每次 → 构造方法收尾），static 混了个脸熟，详见 3.6 代码块

相关笔记

• 3.4 构造方法 ← 上一篇：this(...) 互调的舞台就是它
• 3.3 封装性 ← this.属性 区分撞名第一次登场
• 3.2 类与对象 ← 栈钥匙/堆实物，this 就是"正在用的那把钥匙"
• 2.6 方法 ← this 是方法自带的隐形参数
• 📇 Java基础 · 索引
• 🏠 返回主页