在之前学习方法之间调用时，可以通过方法名进行调用。可是针对构造方法，无法通过构造方法名来相互调用。

构造方法之间的调用，可以通过this关键字来完成。

1. 构造方法调用格式：

this(参数列表);

 

2. 构造方法的调用

class Person {

    // Person的成员属性

    private int age;

    private String name;

 

    // 无参数的构造方法

    Person() {

    }

 

    // 给姓名初始化的构造方法

    Person(String nm) {

        name = nm;

    }

 

    // 给姓名和年龄初始化的构造方法

    Person(String nm, int a) {

        // 由于已经存在给姓名进行初始化的构造方法 name = nm;因此只需要调用即可

        // 调用其他构造方法，需要通过this关键字来调用

        this(nm);

        // 给年龄初始化

        age = a;

    }

}

一 this调用构造方法
构造方法之间的调用，可以通过this关键字来完成。
格式：
this(参数列表);
构造方法的调用举例：
classPerson {//Person的成员属性
private intage;privateString name;//无参数的构造方法
Person() {
}//给姓名初始化的构造方法
Person(String nm) {
name=nm;
}//给姓名和年龄初始化的构造方法
Person(String nm, inta) {//由于已经存在给姓名进行初始化的构造方法 name = nm;因此只需要调用即可//调用其他构造方法，需要通过this关键字来调用
this(nm);//给年龄初始化
age =a;
}
}
二 this的原理图解
例如：
classPerson {private intage;privateString name;
Person() {
}
Person(String nm) {
name=nm;
}
Person(String nm,inta) {this(nm);
age=a;
}
}classPersonDemo {public static voidmain(String[] args) {
Person p= new Person("张三", 23);
}
}
内存图解：
1、先执行main方法，main方法压栈，执行其中的new Person(“张三”,23);
2、堆内存中开辟空间，并为其分配内存地址0x33，，紧接着成员变量默认初始化(name=null age = 0)；
3、拥有两个参数的构造方法(Person(String nm , int a))压栈，在这个构造方法中有一个隐式的this，
因为构造方法是给对象初始化的，那个对象调用到这个构造方法，this就指向堆中的那个对象。
4、由于Person(String nm , int a)构造方法中使用了this(nm);构造方法Person(String nm)就会压栈，
并将“张三”传递给nm。在Person(String nm , int a)构造方法中同样也有隐式的this，this的值同样也为
0x33，这时会执行其中name = nm，即把“张三”赋值给成员的name。当赋值结束后Person(String nm , int a)
构造方法弹栈。
5、程序继续执行构造方法(Person(String nm , int a)中的age = a；这时会将23赋值给成员属性age。
赋值结束构造方法(Person(String nm , int a)弹栈。
6、当构造方法(Person(String nm , int a)弹栈结束后，Person对象在内存中创建完成，并将0x33赋值
给main方法中的p引用变量。
注意事项：
this所在的方法，this就代表哪个对象。
调用其他构造方法的语句必须定义在构造方法的第一行，原因是初始化动作要最先执行。
三 成员变量和局部变量同名问题
以在成员变量名前面加上this.来区别成员变量和局部变量
例如：
classPerson {private intage;privateString name;//给姓名和年龄初始化的构造方法
Person(String name, intage) {//当需要访问成员变量是，只需要在成员变量前面加上this.即可
this.name =name;this.age =age;
}public voidspeak() {
System.out.println("name=" + this.name + ",age=" + this.age);
}
}classPersonDemo {public static voidmain(String[] args) {
Person p= new Person("张三", 23);
p.speak();
}
}
四 this的应用
例如：在Person类中定义功能，判断两个人是否是同龄人
classPerson {private intage;privateString name;//给姓名和年龄初始化的构造方法
Person(String name, intage) {//当需要访问成员变量是，只需要在成员变量前面加上this.即可
this.name =name;this.age =age;
}public voidspeak() {
System.out.println("name=" + this.name + ",age=" + this.age);
}//判断是否为同龄人
public booleanequalsAge(Person p) {//使用当前调用该equalsAge方法对象的age和传递进来p的age进行比较//由于无法确定具体是哪一个对象调用equalsAge方法，这里就可以使用this来代替
/** if(this.age == p.age) { return true; } return false;*/
return this.age =p.age;
}
}

java中this常用有三种功能分别是：引用成员变量，调用构造方法，返回类实例。第一种功能比较容易理解，实际上也就是防止对象属性与方法中形参名相同。
哦对 顺便说下this的概念：this代表调用这个函数的对象。 其实和python中的self类似。
java中this调用构造方法
使用格式如下：
this([参数列表])
1
2
this([参数列表])
系统将根据参数列表来决定调用哪一个构造方法。使用this时还需注意下面几点：
用this调用构造方法时，该语句只能用在构造方法中。
this语句必须是构造方法中的第一条语句。
和new不同，this虽然可以调用构造方法，但它只是执行构造方法中的语句，并不会创建对象。
(百度网友淡忘WHY66的回答)
举个例子
package cn.rui0;
public class Testhis {
public Testhis() {
this(911);//调用有参的构造方法 必须放在第一行
System.out.println("无参");
}
public Testhis(int i) {
System.out.println(i+"\n"+"有参");
}
public static void main(String[] args) {
Testhis a=new Testhis();//创建对象的同时会调用无参的构造方法
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
packagecn.rui0;
publicclassTesthis{
publicTesthis(){
this(911);//调用有参的构造方法 必须放在第一行
System.out.println("无参");
}
publicTesthis(inti){
System.out.println(i+"\n"+"有参");
}
publicstaticvoidmain(String[]args){
Testhisa=newTesthis();//创建对象的同时会调用无参的构造方法
}
}
output:
911
有参
无参
1
2
3
4
5
911
有参
无参
好的，接下来说
java中this返回类实例
可以理解为返回类的对象,然后…要说的都在下面了..
package cn.rui0;
public class Testhis {
int i;
int num;
public Testhis() {
this(911);//必须放在第一行
num=100;
System.out.println("无参");
}
public Testhis(int i) {
this.i=i+1;
System.out.println(this.i+"\n"+"有参");
}
public Testhis aaa(){       //这里定义的返回值类型为Testhis这个类
num++;
return this;
}
public static void main(String[] args) {
Testhis a=new Testhis();//创建对象的同时会调用无参的构造方法
Testhis b=new Testhis();//创建另一个对比
System.out.println("*********************");
System.out.println(a);//输出实例化的类的对象a的地址
System.out.println(a.aaa());
/*
* 输出时运行了这个实例化的类的对象a中的方法aaa()
* 而方法aaa()中返回了当下调用这个方法的对象a(因为用的是this所以是当下调用这个方法的对象a,而不是b)
* 并且类型为Testhis,可以理解为又成为属于Testhis的一个对象,就是又有了Testhis类下的一波属性什么的
* 所以输出的地址和上面a的一样,并且可以进行像下面这样的输出
*/
System.out.println(b);//先对比一下输出地址 是不一样的对象 好了没它事了
System.out.println(a.aaa().getClass().getName ());//获取当前类名
System.out.println(a.num);//获取当前类实例化对象的属性
System.out.println(a.aaa().num);
//      这部分可能有点抽象，本辣鸡打字可能也没说太清，大家不懂可以再多去对比几次的输出的语句和output去理解
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
packagecn.rui0;
publicclassTesthis{
inti;
intnum;
publicTesthis(){
this(911);//必须放在第一行
num=100;
System.out.println("无参");
}
publicTesthis(inti){
this.i=i+1;
System.out.println(this.i+"\n"+"有参");
}
publicTesthisaaa(){//这里定义的返回值类型为Testhis这个类
num++;
returnthis;
}
publicstaticvoidmain(String[]args){
Testhisa=newTesthis();//创建对象的同时会调用无参的构造方法
Testhisb=newTesthis();//创建另一个对比
System.out.println("*********************");
System.out.println(a);//输出实例化的类的对象a的地址
System.out.println(a.aaa());
/*
* 输出时运行了这个实例化的类的对象a中的方法aaa()
* 而方法aaa()中返回了当下调用这个方法的对象a(因为用的是this所以是当下调用这个方法的对象a,而不是b)
* 并且类型为Testhis,可以理解为又成为属于Testhis的一个对象,就是又有了Testhis类下的一波属性什么的
* 所以输出的地址和上面a的一样,并且可以进行像下面这样的输出
*/
System.out.println(b);//先对比一下输出地址 是不一样的对象 好了没它事了
System.out.println(a.aaa().getClass().getName());//获取当前类名
System.out.println(a.num);//获取当前类实例化对象的属性
System.out.println(a.aaa().num);
//      这部分可能有点抽象，本辣鸡打字可能也没说太清，大家不懂可以再多去对比几次的输出的语句和output去理解
}
}
output：
912
有参
无参
912
有参
无参
*********************
cn.rui0.Testhis@7852e922
cn.rui0.Testhis@7852e922
cn.rui0.Testhis@4e25154f
cn.rui0.Testhis
102
103
1
2
3
4
5
6
7
8
9
10
11
12
13
14
912
有参
无参
912
有参
无参
*********************
cn.rui0.Testhis@7852e922
cn.rui0.Testhis@7852e922
cn.rui0.Testhis@4e25154f
cn.rui0.Testhis
102
103
注意:
被static修饰的方法没有this指针。因为被static修饰的方法是公共的，不能说属于哪个具体的对象的
感谢阅读，如果有错误非常欢迎指出～thx 🙂

转载自：https://blog.csdn.net/u014042146/article/details/48374087，除了个别注释稍作更改，其他没变，代码建议跑一遍，想清楚逻辑。
this 和super在构造函数中只能有一个，且都必须是构造函数当中的第一行。
super关键字，子类可以通过它调用父类的构造函数。
1、当父类的构造函数是无参构造函数时，在子类的构造函数中，就算不写super()去调用父类的构造函数，编译器不会报错，因为编译器会默认的去调用父类的无参构造函数。
classhood {publichood(){
System.out.println("1");
}
}class hood2 extendshood{publichood2(){
System.out.println("2");
}
}public classTEST {public static voidmain(String[] args){
hood2 t= newhood2();
}
}
这段代码的运行结果是：1     2
2、当父类的构造函数是有参构造函数时，此时如果子类的构造函数中不写super()进行调用父类的构造函数，编译器会报错，此时不能省去super()
classhood {public hood(inti){
System.out.println("1"+i);
}
}class hood2 extendshood{publichood2(){super(5);
System.out.println("2");
}
}public classTEST {public static voidmain(String[] args){
hood2 t= newhood2();
}
}
这段代码的运行结果是：15    2
再来是this关键字，可以理解为它可以调用自己的其他构造函数，看如下代码：
classFather {int age;      //年龄
int hight;    //身体高度
publicFather() {
print();this.age=20;   //这里初始化 age 的值
}public Father(intage) {this();      //调用自己的第一个构造函数，下面的两个语句不执行的
this.age =age;
print();
}public Father(int age, inthight) {this(age);   //调用自己第二个构造函数  ，下面的两个语句不执行的
this.hight =hight;
print();
}public voidprint() {
System.out.println("I'am a " + age + "岁 " + hight + "尺高 tiger!");
}public static voidmain(String[] args) {new Father(22,7);
}
}
这段代码的运行结果是：
I'am a 0岁 0尺高 tiger!
I'am a 022岁 0尺高 tiger!
I'am a 22岁 7尺高 tiger!