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ù variable
est une variable qui stocke une référence à un objet et method
est 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ù variable
est une variable qui stocke une référence à un objet et field
est une variable d'instance (champ).
2. new
opérateur
Pour créer un objet d'une certaine classe, vous devez utiliser l' new
opérateur. En général, voici à quoi ressemble la création d'un objet :
Class variable = new Class(arguments);
Où Class
est le nom de la classe de la variable
variable 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 arguments
est 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 console
variable 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)
Scanner
console
Dans la deuxième ligne, nous appelons la nextInt()
méthode sur l' Scanner
objet, en utilisant la console
variable, qui stocke une référence à l' Scanner
objet.
Exemples de création d'objet :
Code | Description |
---|---|
|
Créer un String objet |
|
Créer un Scanner objet |
|
Créer un int[] : un conteneur d' 10 int éléments |
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 s
variable stocke une référence à une instance de la String
classe.
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 100
points 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 Point
classe :
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 Point
classe 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 Solution
classe 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 Point
classe 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 String
objet 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 String
classe sont masquées, c'est-à-dire déclarées private
.
Deuxièmement, vous ne pouvez pas hériter de la String
classe : sa déclaration de classe inclut le final
modificateur.
Troisièmement, et c'est le plus intéressant, toutes les méthodes de la String
classe, 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 String
objet 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.
GO TO FULL VERSION