Objets et constructeurs

1. Créer un objet

Eh bien, nous sommes arrivés à créer des objets. Vous avez déjà rencontré cela auparavant, mais nous allons maintenant analyser ce sujet plus en détail. Il est en fait très facile de créer des objets.

Pour créer un objet, vous devez utiliser l' opérateur new . La création d'un objet ressemble approximativement à ceci :

new Class(arguments)

Après avoir créé un objet, nous enregistrons le plus souvent immédiatement une référence à celui-ci dans une variable, qui partage très souvent le même type que l'objet créé. Cela signifie que lors de la création d'un objet, vous voyez généralement un code comme celui-ci :

Class name = new Class(arguments)

Où est la création d'une nouvelle variable, et le code à droite du signe égal est la création d'un nouvel objet dont le type est .Class nameClass

Exemples:

Object o = new Object();

Cat pet = new Cat();

Scanner console = new Scanner(System.in)

Les programmeurs nomment souvent les variables d'après leurs classes, mais avec une lettre minuscule. Pour un programmeur novice, un tel code peut prêter à confusion :

BufferedReader bufferedReader = new BufferedReader( reader );

Cat cat = new Cat();

PersonInfo personInfo = new PersonInfo()

Il n'y a rien de mal avec ce code — c'est le code le plus ordinaire, dans lequel une variable est créée puis immédiatement initialisée par un objet de même type.

A gauche du signe égal nous avons la création d'une variable. A droite, la création d'un objet. C'est ça.

2. Constructeur

Vous avez probablement vu que certains arguments sont fréquemment passés lors de la création d'un objet. De plus, des arguments sont passés pour certains objets, mais pas pour d'autres. Comment fonctionne tout ce mécanisme avec des arguments ?

Ici aussi, tout est simple : chaque classe possède une méthode (ou des méthodes) spéciale(s) chargée(s) de gérer les arguments passés lors de la création d'un objet. Ces méthodes sont appelées constructeurs . Ou quand on parle d'un seul : le constructeur .

Il est facile de distinguer une méthode constructeur d'une méthode régulière. Cette méthode a deux caractéristiques distinctives :

• le nom d'un constructeur est le même que le nom de sa classe (et commence par une majuscule)
• un constructeur n'a pas de type de retour.

En général, voici à quoi cela ressemble habituellement :

modifiers Class(arguments)
{
   Code
}

Exemple:

public class Point
{
   public int x;
   public int y;

   Point(int x, int y)
   {
      this.x = x;
      this.y = y;
   }
}

public class Solution
{
   public static void main(String[] args)
   {
      Point point = new Point(5, 10);
   }
}

Remarquez à quoi ressemble le constructeur : il n'a pas de type de retour et son nom est le même que le nom de la classe.

Et encore une chose : regardez le code à l'intérieur du constructeur. Les paramètres du constructeur ont les mêmes noms que les champs de la classe : x et y. Il est de pratique courante d'éviter de créer de nouveaux noms de paramètres. Les noms sont les mêmes que ceux des champs de la classe. Le conflit de nom est résolu à l'aide du mot-clé this.

3. Appeler un constructeur

Lorsque vous utilisez l' opérateur new et une commande comme "new Class ( arguments )" pour créer un nouvel objet, deux choses se produisent :

• La machine Java crée un objet dont le type est Class
• La machine Java appelle le constructeur de l'objet et transmet vos arguments

En tant que programmeur, vous décidez quels constructeurs votre classe doit avoir et quels paramètres ces constructeurs doivent avoir.

Supposons que vous décidiez de créer une classe pour suivre les chats dans un refuge pour animaux. Ensuite, votre Catclasse pourrait ressembler à ceci :

class Cat
{
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

La Catclasse n'a qu'un seul constructeur avec les paramètres de nom et d'âge. Comme il n'y a pas d'autres constructeurs, vous devez passer le nom du chat ( name) et l'âge ( age) comme arguments lors de la création d'un objet. Passer des arguments au constructeur n'est pas facultatif .

4. Plusieurs constructeurs

Mais si vous en avez besoin, vous pouvez ajouter plusieurs constructeurs à la classe. Il n'y a pas de limite au nombre de constructeurs ou à leurs paramètres. Lorsque vous créez un objet, le compilateur sélectionne automatiquement le constructeur qui correspond aux paramètres

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }
   public Cat(String name)
   {
      this.name = name;
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat("Whiskers");

Cat cat = new Cat();

Nous avons décidé de tenir compte du fait que l'âge d'un chat peut ne pas être connu. Pour gérer ce cas, nous avons ajouté la constante spéciale UNKNOWNavec un constructeur qui n'a qu'un seul paramètre - le nom du chat.

Notez que nous initialisons toujours les deux variables à l'intérieur des deux constructeurs. Nous remplaçons les paramètres inconnus/manquants par la constante UNKNOWN.

Si aucune valeur n'est attribuée à la variable d'âge, elle aura la valeur par défaut de 0. Après tout, un chaton trouvé dans la rue peut très bien avoir 0 ans complets. Cela signifie qu'un zéro dans la variable d'âge ne signifie pas nécessairement "âge inconnu".

5. Constructeur par défaut

Si vous voulez que vos objets soient instanciés sans aucun paramètre, votre classe doit déclarer un constructeur sans argument.

Un constructeur sans paramètres n'est pas nécessairement un constructeur sans code. Un tel constructeur peut contenir du code qui initialise des variables avec des valeurs de départ :

class Cat
{
   public static final int UNKNOWN = -1;
   public String name;
   public int age;

   public Cat(String name, int age)
   {
      this.name = name;
      this.age = age;
   }

   public Cat()
   {
      this.name = "Nameless";
      this.age = UNKNOWN; // Unknown
   }
}

Cat cat = new Cat("Whiskers", 2);

Cat cat = new Cat();

Constructeur par défaut

Il y a un point très important que vous devez connaître et retenir.

Si votre classe ne déclare pas un constructeur , le compilateur ajoutera un constructeur par défaut, qui est un constructeur sans argument avec le modificateur public.

Mais si votre classe déclare ne serait-ce qu'un seul constructeur , aucun constructeur par défaut ne sera ajouté et vous devrez l'ajouter vous-même si vous le souhaitez.

class Cat
{
   public String name;
   public int age;
}

Cat cat = new Cat();