2019-12-03 · this 关键字的使用

一，this 关键字的使用：

this 可以用来修饰：属性，方法，构造器。

二，this 修饰属性和方法：

“this.” 可以理解为：当前对象 或者 当前正在创建的对象。

2.1 在类的方法中，我们可以使用“this.属性”或者“this.方法”的方式，调用当前对象属性或者方法。但是，通常情况下，我们会省略“this.”。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明该变量是属性，而非形参。

2.2 在类的构造器中，我们可以使用“this.属性”或者“this.方法”的方式，调用当前正在创建的对象属性或者方法。但是，通常情况下，我们会省略“this.”。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用“this.变量”的方式，表明该变量是属性，而非形参。

三，this 调用构造器：

1. 我们在类的构造器中，可以显式的使用“this（形参列表）”方式，调用本类中指定的其他构造器。
2. 构造器中不能通过“this（形参列表）”方式调用自己。
3. 如果一个类中有 n 个构造器，则最多有 n-1 个构造器中使用了 “this（形参列表）”方式。
4. “this（形参列表）”方式必须放在首行。
5. 构造器内部，最多只能声明一个 “this（形参列表）”方式，调用其他构造器。
   
   

四，代码演示：

之前我们写形参的时候，会使用“String n”。这样做会让代码丧失了见名知意，我们后期读这段代码不容易理解 “n” 的含义。所以我们把 “n” 改为 “name” ，但是这样又会遇到形参和属性名同名的问题。这时候我们就要用到 “this” 关键字了。

class Person2{
    //私有化的属性
    private String name;
    private int age;
    
    //构造器
    //特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用”this.变量“
    public Person2() {}
    public Person2(String name) {
        //this用来修饰属性
        this.name = name;
    }
    public Person2(int age) {
        this.age = age;
    }
    public Person2(String name, int age) {
        //this用来修饰属性
        this.name = name;
        this.age = age;
    }
    
    //方法
    //特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用”this.变量“
    public String getName() {
        return name;
    }
    public void setName(String name) {
        //this用来修饰属性
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        //this用来修饰属性
        this.age = age;
    }   
}

关于 this 关键字调用构造器的一些问题：

//构造器
    public Person2() {}
    public Person2(String name) {
        //在构造器中调用别的构造器 使用： this 关键字
        //1. 可以显式的使用”this（形参列表）“方式
        this();//调用一个没有形参的构造器
        
        //5.构造器内部，最多只能声明一个”this（形参列表）“方式，调用其他构造器。
        //this(age);
        
        //this用来修饰属性
        this.name = name;
    }
    public Person2(int age) {
        //2. 构造器中不能通过”this（形参列表）“方式调用自己。
        //Recursive constructor invocation Person2(int)
        //this(age);
        this.age = age;
    }
    public Person2(String name, int age) {
        //this用来修饰属性
        this.name = name;
        this.age = age;
        
        //4. ”this（形参列表）“方式必须放在首行。
        //Constructor call must be the first statement in a constructor
        //this();
    }

五，this 关键字的练习题

Boy 类：

public class Boy {
    //属性
    private String name;
    private int age;
    
    //构造器
    public Boy() {}
    public Boy(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    //方法
    public void setName(String i) {
        name = i;
    }
    public String getName() {
        return name;
    }
    public void setAge(int i) {
        age = i;
    }
    public int getAge() {
        return age;
    }
    
    public void marry(Girl girl) {
        System.out.println("我想娶" + girl.getName());
    }
    public void shout() {//呼喊
        System.out.println("l love");
    }
}

Girl 类：

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

    public Girl() {
    }
    public Girl(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void setName(String i) {
        name = i;
    }
    public String getName() {
        return name;
    }
    public void marry(Boy boy) {
        System.out.println("我想嫁给" + boy.getName());
        boy.marry(this);//谁调用，this就变成谁
    }
    
    /**
     * @Description 比较两个对象的大小
     * @param girl
     * @return 正数：当前对象大； 负数：当前对象小； 0：相等
     */
    public int compare(Girl girl) {//比较
//      if(this.age > girl.age) {
//          return 1;
//      }else if(this.age < girl.age) {
//          return -1;
//      }else {
//          return 0;
//      }
        //简化
        //调用方法（this） - 形参列表（girl）
        return this.age - girl.age;
    }
    
    
}

BoyGirlTest 类：

//抱歉，里面的变量名没见名知意...
public class BoyGirlTest {
    public static void main(String[] args) {
        Boy b1 = new Boy("罗密欧", 23);
        
        Girl g1 = new Girl("朱丽叶", 21);
        
        g1.marry(b1);
        
        Girl g2 = new Girl("祝英台", 19);
        
        int compare = g1.compare(g2);
        System.out.println(compare);
    }
}

六，最后附上笔记代码：

package com.it3;
/*
 *1.this关键字的使用：
 *  this可以用来修饰：属性，方法，构造器
 * 
 *2.this修饰属性和方法：
 *  this理解为：当前对象    或者    当前正在创建的对象
 * 
 *  2.1 在类的方法中，我们可以使用”this.属性“或者”this.方法“的方式，
 * 调用当前对象属性或者方法。但是，通常情况下，我们选择省略”this.“。
 * 特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用”this.变量“
 * 的方式，表明该变量是属性，而非形参。
 * 
 *  2.2 在类的构造器中，我们可以使用”this.属性“或者”this.方法“的方式，
 * 调用当前正在创建的对象属性或者方法。但是，通常情况下，我们选择省略”this.“。
 * 特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用”this.变量“
 * 的方式，表明该变量是属性，而非形参。
 * 
 *3.this调用构造器
 *  1.我们在类的构造器中，可以显式的使用”this（形参列表）“方式，调用本类中指定的其他构造器
 *  2.构造器中不能通过”this（形参列表）“方式调用自己。
 *  3.如果一个类中有n个构造器，则最多有n-1个构造器中使用了”this（形参列表）“方式。 
 *  4.”this（形参列表）“方式必须放在首行。
 *  5.构造器内部，最多只能声明一个”this（形参列表）“方式，调用其他构造器。
 * 
 */
public class Test4 {
    public static void main(String[] args) {
        
//      Person1 p1 = new Person1(); 
//      p1.setAge(1);   
//      System.out.println(p1.getAge());
        
        System.out.println("--------------");
        
        Person1 p2 = new Person1("我");
        System.out.println(p2.getName());
        
    }
}

class Person1{
    //属性
    private String name;
    private int age;
    
    //构造器
    //也可以使用this
    public Person1() {
        //调用方法
        //this.eat();
        System.out.println("今天下午状态好！！！");
    }
    public Person1(String name) {
        //调用构造器
        this();
        this.name = name;
    }
    public Person1(int age) {
        this.age = age;
    }
    public Person1(String name, int age) {
        this.name = name;
        this.age = age;
    }

    
    //方法
    //特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用”this.变量“
    public void setName(String name) {
        //this用来修饰属性
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getAge() {
        return age;
    }
    
    public void eat() {
        System.out.println("吃饭");
        //this用来修饰方法
        this.study();
    }
    public void study() {
        System.out.println("学习");
    }
    
}