在 Java 面向对象编程中，this 和 super 关键字是连接类与对象、父类与子类的核心桥梁。无论是区分变量作用域、复用构造逻辑，还是实现继承体系中的方法调用，这两个关键字都扮演着不可替代的角色。本文将结合实战代码，详细拆解它们的核心用法、底层原理及避坑指南。

---

一、this 关键字详解：指向当前对象的引用

this 关键字本质是当前对象的引用，仅能在非静态方法和构造器中使用，核心作用集中在以下 6 个场景：

1. 区分成员变量与局部变量（最常用）

当方法参数或局部变量与类的成员变量同名时，this 可明确指定访问成员变量：

public class User {
    private String name;
    private int age;

    // 构造方法中区分同名变量
    public User(String name, int age) {
        this.name = name; // this.name 指代成员变量
        this.age = age;  // 局部变量age赋值给成员变量
    }

    // 普通方法中区分同名变量
    public void updateName(String name) {
        System.out.println("原名称：" + this.name);
        this.name = name; // 更新成员变量值
    }
}

2. 调用本类的其他构造方法（构造器重载复用）

通过this(参数列表)可调用本类其他构造器，需注意必须作为构造方法的第一条语句：

public class Person {
    private String name;
    private int age;

    // 无参构造器：调用两参构造器设置默认值
    public Person() {
        this("无名氏", 18); // 必须位于第一行
        System.out.println("无参构造器执行");
    }

    // 单参构造器：调用两参构造器设置默认年龄
    public Person(String name) {
        this(name, 18); // 复用初始化逻辑
    }

    // 主构造器：统一初始化逻辑
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
// 测试：new Person() 输出顺序：
// （先执行被调用的两参构造器，再执行无参构造器剩余逻辑）

3. 调用本类的普通方法

可显式使用this.方法名()调用当前类方法（通常可省略 this，但复杂场景能提升可读性）：

public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }

    public void printResult(int a, int b) {
        int result = this.add(a, b); // 等价于 add(a, b)
        System.out.println("计算结果：" + result);
    }
}

4. 作为参数传递给其他方法

将当前对象作为参数传递，常用于回调机制或对象交互场景：

public class Order {
    private String orderId;

    public void submitOrder() {
        // 将当前订单对象传递给支付服务
        PaymentService.processPayment(this);
    }

    // getter/setter 略
}

class PaymentService {
    public static void processPayment(Order order) {
        System.out.println("处理订单支付：" + order.getOrderId());
    }
}

5. 作为构造方法的参数传递

在构造器中传递当前对象，适用于依赖当前实例的初始化场景：

public class Student {
    private String name;
    private StudentCard card;

    // 构造器中传递this给其他对象
    public Student(String name) {
        this.name = name;
        this.card = new StudentCard(this); // 将当前Student实例传递给StudentCard
    }

    public String getName() { return name; }
}

class StudentCard {
    private Student owner;

    public StudentCard(Student owner) {
        this.owner = owner;
        System.out.println("为学生：" + owner.getName() + " 创建校园卡");
    }
}

6. 作为方法返回值（实现链式调用）

返回当前对象引用，支持方法链式调用，常见于 Builder 模式：

public class UserBuilder {
    private String name;
    private int age;

    // 返回this实现链式调用
    public UserBuilder setName(String name) {
        this.name = name;
        return this; // 返回当前对象
    }

    public UserBuilder setAge(int age) {
        this.age = age;
        return this;
    }

    public User build() {
        return new User(name, age);
    }
}

// 使用示例：链式调用简洁优雅
User user = new UserBuilder()
    .setName("云扬")
    .setAge(28)
    .build();

---

二、super 关键字详解：连接子类与父类的桥梁

super 关键字用于引用当前对象的父类实例，核心作用是访问父类成员（变量、方法、构造器），解决继承体系中的访问冲突问题：

1. 调用父类的构造方法

通过super(参数列表)显式调用父类构造器，必须位于子类构造器第一行（JDK 25 + 支持灵活顺序，但兼容起见建议遵循传统规范）：

// 父类
class Animal {
    private String name;
    private int age;

    // 父类带参构造器
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
        System.out.println("Animal构造器执行");
    }
}

// 子类
class Dog extends Animal {
    private String breed;

    // 子类构造器：调用父类带参构造器
    public Dog(String name, int age, String breed) {
        super(name, age); // 必须在第一行，初始化父类部分
        this.breed = breed;
        System.out.println("Dog构造器执行");
    }
}

// 测试：new Dog("Buddy", 3, "拉布拉多")
// 输出顺序：Animal构造器执行 → Dog构造器执行

注意：若父类无无参构造器，子类必须显式调用父类带参构造器，否则编译报错。

2. 调用父类的普通方法（尤其是被重写的方法）

当子类重写父类方法后，可通过 super 访问父类的原始实现：

class Father {
    public void sayHello() {
        System.out.println("父类：Hello World");
    }
}

class Son extends Father {
    @Override
    public void sayHello() {
        super.sayHello(); // 调用父类的sayHello方法
        System.out.println("子类：Hello Java");
    }
}

// 测试：new Son().sayHello()
// 输出：父类：Hello World → 子类：Hello Java

3. 访问父类的成员变量

当子类与父类存在同名成员变量时，super 可直接访问父类变量：

class Parent {
    protected String msg = "父类消息";
}

class Child extends Parent {
    private String msg = "子类消息";

    public void printMsg() {
        System.out.println("子类消息：" + msg);       // 访问子类变量
        System.out.println("父类消息：" + super.msg); // 访问父类变量
    }
}

---

三、this 与 super 核心区别对比

对比维度	this 关键字	super 关键字
本质含义	当前对象的引用	父类对象的引用
适用场景	本类内部（非静态环境）	子类内部（继承场景）
构造器调用	this (…) 调用本类构造器	super (…) 调用父类构造器
方法调用	访问本类方法（可省略）	访问父类方法（重写后需显式）
变量访问	访问本类成员变量	访问父类成员变量
共存规则	不能与 super (…) 同时出现在构造器第一行	不能与 this (…) 同时使用
静态环境	不可使用（无对象上下文）	不可使用（无对象上下文）

---

四、避坑指南：这些错误千万别犯

1. 构造器中 this (…) 和 super (…) 不能共存：两者都要求位于构造器第一行，同时使用会编译报错；
2. 避免构造器循环调用：如 A 构造器调用 B，B 又调用 A，会导致 StackOverflowError；
3. 静态方法中不能使用 this/super：静态方法属于类级别的方法，无对象实例，使用会直接编译失败；
4. JDK 版本兼容问题：JDK 25 + 支持 super (…) 不在构造器第一行，但低版本仍需遵循传统规范；
5. 不要滥用 this：普通方法中访问本类成员时，若无命名冲突，可省略 this 以简化代码。

---

总结

this 和 super 关键字是 Java 面向对象特性的重要体现：this 聚焦于当前对象的内部交互，解决变量区分、构造复用等问题；super 则专注于父子类的继承协作，确保父类资源的正确访问和初始化。理解它们的核心区别和使用场景，能让代码更简洁、逻辑更清晰。

建议结合实际开发场景多做练习，比如在实体类构造器中使用 this 复用逻辑，在子类重写方法时用 super 保留父类功能，逐步形成肌肉记忆。如果遇到复杂继承体系中的访问问题，可通过 debug 跟踪 this 和 super 的指向，快速定位问题根源。