Este artículo presenta principalmente información relevante sobre la diferencia y la comprensión de la palabra clave java this y super. El artículo presenta en detalle a través del código de muestra, que tiene un cierto valor de aprendizaje de referencia para el estudio o el trabajo de todos. Los amigos que lo necesitan están a continuación Estudiemos junto con el editor
esta:
Esto se entiende como: el objeto actual o el objeto que se está creando actualmente.
Estructuras que se pueden llamar: atributos, métodos; constructores
Esto llama a propiedades y métodos:
Primero comprenda los parámetros formales:
El significado del parámetro formal es asignar un valor al atributo. Queremos asignar un valor al atributo con el mismo nombre. En este momento, escribimos el nombre del parámetro y el nombre del atributo como el mismo, para que sepamos que el parámetro que pasamos es para darnos el atributo con el mismo nombre.
En el método de la clase, podemos usar el atributo "este. Atributo" o "este. Método" para llamar al atributo o método del objeto actual. pero,
En circunstancias normales, optamos por omitir "esto". En circunstancias especiales, si el parámetro del método y el atributo de la clase tienen el mismo nombre, debemos usar explícitamente el método "this. Variable" para indicar que esta variable es un atributo, no un parámetro formal.
Ejemplo: declaramos una clase llamada zapatos y le proporcionamos propiedades privadas y métodos y constructores get / set:
//声明一个鞋类
public class shoes {
//鞋的属性
private String name;//鞋名
private int id;//编号
//无参构造器
public shoes() {
}
//有参构造器:
public shoes(String name, int id) {
// name = name;没加this
this.name = name;
// id = id; 没加this
this.id = id;
}
//声明两个方法
public void show(){
System.out.println("展示~~");
sale();//show方法中调sale方法
// this.sale();//this可省略
}
public void sale(){
System.out.println("售卖~~");
}
//get/set方法:
public String getName() {
return name;
}
public void setName(String name) {
//name = name;没加this
this.name = name;
}
public void setId(int id) {
//id = id;没加this
this.id = id;
}
public int getId() {
return id;
}
}
//测试
class test {
public static void main(String[] args) {
//我们先实例化鞋类的对象来调它的属性
shoes s = new shoes();
s.setName("nike");//这里的"nike"就是传入的形参
System.out.println(s.getName());
//我们获取鞋名的时候,获取不到,意思就是形参的值又赋给了形参,代表没有给鞋的属性赋上值
//这个时候控制台会输出传入的形参数据类型的默认值,明显不是我们想看到的结果
s.setId(1);
System.out.println(s.getId());//鞋的id类似的也会出现同样的情况
//"this.方法"举例:
s.show();
/*我们先调的是show自己的方法体,然后在show方法中调了sale方法
意思是s这个对象调了show方法,我们就用调show方法的这个对象s来调sale方法,
其实在sale();前面也省略了this关键字,表示当前对象(就是调show方法的对象)调的sale方法*/
System.out.println("------------------------分割线--------------------");
shoes s1 = new shoes("李宁",2);//我们new的有参数的对象给它赋初值之后
System.out.println(s1.getName());
System.out.println(s1.getId());//如果没有加this,结果还是和没有获取到鞋名和编号
}
}
Veamos primero la situación en la que no se agrega esta palabra clave:
resultado:
Luego agregamos esta palabra clave al atributo zapato :
La salida de la consola es el nombre y el número que configuramos para el zapato:
En el constructor de la clase, podemos usar el método "this. Property" o "this. Method" para llamar a las propiedades o métodos del objeto que se está creando actualmente. Sin embargo, en circunstancias normales, optamos por omitir "esto". En circunstancias especiales, si el parámetro del constructor y el atributo de la clase tienen el mismo nombre, debemos usar explícitamente el método "this. Variable" para indicar que esta variable es un atributo, no un parámetro.
Lo mismo es cierto para nuestro constructor: si el constructor de parámetros no agrega la palabra clave this al atributo: la salida de la consola es la misma que la anterior
Después de agregar:
Esto llama al constructor:
① En el constructor de la clase, podemos usar explícitamente el método "this (lista de parámetros)" para llamar a otros constructores especificados en esta clase
② No puede llamarse a sí mismo en el constructor a través de "esto (lista de parámetros)"
③ Si hay n constructores en una clase, como máximo n-1 constructores usan "this (lista de parámetros)"
④ Disposición: "esto (lista de parámetros)" debe declararse en la primera línea del constructor actual
⑤ Dentro del constructor, solo se puede declarar un "esto (lista de parámetros)" como máximo para llamar a otros constructores
Ejemplo: todavía escribimos una clase Shoes para proporcionar propiedades privadas y métodos get / set y proporcionar tres constructores:
public class Shoes {
//属性
private String name;//鞋名
private int id;//编号
//get/set方法:
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
//构造器1
public Shoes() {
System.out.println("构造器1");
}
//构造器2
public Shoes(int id){
this();//调构造器1
System.out.println("构造器2");
this.id = id;
}
//构造器3
public Shoes(String name, int id) {
//通过调用构造器来执行其他构造器中的代码
this(id);//调构造器2
// this.id = id;//交给构造器2来执行
this.name = name;
//我们如果需要使用到其他构造器中的代码就可以使用"this.构造器"的方式
//这里只是为了举例我们只写了一行输出语句,真正实际中我们写的代码多了,调用构造器的方法的优势就体现出来了
//这样我们可以减少代码的冗余,提高程序执行效率
}
}
class test{
public static void main(String[] args) {
//用构造器3来实例化对象,我们在构造器3中没有把参数id赋给当前对象
//但是通过调构造器2,构造器2中执行了 this.id = id;把id赋给了当前对象的属性
//所以我们才可以得到当前对象s3的id
Shoes s3 = new Shoes("adidas",2021);
System.out.println(s3.getId());
}
}
resultado de la operación:
super: La
palabra clave super se puede entender como:
la estructura de la clase padre que se puede usar para llamar:
propiedades, métodos, constructores *
Super llamadas propiedades y métodos:
Podemos estar en un método o constructor de una subclase. Al utilizar "super. Atributos" o "super. Métodos", los atributos o métodos declarados en la clase principal se llaman explícitamente. Sin embargo, en circunstancias normales, estamos acostumbrados a omitir "super".
① Caso especial: Cuando el atributo con el mismo nombre está definido en la subclase y la clase padre, si queremos llamar al atributo declarado en la clase padre en la subclase, debemos usar explícitamente el método "super. Attribute" para indicar el call Es el atributo declarado en la clase padre.
② Caso especial: cuando la subclase sobrescribe el método en la clase padre, cuando queremos llamar al método reemplazado en la clase padre en el método de la subclase, debemos usar explícitamente el método "super. Método", indica que el método reemplazado se llama al método en la clase principal (es decir, el método original en la clase principal).
Por ejemplo, dos casos especiales: llamar a las propiedades y métodos del mismo nombre en la clase padre en el método de la subclase:
Crea un humano, una clase de estudiantes, la clase de estudiantes hereda el humano y una clase de prueba.
//人类
public class Person {
//属性
String name = "普通人";//姓名
int id = 1234;//身份证号
//方法
public void learn(){
System.out.println("人要学习");
}
}
//学生类
public class Student extends Person {
//声明了与父类的同名属性
String name = "哈利波特";//姓名
int id = 9527;//学号
@Override//子类重写父类的方法
public void learn() {
System.out.println("学生要努力学习");
super.learn();//调父类中原本的方法
System.out.println("姓名:"+name);//子类自己的属性
System.out.println("学号:"+id);
System.out.println("姓名:"+super.name);//父类中声明的属性
System.out.println("身份证号:"+super.id);
}
}
//测试类
public class Test {
public static void main(String[] args) {
//实例化子类对象
Student student = new Student();
//调子类中重写父类的方法
student.learn();
}
}
Resultado de salida:
Super llama al constructor:
podemos usar explícitamente el método "super (lista de parámetros)" en el constructor de la subclase para llamar al constructor especificado declarado en la clase padre
Nota:
El uso de "super (lista de parámetros)" debe declararse en la primera línea del constructor de subclase. En el constructor de la clase, solo podemos elegir uno de los dos para "this (lista de parámetros)" o "super (lista de parámetros)". No puede aparecer en la primera línea del constructor al mismo tiempo, y hay sin declaración explícita. "this (lista de parámetros)" o "super (lista de parámetros)", el valor predeterminado es llamar al constructor del parámetro vacío en la clase principal: super () está en los múltiples constructores de la clase, al menos uno de los constructores de la clase Use "super (lista de parámetros)" para llamar al constructor en la clase padre
Ejemplo: aún usando el ejemplo anterior, agregamos constructores a las clases de humanos y estudiantes:
public class Person {
//属性
String name = "普通人";//姓名
int id = 1234;//身份证号
//构造器
public Person() {
}
public Person(String name, int id) {
this.name = name;
this.id = id;
}
//方法
public void learn(){
System.out.println("人要学习");
}
}
public class Student extends Person {
//声明了与父类的同名属性
String name = "哈利波特";//姓名
int id = 9527;//学号
//构造器1
public Student(String name, int id) {
this.name = name;
this.id = id;
}
//构造器2
public Student(String name, int id, String name1, int id1) {
super(name, id);//调用父类已有的构造器
this.name = name1;
this.id = id1;
}
@Override//子类重写父类的方法
public void learn() {
System.out.println("学生要努力学习");
super.learn();//调父类中原本的方法
System.out.println("姓名:"+name);//子类自己的属性
System.out.println("学号:"+id);
System.out.println("姓名:"+super.name);//父类中声明的属性
System.out.println("身份证号:"+super.id);
}
}
Llame al constructor parametrizado existente de la clase padre en el constructor de subclase 2:
Luego prueba: crea una instancia del objeto de la clase del estudiante y asigna valores a los atributos, y ajusta el método de aprendizaje:
public class Test {
public static void main(String[] args) {
Student student = new Student("人",8888,"学生",2021);
student.learn();
}
}
Resultado de salida:
Resumen de la diferencia entre this y super:
① Representa cosas diferentes
Esto representa el objeto llamador de la función actual
Super significa llamar a la estructura de la clase padre (atributos, métodos, constructores)
②Diferentes condiciones de uso
Super debe tener una relación de herencia antes de que pueda usarse
Esto se puede usar sin herencia.
③Los diferentes constructores se llaman
Super: llama al constructor de la clase padre
Esto: llama al constructor de la clase actual (esta clase)
Descripción:
Lo que se almacena en el espacio de la pila es la referencia del objeto, es decir, el objeto cuyo nombre apunta al nuevo en el espacio del montón. En el espacio del montón, los atributos de la subclase y la clase principal estarán presentes. y super puede apuntar al espacio del montón a través de la referencia del espacio de la pila. Llamar a propiedades específicas.
para resumir
Hasta ahora, se presenta este artículo sobre la diferencia y la comprensión de la palabra clave java this y super. Para obtener más palabras clave Java relacionadas this y super, preste atención al artículo anterior del editor o continúe navegando por los artículos relacionados a continuación. Espero que todos ¡Apóyame mucho en el futuro!