this关键字

在Java 基础中，this关键字是一个重要的概念。
使用this关键字可以完成以下操作：

1. 调用类中的属性
2. 调用类中的方法(普通，构造)
3. 表示当前对象

1.使用this关键字表示本类的属性

在一个类的方法或构造方法内部，可以使用 “this.成员变量名” 这样的格式来引用成员变量名，有些时候可以省略，有些时候不能省略。

---

范例 1：先观察下该程序

class Person{
    private String name;
    private int age;
    // setter,getter 无参构造略
    public Person(String n,int a){
        name = n;
        age = a;
    }
    public String getInfo(){
        return "姓名:" + name + ",年龄：" + age;
    }
}

public class Test{
    public static void main(String[] args){
        
        System.out.println(new Person("张三",20).getInfo());
    }
}

上面程序给出的 参数 有一些问题。现在，分析一下，当前类中的构造方法的核心在于：为类中的 name 和 age 两个属性进行初始化。但是现在构造方法的参数声明不准确 "Person(String n,int a)" , 所以最好的做法是 将参数的名称与属性名称统一起来。
那么这个时候就可能产生参数与属性同名的问题，所以为了明确的标记出要使用的是属性还是方法的参数，那么建议属性前都统一加上 "this"的形式。

范例 2：：加上 this关键字

class Person{
    private String name;
    private int age;
    // setter,getter 无参构造略
    public Person(String name,int age){
        //this.属性 ，当前对象的属性
        this.name = name;
        this.age = age;
    }
    public String getInfo(){
        return "姓名:" + this.name + ",年龄：" + this.age;
    }
}

public class Test{
    public static void main(String[] args){
        
        System.out.println(new Person("张三",20).getInfo());
    }
}

只要在类的方法中访问有类中的属性，那么属性前一定要追加"this"关键字的形式

2.使用this关键字调用本类方法

类中的两种方法：

1. 普通方法： this.方法名称(参数...)；
2. 构造方法： this(参数...)。

---

调用本类方法(普通方法)

范例 1：调用本类方法(普通方法)

class Person{
    private String name;
    private int age;
    // setter,getter 无参构造略
    public Person(String name,int age){
        //this.属性 ，当前对象的属性
        this.name = name;
        this.age = age;
        // 问题是，你现在即使不使用this，也可以调用。
        this.print(); //调用本类方法
    }
    public void print(){
        System.out.println("**************");
    }
    public String getInfo(){
        return "姓名:" + this.name + ",年龄：" + this.age;
    }
}

public class Test{
    public static void main(String[] args){
        
        System.out.println(new Person("张三",20).getInfo());
    }
}

虽然调用本类的普通方法前可以不使用this (this关键字可以省略) ，但是强烈建议追加上this，这样的目的是可以区分方法的定义来源。

调用构造方法

构造方法与普通方法最大的区别：
构造方法使用关键字new实例化类新对象的时候使用一次，而普通方法是在对象实例化完成后(构造方法已经执行了)可以调用多次。

在java里面支持类构造方法的互相调用。

范例 2：观察构造方法本身存在的问题

class Person{
    private String name;
    private int age;
    // 不管你现在调用那个构造方法，都要求一段执行信息
    public Person(){ //无参构造
        System.out.println("******一个新的Person类对象产生了********");
    }
    public Person(String name){
        System.out.println("******一个新的Person类对象产生了********");
        this.name = name;
    }
    public Person(String name,int age){
        System.out.println("******一个新的Person类对象产生了********");
        //this.属性 ，当前对象的属性
        this.name = name;
        this.age = age;
    }
    public String getInfo(){
        return "姓名:" + this.name + ",年龄：" + this.age;
    }
}
public class Test{
    public static void main(String[] args){
        System.out.println(new Person().getInfo());
        System.out.println(new Person("张三").getInfo());
        System.out.println(new Person("张三",20).getInfo());
    }
}

现在给出的程序中出现了重复的代码，必须消除掉重复的代码。

范例 3：使用this 解决问题

class Person{
    private String name;
    private int age;
    // 不管你现在调用那个构造方法，都要求一段执行信息
    public Person(){ //无参构造
        System.out.println("******一个新的Person类对象产生了********");
    }
    public Person(String name){
        this();              //调用本类的无参构造
        this.name = name;
    }
    public Person(String name,int age){
        this(name);    //调用本类的有参构造
        this.age = age;
    }
    public String getInfo(){
        return "姓名:" + this.name + ",年龄：" + this.age;
    }
}
public class Test{
    public static void main(String[] args){
        System.out.println(new Person().getInfo());
        System.out.println(new Person("张三").getInfo());
        System.out.println(new Person("张三",20).getInfo());
    }
}

虽然使用this 可以实现构造方法的互相调用，但是此时有以下的 两点要求：

1. this()调用构造方法的语句必须放在构造方法的首行；
   错误代码：构造方法不再构造方法的首行

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

2. 使用this调用构造方法的时候请留有出口
   错误代码：递归构造调用.

    public Person(){ //无参构造
        this("hello",10);
        System.out.println("******一个新的Person类对象产生了********");
    }
    public Person(String name){
        this(); 
        this.name = name;
    
    }

3.使用this关键字表示当前对象

在一个类之中肯定会产生若干个对象，那么程序类在分辨的时候不会记住具体多少个对象产生了，它唯一可能知道的 当前操作本类的对象 是哪一个。

范例 1：观察当前对象。

class Person{
    public void fun(){
        System.out.println("【FUN方法】" + this);
    }
}
public class Test{
    public static void main(String[] args){
        Person p1 = new Person();
        System.out.println("【MAIN方法】" + p1);
        p1.fun();  // 由p1这个对象调用了fun()方法，(this=p1)
        System.out.println("====================");
        Person p2 = new Person();
        System.out.println("【MAIN方法】" + p2);
        p2.fun();
    }
}

结果：
【MAIN方法】Person@15db9742
【FUN方法】Person@15db9742
====================
【MAIN方法】Person@6d06d69c
【FUN方法】Person@6d06d69c

在整体的操作过程之中，this的定义没变，只要有某一个对象调用了本类中的方法
那么这个this就表示当前执行的对象。