Introduction aux classes en Java

class

Java est le langage orienté objet le plus célèbre utilisé par les programmeurs aujourd'hui. Pour obtenir un récit approfondi du fonctionnement de Java, nous devons avoir une compréhension approfondie des classes et des objets. Plongeons dans le monde des objets et des classes et voyons un premier aperçu de leur fonctionnement.

Objets et classes

Si nous regardons une voiture, nous pouvons voir qu'elle se compose de nombreux composants comme les roues, les fenêtres, la pédale d'accélérateur, la pédale de frein, etc. Il y a de nombreux composants sous le capot que nous ne voyons pas, comme le moteur, le radiateur, etc. Lorsque nous parlons d'une voiture, il ne s'agit pas d'un seul objet, mais d'un ensemble d'objets travaillant ensemble.

La même notion s'applique à la programmation informatique, mais l'objet n'est pas un dispositif physique. En java, un objet peut faire 2 choses :

Il peut stocker des données
Il peut effectuer des opérations

Les objets jouent donc un rôle important dans un langage orienté objet. Par exemple, si vous avez besoin de lire les entrées de la console, vous avez besoin d'un objet scanner. La question est comment utilisons-nous ces objets ? Eh bien, ils n'apparaissent pas comme par magie dans un programme ; nous devons créer un objet en mémoire, et avant de créer un objet, nous avons besoin d'une classe.

Une classe décrit un objet particulier, nous pouvons donc dire qu'une classe est un plan d'un objet. Commençons par une démonstration d'un code réel qui montre des classes et des objets Java.

import java.util.Scanner; // Needed for the Scanner class
import java.util.Random; // Needed for the Random class
import java.io.*; // Needed for file I/O classes

 /**
 This program writes random numbers to a file.
 */

 public class ObjectDemo
 {
 public static void main(String[] args) throws IOException
 {
 int maxNumbers; // Max number of random numbers
 int number; // To hold a random number

 // Create a Scanner object for keyboard input.
 Scanner keyboard = new Scanner(System.in);

 // Create a Random object to generate random numbers.
 Random rand = new Random();

 // Create a PrintWriter object to open the file.
 PrintWriter outputFile = new PrintWriter("numbers.txt");

 // Get the number of random numbers to write.
 System.out.print("How many random numbers should I write? ");
 maxNumbers = keyboard.nextInt();

 // Write the random numbers to the file.
 for (int count = 0; count < maxNumbers; count++)
 {
 // Generate a random integer.
 number = rand.nextInt();

 // Write the random integer to the file.
 outputFile.println(number);
 }

 // Close the file.
 outputFile.close();
 System.out.println("Done");
 }
 }

Un détail important à noter à propos de Java est que tout programme est exécutable lorsqu'il a une classe. Contrairement à C++ où la fonction principale est en dehors de la classe, toutes les fonctions sont à l'intérieur d'une classe, même la fonction principale. La classe ObjectDemo écrit essentiellement un nombre spécifié d'entiers aléatoires dans un fichier appelé numbers.txt, et pour ce faire, elle crée 3 instances, à savoir Scanner, PrintWriter et Random.

Lorsque nous travaillons avec des objets, nous utilisons deux éléments :

L'objet lui-même
Une variable de référence qui fait référence à l'objet

L'objet est créé dans la mémoire à l'aide du nouveau mot-clé et contient des données pour effectuer certaines opérations. Pour utiliser l'objet dans le code, nous avons besoin d'une variable de référence, donc par exemple, si nous voulons utiliser l'objet Scanner, nous avons une variable de référence appelée clavier. La variable de référence ne contient aucune valeur. Il contient simplement l'adresse mémoire de l'objet. Cette explication des variables d'objet et de référence peut être mieux expliquée par une figure.

Écrire une classe simple (étape par étape)

Commençons maintenant par notre première démonstration étape par étape de la création d'une classe, de ses variables et de ses méthodes. Ici, nous allons écrire notre classe appelée rectangle. Le rectangle de classe aura la longueur et la largeur des champs suivants. La classe rectangle aura également des fonctions comme getArea.

Commençons par notre code java pour la description.

public class Rectangle
 {
  //keyword private is an access specifier
  private double length;
  private double width;
  
  /**
 The setLength method stores a value in the
 length field.
 @param length The value to store in length.
 */

  public void setLength(double length)
  {
   this.length = length;
  }
 /**
 The setWidth method stores a value in the
 length field.
 @param width The value to store in width.
 */
   public void setWidth(double width)
  {
   this.width = width;
  }

 /**The getArea method returns a Rectangle
 object's area.
 @return The product of length times width
 */
  public void getArea()
  {
  	return length*width;
  }
 }

Le spécificateur privé signifie que nous ne pouvons pas utiliser les variables (longueur, largeur) en dehors de la classe. Le spécificateur public signifie que nous pouvons appeler les méthodes en dehors de la classe.

Nous allons ensuite tester les fonctions écrites dans la classe rectangle en créant une méthode main puis en créant un objet de rectangle.

/**
 This program demonstrates the Rectangle class's
 setLength and setWidth method.
 */

 public class Demo
 {
 public static void main(String[] args)
 {
 // Create a Rectangle object and assign its
 // address to the box variable.

 Rectangle box = new Rectangle();

 // Indicate what we are doing.
 System.out.println("Sending the value 10.0 " +
 "to the setLength method.");
 System.out.println("Sending the value 20.0 " +
 "to the setWidth method.");

 // Call the box object's setLength method.
 box.setLength(10.0);
 box.setWidth(20.0);
 // Display the area.
 System.out.println("The box's area is " +
 box.getArea());
 // Indicate we are done.
 System.out.println("Done.");
 }
 }

Le code ci-dessus doit être enregistré dans le même répertoire que la classe rectangle, puis nous pouvons exécuter la commande suivante pour compiler le programme.

javac Demo.java

Décomposons le code pour mieux comprendre le fonctionnement des objets et des classes :la déclaration.

Rectangle box = new Rectangle();

La commande déclare une variable appelée box et le type de données de la variable est un rectangle. Le nouveau mot clé est utilisé pour créer un objet en mémoire. Après l'exécution de cette instruction, la zone de variable référencera l'objet créé en mémoire, comme indiqué.

Après avoir défini la longueur sur 10 et défini le avec sur 20, l'état de l'objet boîte change.

Éviter les données obsolètes

Maintenant, vous devez vous demander pourquoi l'aire du rectangle n'est pas stockée, comme la longueur et la largeur. La zone n'est pas stockée dans un champ car elle peut devenir obsolète. Lorsque la valeur d'un élément dépend d'une autre donnée et que l'élément n'est pas mis à jour lorsque les données sont mises à jour, l'élément devient obsolète.

Constructeurs

Que sont les constructeurs ? Eh bien, les constructeurs sont une partie cruciale d'une classe. Un constructeur est automatiquement appelé lorsqu'une instance de la classe est créée. Vous êtes-vous déjà demandé pourquoi les constructeurs sont appelés constructeurs ? C'est parce qu'ils aident à construire un objet. Un constructeur a le même nom que la classe et n'a pas de type de retour car les constructeurs ne sont pas exécutés par des appels de méthode explicites et ne peuvent pas retourner de valeur.

Un exemple du fonctionnement des constructeurs dans les classes est présenté ci-dessous :

/**
 Rectangle class
 */

 public class Rectangle
 {
  private double length;
  private double width;

 /**
 Constructor
 @param l The length of the rectangle.
 @param w The width of the rectangle.
 */

 public Rectangle(double l, double w)
 {
 length = l;
 width = w;
 }
 }

Le constructeur présenté ci-dessus est paramétré et sa démonstration est présentée dans la fonction principale.

/**
 This program demonstrates the Rectangle class's
 constructor.
 */

 public class ConstructorDemo
 {
 public static void main(String[] args)
 {
 // Create a Rectangle object, passing 5.0 and
 // 15.0 as arguments to the constructor.
 Rectangle box = new Rectangle(5.0, 15.0);

 // Display the length.
 System.out.println("The box's length is " +
 box.getLength());

 // Display the width.
 System.out.println("The box's width is " +
 box.getWidth());

 // Display the area.
 System.out.println("The box's area is " +
 box.getArea());
 }
 }

Dans la démonstration, la longueur et la largeur sont définies sur 5,0 et 15,0, respectivement, et le résultat de la zone est 5*15 =75.

Un constructeur qui n'accepte pas d'arguments est appelé constructeur sans argument. Par conséquent, le constructeur par défaut est également un constructeur sans argument. Un constructeur par défaut est créé lorsqu'il n'y a pas de constructeur dans la classe.

Diagramme UML

Lors de la conception d'une classe, nous pouvons utiliser le diagramme UML. L'UML signifie Unified Modeling Language et décrit les classes dans un système orienté objet. Alors, à quoi ressemble un UML ?

La première section de l'UML contient le nom de la classe. La deuxième section contient les champs, c'est-à-dire les variables, et la troisième contient les méthodes.

Dans le diagramme UML, nous avons quelques notations. Pour notifier le spécificateur d'accès d'une variable ou d'une méthode, nous avons un signe +, -.

// private access specifier depicted by a - sign and datatype is double
-length: double

Les variables longueur et largeur sont privées car elles commencent par un signe - et leur type de retour est double.

// public specifier is depicted by a + sign
// function has a return type void
// function takes in argument called length which has a return type double
+ setLength(length:double):void

Toutes les méthodes de classe dans l'UML sont des méthodes publiques car elles ont un signe + au début de la méthode.

Conclusion

C'est tout à propos de notre tutoriel d'introduction sur le fonctionnement des objets et des classes en Java. Restez à l'écoute de Code Underscored pour continuer à en apprendre davantage sur les classes et les objets en Java - d'autres guides sont en cours !