一文带你了解java关键字this

一、概述

学习Java编程的时候，无论是谁，当学到面向对象这部分内容时都会遇到一个关键字：this。

很多初学者对这个关键字的都会感觉到理解不透，不明白这个神秘的”this”到底表示什么意思。

按照官方文档，this关键字的意义被解释为“指向当前对象的引用”。

这个解释非常准确并且很精炼，但它太过学术化了，导致很多初学者有点读不懂，更谈不上深入理解它的意义。

本文将用大白话的形式帮助初学Java的小伙伴来深入理解this关键字的意义，并且梳理它的各种用法。

二、应用场景

1、返回当前对象

使用"this"关键字可以从方法中返回当前对象的引用。这在需要链式调用方法或在方法内部引用当前对象时非常有用。

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public Person getName() {
        return this;  // 返回当前对象的引用
    }
}

2、在构造函数中调用父类构造函数

当一个类扩展另一个类时，在子类的构造函数中可以使用"super"关键字调用父类的构造函数。

然而，如果父类的构造函数需要使用当前对象的引用，可以使用"this"关键字来调用父类的构造函数。

public class Vehicle {
    private String brand;

    public Vehicle(String brand) {
        this.brand = brand;
    }
}

public class Car extends Vehicle {
    private String model;

    public Car(String brand, String model) {
        super(brand);  // 调用父类的构造函数
        this.model = model;
    }
}

3、解决命名冲突（解决构造函数重载冲突）

当一个类中存在局部变量、方法参数或内部类的成员变量与实例变量同名时，可以使用"this"关键字来引用实例变量，以解决命名冲突。

public class Person {
    private String name;

    public void setName(String name) {
        this.name = name;  // 使用"this"关键字引用实例变量
    }

    public void printName(String name) {
        System.out.println("Local variable: " + name);
        System.out.println("Instance variable: " + this.name);  // 使用"this"关键字引用实例变量
    }
}

4、内部类中使用外部类的实例

在内部类中，使用"this"关键字默认引用当前内部类的实例。如果需要引用外部类的实例，可以使用"外部类名.this"的形式。

public class OuterClass {
    private int num = 10;

    public class InnerClass {
        private int num = 20;

        public void printNum() {
            int num = 30;
            System.out.println("Local variable: " + num);
            System.out.println("Inner class variable: " + this.num);  // 内部类的实例变量
            System.out.println("Outer class variable: " + OuterClass.this.num);  // 外部类的实例变量
        }
    }
}

5、传递当前对象给其他方法

使用"this"关键字可以将当前对象作为参数传递给其他方法。这在需要将当前对象作为参数传递给其他对象或方法时非常有用。

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public void process() {
        OtherClass.doSomething(this);  // 将当前对象作为参数传递给其他方法
    }
}

6、构造函数链

使用"this"关键字可以创建构造函数链，其中一个构造函数调用另一个构造函数，最终所有的构造函数都会调用到一个具有完整参数列表的构造函数。

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

    public Person() {
        this("John", 0);  // 调用另一个构造函数
    }

    public Person(String name) {
        this(name, 0);  // 调用另一个构造函数
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
}

三、使用this的注意事项

1、用途和作用域

关键字"this"只能在实例方法、构造函数和实例初始化块中使用。它的作用域限定在当前对象的上下文中，用于引用当前对象的成员和方法。

2、方法链式调用

使用"this"关键字可以实现方法链式调用。方法链式调用是一种编程风格，允许在同一个对象上连续调用多个方法，通过在每个方法中返回"this"来实现。

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

    public Person setName(String name) {
        this.name = name;
        return this;  // 返回当前对象的引用，实现方法链式调用
    }

    public Person setAge(int age) {
        this.age = age;
        return this;  // 返回当前对象的引用，实现方法链式调用
    }
}

// 使用方法链式调用
Person person = new Person().setName("John").setAge(25);

3、匿名内部类中使用

"this"关键字在匿名内部类中具有特殊含义。在匿名内部类中，"this"关键字引用的是匿名内部类的实例，而不是包含它的外部类的实例。为了引用外部类的实例，可以使用外部类的类名加上"this"关键字。

public class OuterClass {
    private int num = 10;

    public void method() {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                int num = 20;
                System.out.println(num);           // 输出：20
                System.out.println(this.num);      // 输出：0 （匿名内部类的成员变量）
                System.out.println(OuterClass.this.num);  // 输出：10 （外部类的成员变量）
            }
        };
        runnable.run();
    }
}

4、静态方法中的限制

由于静态方法不属于任何实例对象，因此无法在静态方法中使用"this"关键字。"this"只能在实例方法和构造函数中使用。

5、安全性和线程同步

在多线程环境下，使用"this"关键字引用当前对象时需要注意线程同步问题。确保适当的同步机制（如锁）用于保护共享资源，以避免并发访问导致的数据不一致性和线程安全问题。

6、冲突解析

当实例变量、方法参数和局部变量与实例方法中的参数或成员变量同名时，使用"this"关键字可以明确指示引用的是实例成员。这样可以避免命名冲突，但也需要小心使用，以确保正确解析变量引用。

7、空指针异常

在某些情况下，使用"this"关键字可能导致空指针异常。如果在一个构造函数中使用"this"关键字来调用其他构造函数，并且没有正确初始化对象的所有成员变量，那么在使用这些成员变量时可能会引发空指针异常。

8、不必要的使用

有时候，在代码中使用"this"关键字可能是多余的，尤其当没有命名冲突时。可以根据个人偏好和代码风格，决定是否使用"this"关键字来明确引用实例成员。

四、this在什么情况下不能忽略（90%都是可以忽略的）

1、解决命名冲突

当一个类中存在与实例变量同名的局部变量或方法参数时，可以使用"this"关键字来引用实例变量，以区分它们之间的命名冲突。

public class MyClass {
    private int value;

    public void setValue(int value) {
        // 通过使用"this.value"，将方法参数的值分配给实例变量。
        this.value = value; // 使用"this"引用实例变量
    }
}

2、在构造函数中调用其他构造函数

当一个类中存在多个构造函数时，可以使用"this"关键字来调用其他构造函数。这通常用于避免代码重复，以及在构造函数链中执行特定的初始化操作。

public class MyClass {
    private int value;

    public MyClass() {
        this(0); // 调用带有参数的构造函数
    }

    public MyClass(int value) {
        this.value = value;
    }
}

3、作为方法参数传递当前对象

有时候，我们可能需要将当前对象作为参数传递给其他方法。

public class MyClass {
    private int value;

    public void doSomething() {
        anotherMethod(this); // 将当前对象作为参数传递给另一个方法
    }

    public void anotherMethod(MyClass obj) {
        // 使用传递的对象进行操作
    }
}

4、返回当前对象

有时候，在一个方法中需要返回当前对象本身。

public class MyClass {
    private int value;

    public MyClass setValue(int value) {
        this.value = value;
        return this; // 返回当前对象
    }
}

五、特别注意

重点：this() 这种语法只能出现在构造方法中的第一行。

public class MyClass {
    private int value;

    public MyClass() {
        this(0); // this() 这种语法只能出现在构造方法中的第一行
        System.out.println("XXXX");
    }

    public MyClass(int value) {
        this.value = value;
    }
}