Constructeur de tutoriel de base Java et surcharge de méthodes

Dans les méthodes et les données membres, nous avons mentionné que les objets en Java sont initialisés lors de leur création. Lors de l'initialisation, les données membres de l'objet se voient attribuer des valeurs initiales. Nous pouvons l'initialiser explicitement. Si nous n'attribuons pas de valeur initiale au membre de données, le membre de données prendra une valeur initiale par défaut en fonction de son type.

L'initialisation explicite nous oblige à déterminer la valeur initiale lors de l'écriture du programme, ce qui est parfois très gênant. Nous pouvons utiliser un constructeur pour initialiser des objets. Les constructeurs peuvent initialiser les données membres et spécifier des opérations spécifiques. Ces opérations sont effectuées automatiquement lors de la création de l'objet.

Définir le constructeur

Un constructeur est une méthode. Comme les méthodes normales, nous définissons des constructeurs dans la classe. Le constructeur a les caractéristiques de base suivantes :

1. Le nom du constructeur est le même que le nom de la classe
2 Le constructeur n'a pas de valeur de retour

Nous définissons le. constructeur de la classe Humain :

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

public class Test

{

public static void main(String[] args)

{

Humain aPerson = new Human(160);

System.out .println(aPerson.getHeight());

}

}

classe Humain

{

/**

   * constructeur

   */

Humain(int h)

{

this.height = h;

System.out.println("Je suis né");

}

/**

   * accesseur

   */

int getHeight ()

{

return this.height;

}

int hauteur;

}

Le programme ci-dessus imprimera

I'm born
160

Le constructeur peut recevoir une liste de paramètres comme une méthode normale . Ici, le constructeur Human() reçoit un entier en paramètre. Dans le corps de la méthode, nous attribuons le paramètre entier à la hauteur du membre de données. Les constructeurs font deux choses lorsqu'un objet est créé :

Les constructeurs peuvent recevoir une liste de paramètres comme une méthode normale. Ici, le constructeur Human() reçoit un entier en paramètre. Dans le corps de la méthode, nous attribuons le paramètre entier à la hauteur du membre de données. Le constructeur fait deux choses lorsque l'objet est créé :

1. Fournit une valeur initiale pour le membre de données this.height = h
2. Effectue des opérations initiales spécifiques. 'm born");

De cette façon, nous pouvons définir de manière flexible la valeur initiale lors de l'appel du constructeur sans être aussi contraint que l'initialisation de l'affichage.

Comment s'appelle le constructeur ? Lorsque nous créons des classes, nous utilisons tous new Human(). En fait, nous appelons le constructeur de la classe Human. Lorsque nous ne définissons pas cette méthode, Java fournira un constructeur vide à appeler lors de l'utilisation de new. Mais lorsque nous définissons un constructeur, Java appellera le constructeur défini lors de la création d'un objet. Lors de l'appel, nous fournissons un paramètre de 160. Vous pouvez également voir dans les résultats finaux d'exécution que la hauteur de l'objet est bien initialisée à 160.

Priorité de la méthode d'initialisation

Dans les méthodes et les données membres, nous pouvons voir que si nous fournissons une valeur initiale explicite, alors le membre de données adoptera une valeur initiale explicite au lieu de la valeur initiale par défaut. Mais si nous fournissons tous les deux une valeur initiale explicite et initialisons le même membre de données dans le constructeur, la valeur initiale finale sera déterminée par le constructeur. Par exemple, dans l'exemple suivant :

public class Test
{
  public static void main(String[] args)
  {
    Human aPerson = new Human(160);
    System.out.println(aPerson.getHeight());
  }
 
}
 
class Human
{
  /**
   * constructor
   */
  Human(int h)
  {
    this.height = h; 
  }
 
  /**
   * accessor
   */
  int getHeight()
  {
    return this.height;
  }
 
  int height=170; // explicit initialization
}

Le résultat d'exécution est :

160

La valeur d'initialisation finale de l'objet est cohérente avec la valeur dans la méthode de construction. Par conséquent :

Méthode de construction> Valeur initiale explicite> Valeur initiale par défaut

(En fait, la soi-disant priorité est liée à l'ordre d'exécution lors de l'initialisation Connexes, j'y reviendrai en profondeur plus tard)

Surcharge de méthode

Plusieurs constructeurs peuvent être définis dans une classe, tels que :

public class Test
{
  public static void main(String[] args)
  {
    Human neZha  = new Human(150, "shit");
    System.out.println(neZha.getHeight()); 
  }
 
}
 
class Human
{
  /**
   * constructor 1
   */
  Human(int h)
  {
    this.height = h;
    System.out.println("I'm born");
  }
 
  /**
   * constructor 2
   */
  Human(int h, String s)
  {
    this.height = h;
    System.out.println("Ne Zha: I'm born, " + s);
  }
 
  /**
   * accessor
   */
  int getHeight()
  {
    return this.height;
  }
 
  int height;
}

Exécuter le résultat :

Ne Zha: I'm born, shit
150

Deux constructeurs sont définis ci-dessus, tous deux nommés Humain. Les deux constructeurs ont des listes de paramètres différentes.

Lors de l'utilisation de new pour créer un objet, Java décidera quel constructeur construire en fonction des paramètres fournis. Par exemple, lors de la construction de neZha, nous fournissons deux paramètres : l'entier 150 et la chaîne "shit", qui correspond à la liste des paramètres de la deuxième méthode de build, donc Java appellera la deuxième méthode de build.

En Java, Java déterminera la méthode à appeler en fonction à la fois du nom de la méthode et de la liste des paramètres. C'est ce qu'on appelle la surcharge de méthode. La méthode build peut être surchargée, et les méthodes ordinaires peuvent également être surchargées. Par exemple, la méthode Breath() ci-dessous :

public class Test
{
  public static void main(String[] args)
  {
    Human aPerson = new Human();
    aPerson.breath(10);
  }
 
}
 
class Human
{
  /**
    * breath() 1
    */
  void breath()
  {
    System.out.println("hu...hu...");
  }
 
 
  /**
  * breath() 2
  */
  void breath(int rep)
  {
    int i;
    for(i = 0; i < rep; i++) {
      System.out.println("lu...lu...");
    }
  }
 
  int height;
}

Résultats en cours d'exécution :

lu...lu...
lu...lu...
lu...lu...
lu...lu...
lu...lu...
lu...lu...
lu...lu...
lu...lu...
lu...lu...
lu...lu...

Vous pouvez le voir. en raison de l'invocation, un paramètre est fourni : l'entier 10, donc la deuxième méthode Breath() dont la liste de paramètres lui correspond est appelée.

Résumé

Fonctionnalités du constructeur : même nom que la classe, aucune valeur de retour
Objectif du constructeur : initialisation, opération initiale
Surcharge de méthode : liste des paramètres du nom de la méthode-> Quelle méthode est réellement appelée

Plus Pour les articles liés au didacticiel de base Java sur les constructeurs et la surcharge de méthodes, veuillez faire attention au site Web PHP chinois !