Java面向对象（进阶）-- this关键字的使用

文章目录

一、引子
- （1） this是什么？
- （2）什么时候使用this
- - 1.实例方法或构造器中使用当前对象的成员
  - 2. 同一个类中构造器互相调用
二、探讨
- （1）问题
- （2）解决
三、this关键字
- （1）this调用属性和方法
- - 方法内
  - 构造器内
- （2）this调用构造器
四、总结
五、练习
- （1）练习1
- （2）练习2

一、引子

（1） this是什么？

在Java中，this关键字不算难理解，它的作用和其词义很接近。
- 它在方法（准确的说是实例方法或非static的方法）内部使用，表示调用该方法的对象
- 它在构造器内部使用，表示该构造器正在初始化的对象。
this可以调用的结构：成员变量、方法和构造器

（2）什么时候使用this

1.实例方法或构造器中使用当前对象的成员

在实例方法或构造器中，如果使用当前类的成员变量或成员方法可以在其前面添加this，增强程序的可读性。不过，通常我们都习惯省略this。

但是，当形参与成员变量同名时，如果在方法内或构造器内需要使用成员变量，必须添加this来表明该变量是类的成员变量。即：我们可以用this来区分成员变量和局部变量。比如：

另外，使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。这个在继承中会讲到。

2. 同一个类中构造器互相调用

this可以作为一个类中构造器相互调用的特殊格式。

this()：调用本类的无参构造器
this(实参列表)：调用本类的有参构造器

注意：

不能出现递归调用。比如，调用自身构造器。
- 推论：如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
this()和this(实参列表)只能声明在构造器首行。
- 推论：在类的一个构造器中，最多只能声明一个"this(参数列表)"

二、探讨

（1）问题

目前可能出现的问题？及解决方案？

我们在声明一个属性对应的setXxx方法时，通过形参给对应的属性赋值。如果形参名和属性名同名了，那么该如何在方法内区分这两个变量呢？

解决方案：使用this。具体来讲，使用this修饰的变量，表示的是属性。没有用this修饰的，表示的是形参。

【举例】

看下面的代码：

public class PersonTest {

}
class Person{
    //属性
    String name;
    int age;

    //方法
    public void setAge(int a){
        age=a;
    }
}

以往，写方法的时候，刻意将形参名与属性名避开了：

可以进一步在main方法里面输出看一下结果：

public class PersonTest {
    public static void main(String[] args) {
        Person p1=new Person();
        p1.setAge(10);
        System.out.println(p1.age);
    }
}
class Person{
    //属性
    String name;
    int age;

    //方法
    public void setAge(int a){
        age=a;
    }
}

输出：

我们知道，定义变量的时候，变量名其实是一个标识符，定义标识符要求“见名知意”。但是这里的形参a与age没什么联系。
构造器里面也一样，这样写过于抽象，如下：

class Person{
    //属性
    String name;
    int age;
    String email;
    
    //构造器
    public Person(){
        
    }
    public Person(String n,String a){
        name=n;
        email=e;
    }
    
    
    //方法
    public void setAge(int a){
        age=a;
    }
}

这里鼓励大家，把形参名写的与属性名一致。这样更加明了，不会变得很抽象。

但是这样来写又出问题了：（注意看方法）

public class PersonTest {
    public static void main(String[] args) {
        Person p1=new Person();
        p1.setAge(10);
        System.out.println(p1.age);
    }
}
class Person{
    //属性
    String name;
    int age;

    //方法
    public void setAge(int age){
        age=age;
    }
}

可以看到，setAge方法里面得age分不清是什么了，是形参还是属性？

这里有一个就近原则，setAge方法里面的age都是形参。

运行结果可以看到并没有赋上值：

（2）解决

解决方法很简单，只需要在想表示为属性的变量前面加上this.即可。

就像这样：

 //方法
    public void setAge(int age){
        this.age=age;
    }

再次调用一下试试：

public class PersonTest {
    public static void main(String[] args) {
        Person p1=new Person();
        p1.setAge(10);
        System.out.println(p1.age);
    }
}
class Person{
    //属性
    String name;
    int age;

    //方法
    public void setAge(int age){
        this.age=age;
    }
}

结果赋上值了：

上面的场景下，this属于必须要用的。（区分属性和形参）

如果要写get方法：

public int getAge(){
    return this.age;
}

这里的getAge方法并没有形参，所以下面的this.age的this.可加可不加，age肯定是属性。

但是刚才的setAge方法里面，this.是必须要加上的，因为有了形参，加上this以示区分形参与属性。

再看这段代码：

public class PersonTest {
    public static void main(String[] args) {
        Person p1=new Person();
        p1.setAge(10);
        System.out.println(p1.age);
    }
}
class Person{
    //属性
    String name;
    int age;

    //方法
    public void setAge(int age){
        this.age=age;
    }
}

这里的this可以理解为：当前属性所属的对象。

这个案例中，main方法里：p1.setAge(10);我们拿p1调用的setAge。这里的p1就充当了setAge方法里面的this。

当然，setAge方法里面的this不能写成p1，因为是先创建类，再创建对象。而且根本事先不知道对象是谁，这里肯定是需要动态的表示对象。这里所谓的动态，就是this来表示的。

这个this，就表示当前对象，谁调用setAge方法，这个this对象就是谁。比如刚才调用p1.setAge(10);那么p1就是this。

方法里面可以调属性，谁调用这个方法，这个属性就是谁的。

构造器一致。如下：

public class PersonTest {
    public static void main(String[] args) {    
        Person p2=new Person("Tom","tom@126.com");//声明完之后，也能给属性赋值
        System.out.println("name="+p2.name+",email="+p2.email);
    }
}
class Person{
    //属性
    String name;
    int age;
    String email;

    //构造器
    public Person(){

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

这里的this理解为：当前正在创建的对象。在当前案例中，this就是执行完之后的p2。

输出结果为：

三、this关键字

（1）this调用属性和方法

方法内

【针对于方法内的使用情况】（准确的说是非static修饰的方法）

this理解为：当前对象

1.一般情况：我们通过对象a调用方法，可以在方法内调用当前对象a的属性或其他方法。

此时，我们可以在属性和其他方法前使用"this."，表示当前属性或方法所属的对象a。但是，一般情况下，我们都选择省略此"this."结构。（没有局部变量）

2.特殊情况：如果方法的形参与对象的属性同名了，我们必须使用"this."进行区分。

使用this.修饰的变量即为属性（或成员变量），没有使用this.修饰的变量，即为局部变量。

构造器内

【针对于构造器内的使用情况】

this理解为：当前正在创建的对象

1.一般情况：我们通过构造器创建对象时，可以在构造器内调用当前正在创建的对象的属性或方法。

此时，我们可以在属性和方法前使用"this."，表示当前属性或方法所属的对象。但是，一般情况下，我们都选择省略此"this."结构。

2.特殊情况：如果构造器的形参与正在创建的对象的属性同名了，我们必须使用"this."进行区分。

使用this.修饰的变量即为属性（或成员变量），没有使用this.修饰的变量，即为局部变量。

（2）this调用构造器

【案例】

💬疑问

看下面代码：

class User{
    //属性
    String name;
    int age;

    //构造器
    public User(){
        //模拟对象创建时，需要初始化50行代码
    }
    public User(String name){
        //模拟对象创建时，需要初始化50行代码
        this.name=name;
    }
    public User(String name,int age){
        //模拟对象创建时，需要初始化50行代码
        this.name=name;
        this.age=age;
    }
}

如果在模拟对象创建时，需要初始化50行代码，而这50行代码每一个构造器都要加载。这怎么办呢？

首先想到的可能是定义一个方法，将50行代码写进去，然后再在构造器里面调用即可，比如init()方法：

class User{
    //属性
    String name;
    int age;

    //构造器
    public User(){
        init();
    }
    public User(String name){
        init();
        
        this.name=name;
    }
    public User(String name,int age){
        init();
        
        this.name=name;
        this.age=age;
    }

    //方法
    private void init(){
        //模拟对象创建时，需要初始化50行代码
        //...
    }
}

但是如果现在的构造器代码是这样的：

public User(String name){
        //模拟对象创建时，需要初始化30行代码
        this.name=name;
        //模拟对象创建时，需要初始化20行代码(这里面的代码又用到了name)
}

那么就可能需要定义好几个方法，会显得很复杂。

🤸解决

针对上面的疑问，可以这样来解决。

将这50行代码放在User()里面，后边的构造器直接调用它。

class User{
    //属性
    String name;
    int age;

    //构造器
    public User(){
        //模拟对象创建时，需要初始化50行代码
        //...
    }
    public User(String name){
        this();	//模拟对象创建时，需要初始化50行代码
        
        this.name=name;
    }
    public User(String name,int age){
    	this();	//模拟对象创建时，需要初始化50行代码
        
        this.name=name;
        this.age=age;
    }
}

使用this()表示调用的是当前空参的构造器，不要写成User()了，只是规定！！！

这里也可以这样调用：

代码：

class User{
    //属性
    String name;
    int age;

    //构造器
    public User(){
        //模拟对象创建时，需要初始化50行代码
        //...
    }
    public User(String name){
        this();    //模拟对象创建时，需要初始化50行代码

        this.name=name;
    }
    public User(String name,int age){
        this(name);    //模拟对象创建时，需要初始化50行代码
    	//this.name=name;
        this.age=age;
    }

}

💀问：既然执行User(String name,int age)方法中的this(name);语句，需要调用User(String name)和User()，那么会创建三个对象么？

不管在构造器里面直接/间接调用了几个重载的构造器，这里创建的对象只有一个。

之前说过构造器的作用之一是：搭配new关键字，创建类的对象。

在构造器里面互相调用并没有用到new关键字，更不用谈创建对象了。

代码：

public class UserTest {
    //只创建了User类的1个对象
    User u1=new User("Tom",14);
}
class User{
    //属性
    String name;
    int age;

    //构造器
    public User(){
        //模拟对象创建时，需要初始化50行代码
        //...
    }
    public User(String name){
        this();    //模拟对象创建时，需要初始化50行代码
        this.name=name;
    }
    public User(String name,int age){
        this(name);    //模拟对象创建时，需要初始化50行代码
        this.age=age;
    }

}

👻总结

1.格式：“this(形参列表)” —>形参列表可以是空的

我们可以在类的构造器中，调用当前类中指定的其它构造器。

不要自己调用自己，会无终止得调用下去。

2.要求："this(形参列表)"必须声明在当前构造器的首行

3.结论："this(形参列表)"在构造器中最多声明一个

4.如果一个类中声明了n个构造器，则最多有n-1个构造器可以声明有"this(形参列表)"的结构。

上边已经说了自己不能调自己，那调用别人呢？

比如，在User()构造器中调用User(String name,int age)构造器：this("Tom",20);

如下：

public User(){
    this("Tom",20);
    //模拟对象创建时，需要初始化50行代码
    //...
}
public User(String name){
	this();    //模拟对象创建时，需要初始化50行代码
	this.name=name;
}
public User(String name,int age){
    this(name);    //模拟对象创建时，需要初始化50行代码
    this.age=age;
}

这样会因为递归导致死循环：

可以互相调用，但不能导致闭环，要不然会死循环。

四、总结

1.this可以调用的结构：成员变量、方法、**构造器 **（不能是局部变量）

①成员变量

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

②方法

方法里面可以调用方法，如下面的sleep();

public void eat(){
    System.out.println("人吃饭");
    sleep();
}
public void sleep(){
    System.out.println("人睡觉");
}

其实，sleep();前面可以加上this.：

public void eat(){
    System.out.println("人吃饭");
    this.sleep();
}
public void sleep(){
    System.out.println("人睡觉");
}

谁调用eat方法，就拿这个对象去调用sleep()；之前没有写不代表没有this，只是省略了而已。

2. this的理解：当前对象（在方法中调用时） 或 当前正在创建的对象（在构造器中调用时）

五、练习

（1）练习1

🌋题目描述

根据图示，添加必要的构造器，综合应用构造器的重载，this关键字。

🤺代码

【Boy.java】

package yuyi01;

/**
 * ClassName: Boy
 * Package: yuyi01
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/27 0027 16:02
 */
public class Boy {
    //属性
    private String name;
    private int age;


    //方法
    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return this.name;   //此this可以省略
    }

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

    public int getAge(){
        return this.age;     //此this可以省略
    }

    public void marry(Girl girl){
        System.out.println("我想娶"+girl.getName());
    }

    public void shout(){
        if(this.age>=22){   //此this可以省略
            System.out.println("我终于可以带喜欢的人回家了");
        }else{
            System.out.println("我还要更加努力变得优秀");
        }
    }


    //构造器
    public Boy() {
    }

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

【Girl.java】

package yuyi01;

/**
 * ClassName: Girl
 * Package: yuyi01
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/27 0027 16:11
 */
public class Girl {
    //属性
    private String name;
    private int age;


    //方法
    public void setName(String name){
        this.name=name;
    }

    public String getName(){
        return this.name;   //此this可以省略
    }

    public void marry(Boy boy){
        System.out.println("我想嫁给"+boy.getName());

        boy.marry(this);
    }

    /**
     * 比较两个Girl对象的大小--调compare方法的girl和形参girl
     * @param girl--待比较的对象
     * @return 若返回值为正数，则表示当前对象大；若为负数，则表示当前对象小(或形参girl大)；若为0，则表示两者相等
     */
    public int compare(Girl girl){
        if(this.age>girl.age){  //如果当前对象的age大于形参对象的age，返回正数
            return 1;
        }else if(this.age<girl.age){    //如果当前对象的age小于形参对象的age，返回负数
            return -1;
        }else{  //如果当前对象的age等于形参对象的age，返回0
            return 0;
        }
    }

    //构造器
    public Girl() {
    }

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

【BoyGirlTest.java】

package yuyi01;

/**
 * ClassName: BoyGirlTest
 * Package: yuyi01
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/27 0027 17:06
 */
public class BoyGirlTest {
    public static void main(String[] args) {
        Boy boy1=new Boy("Jack",24);
        Girl girl1=new Girl("Luis",22);

        girl1.marry(boy1);
        boy1.shout();

        Girl girl2=new Girl("Cendy",20);
        int compare=girl1.compare(girl2);
        if(compare>0){
            System.out.println(girl1.getName()+"大");
        } else if (compare<0) {
            System.out.println(girl2.getName()+"大");
        }else{
            System.out.println(girl1.getName()+girl2.getName()+"一样大");
        }
    }
}

⚡输出结果

👻注意

【一个易错细节】

在Girl.java里面的marry方法，我们调用了boy.marry，里面的参数有可能会写错。

这里女孩说想嫁给男孩，男孩回应也想娶这个女孩。第二个图片是正确的：

具体原因看图：

在main方法里面执行marry方法：

【compare方法】

比较两个对象的大小，其实比较的是两个属性的大小。

/**
 * 比较两个Girl对象的大小--调compare方法的girl和形参girl
 * @param girl--待比较的对象
 * @return 若返回值为正数，则表示当前对象大；若为负数，则表示当前对象小(或形参girl大)；若为0，则表示两者相等
 */
public int compare(Girl girl){
    if(this.age>girl.age){  //如果当前对象的age大于形参对象的age，返回正数
        return 1;
    }else if(this.age<girl.age){    //如果当前对象的age小于形参对象的age，返回负数
        return -1;
    }else{  //如果当前对象的age等于形参对象的age，返回0
        return 0;
    }
}

【Tips1】一键生成get/set方法

比如现在只写了属性：

public class hello {
    private int apple;
    private int coffee;
}

然后想要生成get与set方法。
键盘同时按住Alt+Insert键，然后选择下面红框部分：

然后按住Crtl键，将两个都选中：

确定之后就可以自动生成了：

public class hello {
    private int apple;
    private int coffee;

    public int getApple() {
        return apple;
    }

    public void setApple(int apple) {
        this.apple = apple;
    }

    public int getCoffee() {
        return coffee;
    }

    public void setCoffee(int coffee) {
        this.coffee = coffee;
    }
}

【Tips2】一键生成构造器

现在我们想要生成构造器，还是同样键盘同时按住Alt+Insert键，然后选择下面红框部分：

如果只想生成空参构造器，那么点这个即可：

生成：

public hello() {
}

若要生成带参构造器，按住Ctrl键将它们都选中，然后确定即可：（根据需要选择参数）

生成：

public hello(int apple, int coffee) {
    this.apple = apple;
    this.coffee = coffee;
}

idea没有那么智能，它前后参数的顺序不是我们刚才点击的顺序，而是属性定义先后的顺序。

（2）练习2

🌋题目描述

1、按照UML类图，创建Account类，提供必要的结构。

在提款方法withdraw()中，需要判断用户余额是否能够满足提款数额的要求，如果不能，应给出提示。
deposit()方法表示存款。

2、按照UML类图，创建Customer类，提供必要的结构。

3、按照UML类图，创建Bank类，提供必要的结构。

addCustomer 方法必须依照参数（姓，名）构造一个新的 Customer对象，然后把它放到 customer 数组中。
还必须把 numberOfCustomer 属性的值加 1。
getNumOfCustomers 方法返回 numberofCustomers 属性值。
getCustomer方法返回与给出的index参数相关的客户。

4、创建BankTest类，进行测试。

🤺代码

【Account.java】

package yuyi02;

/**
 * ClassName: Account
 * Package: yuyi01
 * Description:
 *  账户类
 * @Author 雨翼轻尘
 * @Create 2023/10/27 0027 17:20
 */
public class Account {
    //属性
    private double balance; //余额

    //方法
    public double getBalance(){
        return balance;
    }

    public void deposit(double amt){    //存钱
        if(amt>0){
            balance+=amt;
            System.out.println("成功存入"+amt);
        }
    }

    public void withdraw(double amt){   //取钱
        if(balance>=amt && amt>0){
            balance-=amt;
            System.out.println("成功取出"+amt);
        }else{
            System.out.println("取款数额有误或余额不足");
        }
    }

    //构造器
    public Account(double init_balance){
        this.balance=init_balance;
    }
}

【Customer.java】

package yuyi02;

/**
 * ClassName: Customer
 * Package: yuyi01
 * Description:
 *  客户类
 * @Author 雨翼轻尘
 * @Create 2023/10/27 0027 17:20
 */
public class Customer {
    //属性
    private String firstName;   //名
    private String lastName;    //姓
    private Account account;    //账户


    //方法
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }


    public Account getAccount() {
        return account;
    }

    public void setAccount(Account account) {
        this.account = account;
    }


    //构造器
    public Customer(String f, String l) {
        this.firstName = f;
        this.lastName = l;
    }

}

【Bank.java】

package yuyi02;

/**
 * ClassName: Bank
 * Package: yuyi02
 * Description:
 *  银行类
 * @Author 雨翼轻尘
 * @Create 2023/10/27 0027 17:21
 */
public class Bank {
    //属性
    private Customer[] customers;   //用于保存多个客户
    private int numberOfCustomer;   //用于记录存储的客户的个数

    //构造器
    public Bank(){  //创建对象的时候就可以把数组创建好
        //数组赋值
        customers=new Customer[10]; //还可以在Bank里面写一个参数，将参数赋值给Customer[]，每次造对象的时候就可以指明一下数组的长度
    }

    //方法

    /**
     * 将指定姓名的客户保存在银行的客户列表中
     * @param f
     * @param l
     */
    public void addCustomer(String f,String l){
        //把f和l为代表的姓和名封装为一个客户对象
        Customer cust=new Customer(f,l);
        //然后把对象放到数组里面
        customers[numberOfCustomer]=cust;   //将创建的对象的地址赋值给customers数组的第numberOfCustomer的位置
        //每调用一次方法，就会记录一次客户的数量(加1)
        numberOfCustomer++;

    }

    /**
     * 获取客户列表中存储的客户个数
     * @return
     */
    public int getNumOfCustomers(){
        return numberOfCustomer;
    }

    /**
     * 获取指定索引位置上的客户
     * @param index
     * @return
     */
    public Customer getCustomer(int index){
        //先写有效/无效范围都行
        if(index<0 || index>=numberOfCustomer){   //无效范围 ，若有3个数，最大角标就是2，这里可以取等号
            return null;
        }else{
            return customers[index];
        }
    }

}

【BankTest.java】

package yuyi02;

/**
 * ClassName: BankTest
 * Package: yuyi02
 * Description:
 *
 * @Author 雨翼轻尘
 * @Create 2023/10/27 0027 17:21
 */
public class BankTest {
    public static void main(String[] args) {
        Bank bank=new Bank();
        //添加两个客户
        bank.addCustomer("飞","张");
        bank.addCustomer("备","刘");

        //获取客户名字(从数组中通过索引号获取)，然后通过setAccount来new一个账户，并且让初始余额为1000块钱
        bank.getCustomer(0).setAccount(new Account(1000));

        //获取客户名字(从数组中通过索引号获取)，然后通过getAccount获取它的账户，然后取出50块钱
        bank.getCustomer(0).getAccount().withdraw(50);
        System.out.println("账户余额为： "+bank.getCustomer(0).getAccount().getBalance());//查看余额
    }
}

输出结果

👻注意

1.【addCustomer方法】

public class Bank {
    //属性
    private Customer[] customers;   //用于保存多个客户
    private int numberOfCustomer;   //用于记录存储的客户的个数

    //方法

    /**
     * 将指定姓名的客户保存在银行的客户列表中
     * @param f
     * @param l
     */
    public void addCustomer(String f,String l){
        //把f和l为代表的姓和名封装为一个客户对象
        Customer cust=new Customer(f,l);
        //然后把对象放到数组里面
        customers[numberOfCustomer]=cust;
        //每调用一次方法，就会记录一次客户的数量(加1)
        numberOfCustomer++;

    }
}

这里还可以合并来写，不过要注意只能是后置++：

2.【index有效范围】

/**
     * 获取指定索引位置上的客户
     * @param index
     * @return
     */
    public Customer getCustomer(int index){
        //先写有效/无效范围都行
        if(index<0 || index>=numberOfCustomer){   //无效范围 ，若有3个数，最大角标就是2，这里可以取等号
            return null;
        }else{
            return customers[index];
        }
    }

如图：

if结构还可以这样来写，减少嵌套：

/**
 * 获取指定索引位置上的客户
 * @param index
 * @return
 */
public Customer getCustomer(int index){
//先写有效/无效范围都行
	if(index<0 || index>=numberOfCustomer){   //无效范围 ，若有3个数，最大角标就是2，这里可以取等号
        return null;
    }
     return customers[index]; 
}

3.【难点代码】

BankTest测试类里面，创建好两个对象之后：

Bank bank=new Bank();
//添加两个客户
bank.addCustomer("飞","张");
bank.addCustomer("备","刘");

①

//获取客户名字(从数组中通过索引号获取)，然后通过setAccount来new一个账户，
bank.getCustomer(0).setAccount(new Account(1000));

②

//获取客户名字(从数组中通过索引号获取)，然后通过getAccount获取它的账户，然后取出50块钱
bank.getCustomer(0).getAccount().withdraw(50);

③

System.out.println("账户余额为： "+bank.getCustomer(0).getAccount().getBalance());//查看余额

输出结果：

4.【内存结构剖析】

核心代码：

public class BankTest {
    public static void main(String[] args) {
        Bank bank=new Bank();
        //添加两个客户
        bank.addCustomer("飞","张");
        bank.addCustomer("备","刘");

        //获取客户名字(从数组中通过索引号获取)，然后通过setAccount来new一个账户，并且让初始余额为1000块钱
        bank.getCustomer(0).setAccount(new Account(1000));

        //获取客户名字(从数组中通过索引号获取)，然后通过getAccount获取它的账户，然后取出50块钱
        bank.getCustomer(0).getAccount().withdraw(50);
        System.out.println("账户余额为： "+bank.getCustomer(0).getAccount().getBalance());//查看余额
    }
}