Objets en Java

1. Objets

Tout en Java est un objet.

Plus précisément, il y a très peu de choses en Java qui ne sont pas des objets. Par exemple, les types primitifs. Mais c'est une exception assez rare à la règle.

Qu'est-ce donc qu'un objet ?

Un objet est une entité qui regroupe des données avec des méthodes qui traitent les données . Quand nous disons "données", nous entendons des variables, bien sûr.

Les variables d'un objet sont appelées ses "données" ou "état".

On dit que les méthodes d'un objet sont son "comportement". Il est d'usage de modifier l'état d'un objet (variables) uniquement à l'aide des méthodes de cet objet. Changer directement les variables d'un objet (sans utiliser ses méthodes) est considéré comme une mauvaise forme.

Chaque objet , ainsi que chaque variable, a un type . Ce type est déterminé une fois lors de la création de l'objet et ne peut plus être modifié par la suite. Le type d'un objet est sa classe.

Chaque objet a sa propre copie de variables d'instance (champs). Si une variable int a non statique est déclarée dans une classe et que votre programme crée 10 objets de cette classe, chaque objet aura sa propre variable int a.

Interagir avec un objet

La façon la plus pratique de travailler avec un objet est de stocker une référence à celui-ci dans une variable, puis d'appeler des méthodes sur cette variable. Cela vous semblera familier :

variable.method()

Où variableest une variable qui stocke une référence à un objet et methodest une méthode de cette classe.

Si vous voulez faire référence à un champ (variable) d'un objet, alors vous devez également utiliser l' opérateur point :

variable.field

Où variableest une variable qui stocke une référence à un objet et fieldest une variable d'instance (champ).

2. newopérateur

Pour créer un objet d'une certaine classe, vous devez utiliser l' newopérateur. En général, voici à quoi ressemble la création d'un objet :

Class variable = new Class(arguments);

Où Classest le nom de la classe de la variablevariable ainsi que le nom de la classe de l'objet à créer. Et variable est une variable qui stocke une référence à l'objet créé. Et argumentsest un espace réservé pour une liste d'arguments séparés par des virgules transmise au constructeur.

La liste spécifique des arguments qui peuvent être passés est décidée par les programmeurs qui écrivent la classe.

Vous avez déjà créé des objets et même utilisé cette construction particulière. Vous n'avez pas oublié, j'espère ?

Scanner console = new Scanner(System.in);
int x = console.nextInt();

Scanner console— cela crée une consolevariable dont le type est Scanner. — cela crée un nouvel objet. Et l'opérateur d'affectation définit la variable égale à une référence à l'objet nouvellement créé.new Scanner(System.in)Scannerconsole

Dans la deuxième ligne, nous appelons la nextInt()méthode sur l' Scannerobjet, en utilisant la consolevariable, qui stocke une référence à l' Scannerobjet.

Exemples de création d'objet :

String s = new String("Hello");

Scanner console = new Scanner("");

int[] data = new int[10];

Les objets créés sont appelés objets de la classe ou instances de la classe , tandis que la classe est appelée la classe de l'objet . Par exemple, la svariable stocke une référence à une instance de la Stringclasse.

3. Présentation des cours

Je pense que vous avez déjà vu à quel point il est très pratique d'utiliser des classes écrites par d'autres programmeurs. Mais qu'en est-il de l'écriture de vos propres cours ?

Comment savez-vous quand et où vous avez besoin de votre propre classe et comment en créer une ?

Les programmeurs créent généralement leurs propres classes lorsqu'ils souhaitent intégrer une nouvelle entité au programme. Cela vous semble-t-il déroutant ? Ensuite, je vais essayer d'expliquer, mais je vais commencer de loin.

Groupe de données

En simplifiant un peu, on peut dire qu'un objet en Java est un bloc de mémoire qui contient les variables déclarées dans une classe (champs d'instance). Ou, en d'autres termes, des variables combinées dans un groupe.

Disons que votre programme a besoin de stocker les coordonnées de 100points et a besoin d'une méthode pour les afficher à l'écran. Cela peut être fait en utilisant des tableaux. Par exemple, comme ceci :

class Solution
{
   public static void printPoints(int[] x, int[] y, int[] color)
   {
     for (int i = 0; i < x.length; i++)
       System.out.println("Color of (" + x[i] + ", " + y[i] + ") = " + color[i]);
   }

   public static void main(String[] args)
   {
     int[] x = new int[100];
     int[] y = new int[100];
     int[] color = new int[100];
     printPoints(x, y, color);
   }
}

Il serait beaucoup plus pratique d'avoir un seul type pour stocker toutes les informations sur un point : x, y, color. Si un tel type n'existe pas en Java, vous pouvez le créer vous-même.

Pour ce faire, nous allons écrire du code pour une Pointclasse :

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

Maintenant, le code ci-dessus peut être réécrit comme suit :

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       System.out.println("Color of (" + points[i].x + ", " + point[i].y + ") = " + points[i].color);
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Ajoutons maintenant une méthode à la Pointclasse qui affichera des informations sur l'objet :

public class Point
{
   public int x;
   public int y;
   public int color;
   public void print()
   {
     System.out.println("Color of (" + x + ", " + y + ") = " + color);
   }
}

Maintenant, la Solutionclasse ressemble à ceci :

class Solution
{
   public static void printPoints(Point[] points)
   {
     for (int i = 0; i < points.length; i++)
       points[i].print();
   }

   public static void main(String[] args)
   {
     Point[] data = new Point[100];
     for (int i = 0; i < data.length; i++)
       data[i] = new Point();
     printPoints(data);
   }
}

Nous avons habilement caché les coordonnées du point et les informations de couleur à l'intérieur de la Pointclasse avec la méthode qui affiche l'état du point.

Les classes sont un moyen de gérer la complexité du programme. Un grand programme devient moins complexe lorsqu'il est divisé en plusieurs petites classes.

4. Objets mutables vs immuables

Il était une fois, nous avons étudié les constantes en Java et sommes arrivés à une conclusion qui n'est pas très réconfortante. Les constantes vous permettent de protéger les variables contre la modification, mais elles ne peuvent pas empêcher les modifications des objets auxquels elles se réfèrent.

Pour résoudre ce problème, Java a proposé des objets constants. Ou, comme on les appelle plus fréquemment, des objets immuables.

Au fait, vous connaissez déjà cette classe, dont les objets ne peuvent pas être modifiés : String. Un Stringobjet reste à jamais inchangé après sa création. Et comment les créateurs de Java y sont-ils parvenus ?

Tout d'abord, toutes les variables de la Stringclasse sont masquées, c'est-à-dire déclarées private.

Deuxièmement, vous ne pouvez pas hériter de la Stringclasse : sa déclaration de classe inclut le finalmodificateur.

Troisièmement, et c'est le plus intéressant, toutes les méthodes de la Stringclasse, qui, en théorie, devraient modifier l'objet existant, ne le modifient pas réellement, mais en renvoient un nouveau.

Par exemple, la toUpperCase()méthode met toutes les lettres de la chaîne en majuscules. Mais au lieu de changer l'objet sur lequel la méthode est appelée, elle renvoie un nouvel Stringobjet composé de lettres majuscules :

String text = "This is a very important message";
String message = text.toUpperCase();

Voici ce qui sera en mémoire après l'exécution de ce code :

N'hésitez donc pas à passer vos chaînes à n'importe quelle méthode : personne ne les changera.