Flux de contrôle d'instance en Java

Le flux de contrôle d'instance est un concept fondamental du langage de programmation Java qu'un débutant comme un expérimenté doit connaître. En Java, le flux de contrôle d'instance est un processus étape par étape d'exécution des membres situés au sein de la classe. Les membres qui existent à l'intérieur d'une classe incluent des variables d'instance, des méthodes d'instance et des blocs d'instance.

Chaque fois que nous exécutons un programme Java, JVM recherche d'abord la méthode main(), puis charge la classe en mémoire. En allant plus loin, la classe est initialisée et son bloc statique, le cas échéant, est exécuté. Après l'exécution du bloc statique, le flux de contrôle de l'instance commence. Dans cet article, nous allons expliquer ce qu'est un flux de contrôle d'instance.

Flux de contrôle d'instance en Java

Dans la section précédente, nous avons présenté le flux de contrôle des instances. Dans cette section, nous en discuterons en détail à travers des exemples de programmes.

Les étapes suivantes sont impliquées dans le processus de flux de contrôle d'instance :

• 第一步是从类的顶部到底部识别实例成员，如实例变量、实例方法和实例块

• La deuxième étape est l'exécution de la variable d'instance de la classe. Les variables d'instance sont déclarées à l'intérieur de la classe mais en dehors de la méthode. Généralement, pour afficher leurs valeurs, nous devons définir soit un constructeur, soit une méthode.

• Ensuite, les blocs d'instance sont exécutés par JVM dans l'ordre dans lequel ils apparaissent dans la classe. Ces blocs sont des blocs anonymes utilisés pour initialiser les variables d'instance.

• Dans la quatrième étape, la JVM invoque le constructeur de la classe pour initialiser l'objet.

• 进一步移动，调用实例方法来执行各自的操作。

• Au final, le garbage collector est appelé pour libérer la mémoire.

Exemple 1

的中文翻译为：

示例 1

下面的示例演示了Instance控制流的整个过程。

public class Example1 {
   int x = 10; // instance variable 
   // instance block
   {
      System.out.println("Inside an instance block"); 
   }
   // instance method
   void showVariable() {
      System.out.println("Value of x: " + x); 
   }
   // constructor
   Example1() {
      System.out.println("Inside the Constructor"); 
   }
   public static void main(String[] args) {
      System.out.println("Inside the Main method");
      Example1 exp = new Example1(); // creating object
      exp.showVariable(); // calling instance method
   }
}

输出

Inside the Main method
Inside an instance block
Inside the Constructor
Value of x: 10

Exemple 2

的中文翻译为：

示例2

L'exemple suivant illustre le flux de contrôle d'instance dans la relation parent-enfant. Les membres d'instance de la classe Parent sont exécutés avant ceux de la classe Child.

// creating a parent class
class ExmpClass1 {
   int x = 10; // instance variable of parent
   // first instance block
   {
      System.out.println("Inside parent first instance block"); 
   }
   // constructor of parent class
   ExmpClass1() {
      System.out.println("Inside parent constructor"); 
      System.out.println("Value of x: " + this.x);
   }
   // Second instance block
   {
      System.out.println("Inside parent second instance block"); 
   }
}
// creating a child class
class ExmpClass2 extends ExmpClass1 {
   int y = 20; // instance variable of child
   // instance block of child
   {
      System.out.println("Inside instance block of child"); 
   }
   // creating constructor of child class
   ExmpClass2() {
      System.out.println("Inside child constructor"); 
      System.out.println("Value of y: " + this.y);
   }
}
public class Example2 {
   public static void main(String[] args) {
      // creating object of child class
      ExmpClass2 cls = new ExmpClass2(); 
      System.out.println("Inside the Main method");
   }
}

输出

Inside parent first instance block
Inside parent second instance block
Inside parent constructor
Value of x: 10
Inside instance block of child
Inside child constructor
Value of y: 20
Inside the Main method

结论

Dans cet article, nous avons compris l'ensemble du processus de flux de contrôle d'instance en Java. Il y a un total de six étapes dans ce processus. Fondamentalement, le flux de contrôle d'instance nous indique comment la machine virtuelle Java exécute les membres d'une classe.

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!