Java - Classe Numbers

Bonjour, aspirants programmeurs Java ! Aujourd'hui, nous allons plonger dans le monde fascinant des nombres en Java. Ne vous inquiétez pas si vous êtes nouveau dans la programmation ; nous commencerons par les bases et nous nous dirigerons vers le haut. À la fin de ce tutoriel, vous jouerez avec les nombres comme un pro !

Introduction aux nombres en Java

En Java, les nombres ne sont pas seulement des valeurs simples ; ils sont des objets avec des superpouvoirs ! Java fournit plusieurs classes pour gérer différents types de nombres. Ces classes font partie du package java.lang, qui est automatiquement importé dans chaque programme Java.

Hiérarchie de la classe Number

Commençons par une vue d'ensemble de la hiérarchie de la classe Number :

Number (abstrait)
|
+-------+-------+
|       |       |
Integer  Float  Double
|
Byte

La classe Number est la classe mère de toutes les classes enveloppes numériques. Elle est abstraite, ce qui signifie que vous ne pouvez pas créer un objet Number directement, mais vous pouvez utiliser ses sous-classes.

Classes enveloppes

Java fournit des classes enveloppes pour chaque type primitif numérique. Ces classes "enveloppent" les valeurs primitives dans des objets, leur conférant une fonctionnalité supplémentaire. Voici un tableau des classes enveloppes numériques les plus couramment utilisées :

Type primitif	Classe enveloppe
byte	Byte
short	Short
int	Integer
long	Long
float	Float
double	Double

Création d'objets Number

Créons quelques objets nombres et voyons comment ils fonctionnent :

Integer intObj = new Integer(42);
Double doubleObj = new Double(3.14159);
Float floatObj = new Float(2.5f);

Dans cet exemple, nous créons des objets de différents types de nombres. Notez comment nous utilisons le mot-clé new suivi du constructeur de la classe enveloppe.

Mais attendez, il y a un moyen plus simple ! Java fournit l'autoboxing, qui convertit automatiquement les primitives en leurs objets enveloppes :

Integer intObj = 42;
Double doubleObj = 3.14159;
Float floatObj = 2.5f;

N'est-ce pas pratique ? Java fait l'enveloppement pour nous en arrière-plan !

Méthodes communes des nombres

Maintenant que nous avons nos objets nombres, explorons quelques-unes des méthodes utiles qu'ils fournissent :

1. valueOf()

La méthode valueOf() est un moyen pratique de créer des objets nombres :

Integer intObj = Integer.valueOf(42);
Double doubleObj = Double.valueOf("3.14159");

Cette méthode est souvent préférée aux constructeurs car elle peut réutiliser des objets mis en cache pour une meilleure performance.

2. xxxValue()

Ces méthodes convertissent l'objet nombre en son type primitif :

Integer intObj = 42;
int intValue = intObj.intValue();
double doubleValue = intObj.doubleValue();

Ici, intValue() renvoie la valeur int, tandis que doubleValue() la convertit en double.

3. compareTo()

Cette méthode compare deux objets nombres :

Integer num1 = 42;
Integer num2 = 100;
int result = num1.compareTo(num2);
System.out.println(result); // Sortie : -1

La méthode compareTo() renvoie :

• Une valeur négative si le premier nombre est inférieur au second
• Zéro s'ils sont égaux
• Une valeur positive si le premier nombre est supérieur au second

4. equals()

Cette méthode vérifie si deux objets nombres sont égaux :

Integer num1 = 42;
Integer num2 = 42;
boolean areEqual = num1.equals(num2);
System.out.println(areEqual); // Sortie : true

N'oubliez pas que equals() compare les valeurs, pas les références d'objets !

Amusez-vous avec les nombres : Un mini-projet

Mettons notre nouvelle connaissance en pratique avec un petit projet. Nous allons créer un simple jeu de devinette de nombre :

import java.util.Random;
import java.util.Scanner;

public class NumberGuessingGame {
public static void main(String[] args) {
Random random = new Random();
Integer secretNumber = random.nextInt(100) + 1;
Scanner scanner = new Scanner(System.in);
Integer guess;
int attempts = 0;

System.out.println("Bienvenue dans le Jeu de devinette de nombre !");
System.out.println("Je pense à un nombre entre 1 et 100.");

do {
System.out.print("Entrez votre devinette : ");
guess = scanner.nextInt();
attempts++;

if (guess.compareTo(secretNumber) < 0) {
System.out.println("Trop bas ! Essayez encore.");
} else if (guess.compareTo(secretNumber) > 0) {
System.out.println("Trop haut ! Essayez encore.");
} else {
System.out.println("Félicitations ! Vous avez deviné le nombre en " + attempts + " tentatives !");
}
} while (!guess.equals(secretNumber));

scanner.close();
}
}

Voici ce qui se passe dans ce code :

1. Nous créons un objet Random pour générer un nombre aléatoire entre 1 et 100.
2. Nous utilisons un Scanner pour lire l'entrée utilisateur.
3. Nous utilisons une boucle do-while pour continuer à demander des devinettes jusqu'à ce que le bon nombre soit deviné.
4. Nous utilisons compareTo() pour vérifier si la devinette est trop basse ou trop haute.
5. Nous utilisons equals() pour vérifier si la devinette est correcte.

Ce jeu montre comment nous pouvons utiliser les objets Number et leurs méthodes dans une application réelle. Ce n'est pas seulement question de stocker des nombres, mais de les manipuler et de les comparer de manière significative.

Conclusion

Nous n'avons qu'effleuré la surface de ce que les classes de nombres de Java peuvent faire. À mesure que vous continuez votre parcours Java, vous découvrirez encore plus de fonctionnalités puissantes et de méthodes. N'oubliez pas que la pratique fait le maître, donc n'hésitez pas à expérimenter avec ces concepts dans vos propres projets.

Continuez à coder, à apprendre, et surtout, amusez-vous avec les nombres Java !

Credits: Image by storyset