Detailed introduction to this and super keywords in Java
- 黄舟Original
- 2017-09-20 10:19:221676browse
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();
}
}Running result:
Shanghai China
As you can see, both the methods of the parent class and the variables of the parent class are called here. If the parent class method value() is not called and only the parent class variable name is called, the parent class name value will be the default value null. 3. Reference constructor
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);
}
}Run result:
父类·无参数构造方法： 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
As you can see from this example, you can use super and this to call the parent respectively. Class constructors and other forms of constructors in this class.
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:
- super (parameter): call a constructor in the base class (should be in the constructor The first statement)
- this (parameter): Call another formed constructor in this class (should be the first statement in the constructor)
- super: It refers to members in the direct parent class of the current object (used to access member data or functions in the parent class that are hidden in the direct parent class. The base class and the derived class have the same member definitions. For example: super. variable name super. member function data name (actual parameter)
- #this: It represents the current object name (where ambiguity is likely to occur in the program, it should be used this is used to indicate the current object; if the member data in the function's formal participant class has the same name, then this needs to be used to indicate the member variable name)
- Calling super() must be written in the subclass The first line of the constructor, otherwise the compilation will not pass. The first statement of each subclass constructor implicitly calls super(). If the parent class does not have this form of constructor, then it will be called during compilation. An error will be reported.
- super() is similar to this(). The difference is that super() calls the constructor of the parent class from the subclass, and this() calls other methods in the same class. Method.
- ##Both super() and this() need to be placed in the first line of the constructor
##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
- ##this() and super. () all refer to objects, so they cannot be used in static environments. Including: static variables, static methods, static statement blocks ##Essentially, this is. A pointer to this object, however super is a Java keyword
- .
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!