Les classes et les objets dans Java

Apprenez à associer des classes, des champs, des méthodes, des constructeurs et des objets dans vos applications Java.

Les classes, les champs, les méthodes, les constructeurs et les objets sont les éléments constitutifs des applications Java basées sur des objets. Ce tutoriel vous apprend à déclarer des classes, à décrire des attributs via des champs, à décrire des comportements via des méthodes, à initialiser des objets via et à instancier des objets à partir de classes et d’accéder à leurs membres. Vous en apprendrez également sur les setters et getters et les méthodes, etc.

• Déclaration de classe
• Classes utilitaires
• Application multi-classes et main()
• Classes publiques
• Description des attributs
• Méthodes: description des comportements
• Setters et Getters
• Variables locales

Déclaration de classe

Une classe est un modèle pour la fabrication d’objets. Vous déclarez une classe en spécifiant le mot-clé de class suivi d’un identificateur non réservé qui le nomme. Une paire de caractères d’accolade d’ouverture et de fermeture ({et}) coordonnés suit et délimite le corps de la classe. Cette syntaxe apparaît ci-dessous:

identifiant de classe
{
   // corps de classe
}

Par convention, la première lettre du nom d’une classe est mise en majuscule et les caractères suivants en minuscule (par exemple, Employes). Si un nom est composé de plusieurs mots, la première lettre de chaque mot est placée en majuscule (telle que EnrejistrerCompte).

L’exemple suivant déclare une classe nommée Livre:

class Livre
{
   // corps de classe
}

Le corps d’une classe est peuplé de champs, de méthodes et de constructeurs. La combinaison de ces fonctionnalités de langage en classes est appelée encapsulation. Cette fonctionnalité nous permet de programmer à un niveau d’abstraction plus élevé (classes et objets) plutôt que de nous concentrer séparément sur les structures et les fonctionnalités de données.

Classes utilitaires

Une classe peut être conçue pour n’avoir rien à voir avec la fabrication d’objets. Au lieu de cela, il existe un espace réservé pour les champs de classe et / ou les méthodes de classe. Une telle classe est connue sous le nom de classe utilitaire. Un exemple de classe utilitaire est la classe Math de la bibliothèque de classes standard Java.

Applications multi-classes et main ()

Une application Java est implémentée par une ou plusieurs classes. Les petites applications peuvent être hébergées par une seule classe, mais les applications plus grandes nécessitent souvent plusieurs classes. Dans ce cas, l’une des classes est désignée comme classe principale et contient la méthode main (). Par exemple, une application construite à l’aide de trois classes: A, B et C; C est la classe principale.

Une application Java avec plusieurs classes

Class A
{
}

Class B
{
}

class C
{
   public static void main (String [] args)
   {
      System.out.println ("Point d'entrée de l'application C");
   }
}

Vous pouvez déclarer ces trois classes dans un seul fichier source, tel que D.java. Vous devez ensuite compiler ce fichier source comme suit:

javac D.java

Le compilateur génère trois fichiers de classe: A.class, B.class et C.class. Exécutez cette application via la commande suivante:

java C

Vous devriez observer le résultat suivant:

Point d'entrée de l'application C

Vous pouvez également déclarer chaque classe dans son propre fichier source. Par convention, le nom du fichier source correspond au nom de la classe. Vous déclareriez A dans A.java, par exemple. Vous pouvez ensuite compiler ces fichiers sources séparément:

javac A.java
javac B.java
javac C.java

Pour gagner du temps, vous pouvez compiler les trois fichiers source en même temps en remplaçant le nom du fichier par un astérisque (tout en conservant l’extension du fichier .java):

javac * .java

Dans les deux cas, vous exécuteriez l’application via la commande suivante:

java C

Classes publics

Java vous permet de déclarer une classe avec un accès publique via le mot clé public. Lorsque vous déclarez une classe publique, vous devez la stocker dans un fichier portant le même nom. Par exemple, vous stockeriez la classe publique C {} dans C.java. Vous ne pouvez déclarer qu’une seule classe publique dans un fichier source.

Lors de la conception d’applications multi-classes, vous allez désigner l’une de ces classes comme classe principale et y localiser la méthode main (). Cependant, rien ne vous empêche de déclarer les méthodes main () dans les autres classes, peut-être à des fins de test.

Déclarer plus d’une méthode main()

class A
{
public static void main(String[] args)
{
System.out.println("Tester la classe A");
}
}

class B
{
public static void main(String[] args)
{
System.out.println("Tester la classe B");
}
}

class C
{
public static void main(String[] args)
{
System.out.println("Point d 'entrée de l'application C");
}
}

Après avoir compilé le code source, vous devez exécuter les commandes suivantes pour tester les classes A et B et pour exécuter la classe d’application C:

java A
java B
java C

Vous observeriez alors les lignes de sortie suivantes, une ligne par commande java:

Classe d'essai A
Classe d'essai B
Point d'entrée de l'application C

Faites attention avec la méthode main ()

Placer une méthode main () dans chaque classe surtout si vous oubliez de documenter la classe principale. En outre, vous pourriez oublier de supprimer ces méthodes avant de mettre l’application en production. Dans ce cas, leur présence ajouterait du volume à l’application. En outre, une personne peut exécuter l’une des classes de support, ce qui peut perturber l’environnement de l’application.

Description des attributs

Une classe modélise une entité du monde réel en termes d’état (attributs). Par exemple, un véhicule a une couleur et un compte courant a un solde. Une classe peut également inclure un état non entité. Quoi qu’il en soit, l’état est stocké dans des variables appelées champs. Une déclaration de champ a la syntaxe suivante:

[statique] identificateur de type [= expression];

Une déclaration de champ commence éventuellement par le mot clé static (pour un attribut non entité) et se poursuit avec un type suivi d’un identificateur non réservé qui nomme le champ. Le champ peut être explicitement initialisé en spécifiant = suivi d’une expression avec un type compatible. Un point-virgule termine la déclaration.

L’exemple suivant déclare une paire de champs dans Livre:

Class Livre
{
   Titre de chaîne;
   int pubAnnee; // année de publication
}

Les champs titre et pubAnnee stockent les valeurs d’un livre spécifique. Cependant, vous pouvez stocker un état indépendant de tout livre. Par exemple, vous pouvez enregistrer le nombre total d’objets de livre créés. Voici comment vous le feriez:

class Livre
{
// ...

static int count;
}

Cet exemple déclare un champ nombre entier qui stocke le nombre d’objets Livre créés. La déclaration commence par le mot-clé static pour indiquer qu’il n’y a qu’une seule copie de ce champ en mémoire.

Chaque objet Livre peut accéder à cette copie et aucun objet n’a sa propre copie. Pour cette raison, count est appelé champ de classe.

Initialisation

Les champs précédents n’ont pas reçu de valeurs. Lorsque vous n’initialisez pas explicitement un champ, il est implicitement initialisé avec tous ses bits mis à zéro. Vous interprétez cette valeur par défaut comme false (pour booléen), ‘\ u0000’ (pour char), 0 (pour int), 0L (pour long), 0.0F (pour float), 0.0 (pour double) ou null (pour un type de référence).

Cependant, il est également possible d’initialiser explicitement un champ lorsque celui-ci est déclaré. Par exemple, vous pouvez spécifier static int count = 0; (ce qui n’est pas nécessaire car le nombre par défaut est 0), String logfile = « log.txt » ;, static int ID = 1 ;, ou même double sinPIDiv2 = Math.sin (Math.PI / 2) ;.

Bien que vous puissiez initialiser un champ d’instance par une affectation directe, il est plus courant d’exécuter cette initialisation dans un constructeur, ce que je démontrerai plus tard. En revanche, un champ de classe (en particulier une constante de classe) est généralement initialisé par l’affectation directe d’une expression au champ.

Durée de vie et portée

Un champ d’instance est né lorsque son objet est créé et meurt lorsqu’il est collecté. Un champ de classe est né lorsque la classe est chargée et meurt lorsque la classe est déchargée ou lorsque l’application se termine. Cette propriété est appelée durée de vie.

Les champs d’instance et de classe sont accessibles depuis leurs déclarations jusqu’à la fin de leurs classes déclarantes. En outre, ils ne sont accessibles au code externe que dans un contexte d’objet (pour les champs d’instance) ou d’objet et de classe (pour les champs de classe) lorsque des niveaux d’accès appropriés sont définis. Cette propriété est appelée étendue.

Méthodes: description des comportements

En plus de modéliser l’état d’une entité du monde réel, une classe modélise également ses comportements. Par exemple, un véhicule prend en charge le mouvement et un compte courant prend en charge les dépôts et les retraits. Une classe peut également inclure des comportements non-entités. Quoi qu’il en soit, les programmeurs Java utilisent des méthodes pour décrire les comportements. Une déclaration de méthode a la syntaxe suivante:

[static] typeDeRetour identificateur ( [listParametres] )
{
// corp de methode
}

Une déclaration de méthode commence éventuellement par le mot clé static (pour un comportement autre que l’entité) et se poursuit avec un type de retour typeDeRetour suivi d’un identificateur non réservé qui nomme la méthode. Le nom est ensuite suivi par une liste de paramètres facultative, listParametres, délimitée par des parenthèses . Un corps délimité par des accolades contenant du code à exécuter lorsque la méthode est appelée.

Le type de retour identifie le type de valeurs renvoyées par la méthode via l’instruction return, dont je parlerai plus tard. Par exemple, si une méthode retourne des chaînes, son type de retour serait défini sur String. Lorsqu’une méthode ne renvoie pas de valeur, son type de retour est défini sur void.

La liste de paramètres est une liste de déclarations de paramètres séparées par des virgules: chaque déclaration consiste en un type suivi d’un identificateur non réservé qui nomme le paramètre. Un paramètre est une variable qui reçoit un argument (une valeur d’expression dont le type est compatible avec le paramètre correspondant) lors de l’appel d’une méthode ou d’un constructeur.

Un paramètre est local à sa méthode ou à son constructeur. Il entre en existence lorsque la méthode ou le constructeur est appelé et disparaît lorsque la méthode ou le constructeur revient à son appelant. En d’autres termes, sa durée de vie est l’exécution de la méthode. Un paramètre peut être accédé par n’importe quel code de la méthode. Sa portée est la méthode entière.

L’exemple suivant déclare quatre méthodes de la classe Livre:

class Livre
{
// ...

String getTitre()
{
return titre;
}int 

getPubAnnee()
{
return pubAnnee;
}

void setTitre(String _titre)
{
titre = _titre;
}

void setPubAnee(int _pubAnnee)
{
pubAnee = _pubAnee;
}
}

Les méthodes getTitre () et getPubAnnee () renvoient les valeurs de leurs champs respectifs. Ils utilisent l’instruction return pour renvoyer ces valeurs à l’appelant. Notez que le type d’expression de cette instruction doit être compatible avec le type de retour de la méthode.

Les méthodes setTitre () et setPubAnnee () vous permettent de définir les valeurs des champs titre et pubAnnee. Leurs types de retour sont définis sur mot clé void pour indiquer qu’ils ne renvoient aucune valeur à leurs appelants. Les quatre méthodes sont appelées méthodes d’instance car elles n’affectent que les objets sur lesquels elles sont appelées.

Setters et Getters

Le préfixe « set » identifie les méthodes setTitre () et setPubAnnee (), ce qui signifie qu’elles définissent des valeurs. De même, le préfixe « get » identifie getTitre () et getPubAnnee () en tant que méthodes getter, ce qui signifie qu’elles obtiennent des valeurs.

Les méthodes getTitre (), getPubAnnee(), setTitre () et setPubAnnee () affectent les copies d’un seul objet des champs titre et pubAnnee. Cependant, vous voudrez peut-être déclarer une méthode indépendante de tout livre. Par exemple, vous pouvez introduire une méthode qui génère le nombre d’objets Livre, comme suit:

class Livre
{
// ...

static void showCount()
{
System.out.println("count = " + count);
}
}

Cet exemple déclare une méthode showCount () qui affichera la valeur du champ count. La déclaration commence par le mot clé static pour indiquer que cette méthode appartient à la classe et ne peut pas accéder à l’état de l’objet individuel; aucun objet n’a besoin d’être créé. Pour cette raison, showCount () est connue sous le nom de méthode de classe.

Variables locales

Dans une méthode ou un constructeur, vous pouvez déclarer des variables supplémentaires dans le cadre de son implémentation. Ces variables sont appelées variables locales car elles sont locales à la méthode / au constructeur. Ils n’existent que pendant l’exécution de la méthode ou du constructeur et ne sont pas accessibles depuis l’extérieur de la méthode / du constructeur. Prenons l’exemple suivant:

static void average(double[] valeurs)
{
double sum = 0.0;
for (int i = 0; i < valeurs.length; i++)
sum += valeurs[i];
System.out.println("Average: " + (sum / values.length));
}

Cet exemple présente une méthode nommée moyenne pour calculer et afficher la moyenne d’un tableau de doubles. En plus des valeurs de paramètre, il déclare les variables locales somme et i pour aider au calcul. La durée de vie et la portée de sum vont de son point de déclaration à la fin de la méthode. La durée de vie et la portée de i sont limitées à la boucle for.