This article mainly introduces the relevant information on how to use this and super keywords in java. I hope this article can help everyone and let everyone fully understand the application of this and super in java. Friends who need it can refer to it
How to use this and super keywords in java
In the past few days, I have seen that classes use this and super when inheriting. Here is a summary, and Let’s communicate together. Please correct me if there are any mistakes~
this
this is an object of its own, representing the object itself, and can be understood as: a pointer to the object itself. .
The usage of this in java can be roughly divided into three types:
1. Ordinary direct reference
There is no need to talk about this. this is equivalent to pointing to the current object itself.
2. If the names of participating members are the same, use this to distinguish them:
##
class Person {
private int age = 10;
public Person(){
System.out.println("初始化年龄："+age);
}
public int GetAge(int age){
this.age = age;
return this.age;
}
}
public class test1 {
public static void main(String[] args) {
Person Harry = new Person();
System.out.println("Harry's age is "+Harry.GetAge(12));
}
} Running results:
初始化年龄：10 Harry's age is 12As you can see, age is the formal parameter of the GetAge member method, and this.age is the member variable of the Person class.
3. Reference constructor
This is discussed together with super, see below.super
super can be understood as a pointer to its own super (parent) class object, and this super class refers to the parent class closest to itself . Super also has three uses: 1. Ordinary direct reference Similar to this, super is equivalent to pointing to the parent class of the current object, so you can use super. xxx to refer to members of the parent class. 2. The member variables or methods in the subclass have the same name as the member variables or methods in the parent class##
class Country {
String name;
void value() {
name = "China";
}
}
class City extends Country {
String name;
void value() {
name = "Shanghai";
super.value(); //调用父类的方法
System.out.println(name);
System.out.println(super.name);
}
public static void main(String[] args) {
City c=new City();
c.value();
}
}Shanghai China
super (parameter): Call a certain constructor in the parent class (should be the first statement in the constructor).
this (parameter): Call another form of constructor in this class (should be the first statement in the constructor).
class Person {
public static void prt(String s) {
System.out.println(s);
}
Person() {
prt("父类·无参数构造方法： "+"A Person.");
}//构造方法(1)
Person(String name) {
prt("父类·含一个参数的构造方法： "+"A person's name is " + name);
}//构造方法(2)
}
/**
* Java学习交流QQ群：589809992 我们一起学Java！
*/
public class Chinese extends Person {
Chinese() {
super(); // 调用父类构造方法（1）
prt("子类·调用父类”无参数构造方法“： "+"A chinese coder.");
}
Chinese(String name) {
super(name);// 调用父类具有相同形参的构造方法（2）
prt("子类·调用父类”含一个参数的构造方法“： "+"his name is " + name);
}
Chinese(String name, int age) {
this(name);// 调用具有相同形参的构造方法（3）
prt("子类：调用子类具有相同形参的构造方法：his age is " + age);
}
public static void main(String[] args) {
Chinese cn = new Chinese();
cn = new Chinese("codersai");
cn = new Chinese("codersai", 18);
}
}父类·无参数构造方法： A Person. 子类·调用父类”无参数构造方法“： A chinese coder. 父类·含一个参数的构造方法： A person's name is codersai 子类·调用父类”含一个参数的构造方法“： his name is codersai 父类·含一个参数的构造方法： A person's name is codersai 子类·调用父类”含一个参数的构造方法“： his name is codersai 子类：调用子类具有相同形参的构造方法：his age is 18
In the example, the third construction method of the Chinese class calls the second construction method of this class, and the second construction method calls the parent class, so the construction method of the parent class must be called first. Then call the second method in this class, and finally override the third construction method.
The similarities and differences between super and this:
##Although you can use this to call one. Constructor, but you cannot call two.
this and super cannot appear in a constructor at the same time, because this will inevitably call other constructors, and other constructors will also. There will be a super statement, so if there are the same statements in the same constructor, the meaning of the statements will be lost, and the compiler will not pass
The above is the detailed content of Detailed introduction to this and super keywords in Java. For more information, please follow other related articles on the PHP Chinese website!