Analyse détaillée des mots-clés this et super de Java

Cet article vous apporte des connaissances pertinentes sur java. Il présente principalement les problèmes liés à ces mots-clés et super in, ainsi que certaines de leurs différences. Examinons-les ensemble. J'espère qu'il sera utile à tout le monde.

Apprentissage recommandé : "Tutoriel vidéo Java"

1. L'utilisation de "ce" mot-clé

1. c'est quoi ?

• En Java, le mot-clé this est difficile à comprendre. Sa fonction est très proche de sa signification, qui signifie « actuel ».

2. Function

this关键字比较难理解，它的作用和其词义很接近，表示“当前”的意思。

2. 作用

this关键字可以用来修饰、调用：属性、方法、构造器。
this关键字只能在方法内部使用。
 它在方法内部使用，即这个方法所属对象的引用；
 它在构造器内部使用，表示该构造器正在初始化的对象。

3. 使用

• 什么时候使用this关键字呢？

当在方法内需要用到调用该方法的对象时，就用this。具体的：我们可以用this来区分属性和局部变量。比如：this.name = name;

3.1 修饰属性和方法

this理解为：当前对象或当前正在创建的对象
在类的方法中，我们可以使用this.属性或this.方法的方式，调用当前对象属性或方法。但是，通常情况下，我们都选择省略this.。特殊情况下，如果方法的形参和类的属性同名时，我们必须显式的使用this.变量的方式，表明此变量是属性，而非形参。
使用this访问属性和方法时，如果在本类中未找到，会从父类中查找。

代码演示：

class Person{ // 定义Person类
    private String name ;
    private int age ;
    public Person(String name,int age){
      this.name = name ; 
      this.age = age ; }
    public void getInfo(){
      System.out.println("姓名：" + name) ;
      this.speak();
    }
    public void speak(){
      System.out.println(“年龄：” + this.age);
    } }

3.2 调用构造器

 在类的构造器中，我们可以使用this.属性或this.方法的方式，调用当前正在创建的对象属性或方法。但是，通常情况下，我们都选择省略this.。特殊情况下，如果构造器的形参和类的属性同名时，我们必须显式的使用this.变量的方式，表明此变量是属性，而非形参。

我们在类的构造器中，可以显式的使用this(形参列表)的方式，调用本类中指定的其它构造器。

构造器中不能通过this(形参列表)方式调用自身的构造器。

 如果一个类中有n个构造器，则最多有 n - 1个构造器中使用了this(形参列表)

 规定：this(形参列表)必须声明在当前构造器的首行。

 构造器内部，最多只能声明一个this(形参列表)，用来调用其它的构造器。

 除构造器之外，编译器禁止在其它任何方法中调用构造器。

代码演示：

class Person{ // 定义Person类
   private String name ;
   private int age ;
   public Person(){ // 无参构造器
     System.out.println("新对象实例化") ;
   }
   public Person(String name){
     this(); // 调用本类中的无参构造器
     this.name = name ;
   }
   public Person(String name,int age){
     this(name) ; // 调用有一个参数的构造器
     this.age = age;
   }
   public String getInfo(){
     return "姓名：" + name + "，年龄：" + age ;
   } }

3.3 返回当前对象

代码演示：

public class Leaf {
    int i = 0;
    Leaf increment(){
        i++;
        return this;
    }
    void print(){
        System.out.println("i = "+i);
    }
    public static void main(String args[]){
        Leaf x = new Leaf();
        x.increment().increment().increment().print();//i = 3
    }}

二、“ super ”关键字的使用

1. 概述

（1）super理解为：父类的

（2）在Java类中使用super来调用父类中的指定操作：
super可用于访问父类中定义的属性。

super可用于调用父类中定义的成员方法。
super可用于在子类构造器中调用父类的构造器。
尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员，super的追溯不仅限于直接父类。
super和this的用法相像，this代表本类对象的引用，super

this peut être utilisé pour modifier et appeler : des propriétés, des méthodes et des constructeurs. Le mot-clé
this ne peut être utilisé qu'à l'intérieur d'une méthode.
Il est utilisé à l'intérieur d'une méthode, c'est-à-dire une référence à l'objet auquel appartient cette méthode ;
Il est utilisé à l'intérieur d'un constructeur, indiquant l'objet que le constructeur est en train d'initialiser.

3. Utiliser

🎜🎜Quand devez-vous utiliser ce mot-clé ? 🎜🎜🎜🎜🎜Lorsque vous devez utiliser l'objet qui appelle la méthode dans une méthode, utilisez this. Plus précisément : nous pouvons utiliser this pour distinguer les propriétés et les variables locales. Par exemple : this.name = name;🎜🎜

3.1 Propriétés et méthodes de modification

🎜🎜this est compris comme : l'objet courant ou l'objet en cours de création
Dans les méthodes de classe, nous pouvons utiliser this.property ou this.method pour appeler les propriétés ou méthodes de l'objet actuel. Cependant, généralement, nous choisissons d'omettre ceci.. Dans des cas particuliers, si le paramètre formel de la méthode porte le même nom que l'attribut de la classe, il faut explicitement utiliser this.variable pour indiquer que la variable est un attribut et non un paramètre formel.
Lorsque vous utilisez this pour accéder aux propriétés et aux méthodes, si elles ne sont pas trouvées dans cette classe, elles seront recherchées à partir de la classe parent. 🎜🎜🎜🎜Démonstration de code : 🎜🎜

public class Person {
    private String name;
    private int age;
    private Date birthDate;
    public Person(String name, int age, Date d) {
       this.name = name;
       this.age = age;
       this.birthDate = d; }
    public Person(String name, int age) {
       this(name, age, null);
    }
    public Person(String name, Date d) {
       this(name, 30, d);
    }
    public Person(String name) {
       this(name, 30);
    } }public class Student extends Person {
    private String school;
    public Student(String name, int age, String s) {
      super(name, age);
      school = s; 
    }
    public Student(String name, String s) {
      super(name);
      school = s; 
    }// 编译出错: no super(),系统将调用父类无参数的构造器。
    public Student(String s) { 
      school = s; 
    } }

3.2 Appeler le constructeur

🎜🎜 Dans le constructeur d'une classe, on peut utiliser this.property ou this.method pour appeler les propriétés ou méthodes de l'objet en cours de création. Cependant, généralement, nous choisissons d'omettre ceci.. Dans des cas particuliers, si le paramètre formel du constructeur porte le même nom qu'une propriété de la classe, nous devons explicitement utiliser this.variable pour indiquer que la variable est un attribut et non un paramètre formel. 🎜🎜🎜🎜Dans le constructeur d'une classe, nous pouvons explicitement utiliser this (liste formelle de paramètres) pour appeler d'autres constructeurs spécifiés dans cette classe. 🎜🎜🎜🎜Le constructeur ne peut pas appeler son propre constructeur via la méthode this (liste formelle de paramètres). 🎜🎜🎜🎜 S'il y a n constructeurs dans une classe, alors Il y en a au plus n - 1 🎜ceci (liste formelle de paramètres) est utilisé dans le constructeur 🎜🎜🎜🎜 stipule : this (liste formelle de paramètres) doit être déclaré dans la première ligne du constructeur actuel🎜. 🎜🎜🎜🎜 À l'intérieur du constructeur, ne peut déclarer qu'au plus un this (liste formelle de paramètres), qui est utilisé pour appeler d'autres constructeurs. 🎜🎜🎜🎜 À l'exception du constructeur, le compilateur interdit d'appeler le constructeur dans toute autre méthode. 🎜🎜🎜🎜Démonstration de code : 🎜🎜rrreee

3.3 Renvoie l'objet actuel

🎜🎜Démonstration de code : 🎜🎜rrreee🎜 2. Utilisation du mot-clé "super" 🎜🎜🎜1. 1) super est compris comme : 🎜🎜🎜🎜 de la classe parent (2) Utilisez super dans une classe Java pour appeler l'opération spécifiée dans la classe parent :
super Peut être utilisé pour accéder aux attributs <span style="color:red"> 🎜 définis dans la classe parent. 🎜🎜<code>super peut être utilisé pour appeler des méthodes membres🎜 définies dans la classe parent.
super peut être utilisé pour appeler le constructeur 🎜 de la classe parent dans le constructeur de sous-classe.
Surtout lorsqu'un membre portant le même nom apparaît dans une classe enfant ou parent, vous pouvez utiliser super pour indiquer que vous appelez un membre de la classe parent. Le traçage de . super n'est pas limité à la classe parent directe.
super est similaire à this this représente une référence à un objet de cette classe, et super représente le parent. L'identifiant de l'espace mémoire de la classe. 🎜🎜🎜2. Utilisez 🎜🎜🎜 pour appeler explicitement la structure de la classe parent dans la sous-classe. 🎜

3.使用

3.1 调用属性和方法

我们可以在子类的方法或构造器中。通过使用"super.属性“或”super.方法“的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯省略”super."。

当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性。

当子类重写了父类中的方法以后，我们想在子类的方法中调用父类中被重写的方法时，则必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。

3.2 调用构造器

（1）子类中所有的构造器默认都会访问父类中空参数的构造器。

（2）当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，否则编译出错。同时，只能”二选一”，不能同时出现，且必须放在构造器的首行。

（3）在类的多个构造器中，至少有一个类的构造器中使用了"super(形参列表)"，调用父类中的构造器。

代码演示：

public class Person {
    private String name;
    private int age;
    private Date birthDate;
    public Person(String name, int age, Date d) {
       this.name = name;
       this.age = age;
       this.birthDate = d; }
    public Person(String name, int age) {
       this(name, age, null);
    }
    public Person(String name, Date d) {
       this(name, 30, d);
    }
    public Person(String name) {
       this(name, 30);
    } }public class Student extends Person {
    private String school;
    public Student(String name, int age, String s) {
      super(name, age);
      school = s; 
    }
    public Student(String name, String s) {
      super(name);
      school = s; 
    }// 编译出错: no super(),系统将调用父类无参数的构造器。
    public Student(String s) { 
      school = s; 
    } }

三、this和super的区别

No.	区别点	this	super
1	访问属性	访问本类中的属性，如果本类没有此属性则从父类中继续查找	直接访问父类中的属性
2	调用方法	访问本类中的方法，如果本类没有此方法则从父类中继续查找	直接访问父类中的方法
3	调用构造器	调用本类构造器，必须放在构造器的首行	调用父类构造器，必须放在子类构造器的首行

四、子类对象实例化的全过程

（1）从结果上来看：（继承性）
 子类继承父类以后，就获取了父类中声明的属性或方法。
 创建子类的对象，在堆空间中，就会加载所有父类中声明的属性。

（2）从过程上来看：
当我们通过子类的构造器创建子类对象时，我们一定会直接或间接的调用其父类的构造器，进而调用父类的父类的构造器，…直到调用了java.lang.Object类中空参的构造器为止。正因为加载过所有的父类的结构，所以才可以看到内存中有父类中的结构，子类对象才可以考虑进行调用。

（3）明确：虽然创建子类对象时，调用了父类的构造器，但是自始至终就创建过一个对象，即为new的子类对象。

推荐学习：《java视频教程》

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!