Laboratoire sur les types de données et opérations de base en Java | Apprendre les fondamentaux de Java

Introduction

Bienvenue dans le laboratoire sur les types de données et les opérations de base en Java ! Dans ce laboratoire, nous allons plonger dans les éléments fondamentaux de la programmation Java. Vous explorerez les entiers, les nombres à virgule flottante et les chaînes de caractères, qui constituent la base de tout programme Java. Ne vous inquiétez pas si ces termes vous semblent un peu nouveaux ; nous expliquerons chaque concept étape par étape et nous nous entraînerons à les utiliser dans du code réel.

Vous acquerrez également une expérience pratique des opérations arithmétiques de base et de la concaténation de chaînes. Ces compétences sont essentielles pour tout programmeur Java, et leur maîtrise vous préparera au succès pour la suite de votre apprentissage.

À la fin de ce laboratoire, vous aurez une solide compréhension de la manière de manipuler différents types de données en Java et vous serez prêt à relever des défis de programmation plus complexes. Commençons !

Travailler avec des nombres entiers

Commençons notre voyage en explorant les nombres entiers en Java. Les entiers sont des nombres entiers sans virgule, fréquemment utilisés en programmation pour le comptage, l'indexation et bien d'autres usages.

Ouvrez le fichier IntegerDemo.java dans l'éditeur WebIDE. Vous verrez le code suivant :
```
public class IntegerDemo {
    public static void main(String[] args) {
        // TODO: Declare an integer variable and print it
    }
}
```
C'est la structure de base d'un programme Java. La méthode main est le point de départ de l'exécution de notre programme.
Remplaçons maintenant le commentaire TODO par du code réel. Ajoutez les lignes suivantes :
```
int number = 42;
System.out.println("The number is: " + number);
```
Analysons ce code :
- int number = 42; : Cette ligne crée une variable nommée number de type int (entier) et lui assigne la valeur 42.
- System.out.println("The number is: " + number); : Cette ligne affiche un message. L'opérateur + est ici utilisé pour la concaténation de chaînes, ce qui signifie qu'il combine le texte "The number is: " avec la valeur de notre variable number.
Excellent travail ! Enregistrez maintenant le fichier. Dans la plupart des IDE, y compris WebIDE, l'enregistrement est automatique, mais c'est une bonne habitude de s'assurer que votre fichier est bien enregistré.
Ensuite, nous devons compiler notre programme. La compilation convertit notre code Java lisible par l'homme en une forme que l'ordinateur peut exécuter. Exécutez cette commande dans le terminal :
```
javac ~/project/IntegerDemo.java
```
Si vous ne voyez aucune sortie, c'est bon signe ! Cela signifie que notre code a été compilé sans erreur.
Maintenant que nous avons compilé notre programme, exécutons-le. Utilisez cette commande :
```
java -cp ~/project IntegerDemo
```
Note : java -cp indique à Java où trouver les fichiers de classe compilés. Dans ce cas, nous demandons à Java de chercher dans le répertoire ~/project.

Ou bien, vous pouvez naviguer vers le répertoire ~/project et exécuter le programme avec :
```
cd ~/project
java IntegerDemo
```
Si tout a fonctionné correctement, vous devriez voir le résultat : The number is: 42

Félicitations ! Vous venez de créer, compiler et exécuter votre premier programme Java manipulant des entiers. Si vous avez rencontré des erreurs, ne vous inquiétez pas : le codage implique souvent du dépannage. Vérifiez votre code pour détecter d'éventuelles fautes de frappe et assurez-vous d'avoir suivi chaque étape avec soin.

Opérations arithmétiques de base

Maintenant que nous sommes à l'aise avec les entiers, explorons comment effectuer des opérations arithmétiques de base en Java. Ces opérations sont les briques élémentaires de calculs plus complexes en programmation.

Modifions notre fichier IntegerDemo.java pour inclure quelques opérations arithmétiques. Remplacez son contenu par le code suivant :
```
public class IntegerDemo {
    public static void main(String[] args) {
        int number1 = 10;
        int number2 = 5;

        // TODO: Perform arithmetic operations and print the results
    }
}
```
Ici, nous avons déclaré deux variables entières, number1 et number2, que nous utiliserons dans nos calculs.
Remplaçons maintenant le commentaire TODO par du code effectuant des opérations arithmétiques de base. Ajoutez les lignes suivantes :
```
int sum = number1 + number2;
int difference = number1 - number2;
int product = number1 * number2;
int quotient = number1 / number2;

System.out.println("Number 1: " + number1);
System.out.println("Number 2: " + number2);
System.out.println("Sum: " + sum);
System.out.println("Difference: " + difference);
System.out.println("Product: " + product);
System.out.println("Quotient: " + quotient);
```
Analysons cela :
- Nous effectuons quatre opérations arithmétiques de base : l'addition (+), la soustraction (-), la multiplication (*) et la division (/).
- Nous stockons chaque résultat dans une nouvelle variable.
- Enfin, nous affichons tous les nombres et les résultats.
Enregistrez votre fichier, puis compilez et exécutez à nouveau le programme en utilisant les mêmes commandes qu'auparavant :
```
javac ~/project/IntegerDemo.java
java -cp ~/project IntegerDemo
```
Vous devriez voir une sortie affichant les nombres originaux et les résultats de toutes les opérations arithmétiques.
```
Number 1: 10
Number 2: 5
Sum: 15
Difference: 5
Product: 50
Quotient: 2
```
Avez-vous remarqué quelque chose d'intéressant concernant le quotient ? Même si 10 divisé par 5 donne 2.0, notre résultat est simplement 2. C'est parce que lorsque vous divisez deux entiers en Java, le résultat est également un entier. Toute partie décimale est tronquée (coupée), et non arrondie.

Expérimentez avec ce programme ! Essayez de changer les valeurs de number1 et number2 pour voir comment cela affecte les résultats. C'est un excellent moyen de comprendre comment fonctionne l'arithmétique en Java.

Travailler avec des nombres à virgule flottante

Maintenant que nous maîtrisons les entiers, explorons les nombres à virgule flottante. Ce sont des nombres qui peuvent comporter des décimales, ce qui nous permet de représenter des fractions ou des mesures plus précises.

Ouvrez le fichier FloatDemo.java. Vous verrez ce code de départ :

public class FloatDemo {
    public static void main(String[] args) {
        // TODO: Declare and use floating-point numbers
    }
}

Remplaçons le commentaire TODO par du code démontrant l'utilisation des nombres à virgule flottante :
```
double pi = 3.14159;
System.out.println("The value of pi is approximately: " + pi);

double radius = 5.0;
double area = pi * radius * radius;
System.out.println("The radius of the circle is: " + radius);
System.out.println("The area of the circle is: " + area);

// Demonstrating precision
double result = 0.1 + 0.2;
System.out.println("0.1 + 0.2 = " + result);
```
Analysons cela :
- Nous utilisons le type double pour les nombres à virgule flottante. Il offre une meilleure précision que le type float.
- Nous définissons pi et l'utilisons pour calculer l'aire d'un cercle.
- La dernière partie démontre une particularité de l'arithmétique à virgule flottante qui surprend souvent les débutants.
Enregistrez votre fichier, puis compilez et exécutez le programme :
```
javac ~/project/FloatDemo.java
java -cp ~/project FloatDemo
```
Vous devriez voir une sortie similaire à celle-ci :
```
The value of pi is approximately: 3.14159
The radius of the circle is: 5.0
The area of the circle is: 78.53975
0.1 + 0.2 = 0.30000000000000004
```
Avez-vous remarqué quelque chose d'étrange sur la dernière ligne ? Même si nous savons que 0.1 + 0.2 devrait être exactement égal à 0.3, notre programme affiche une valeur légèrement différente. Cela est dû à la manière dont les ordinateurs représentent les nombres décimaux en binaire. C'est une source fréquente de confusion pour les nouveaux programmeurs, mais dans la plupart des applications pratiques, cette minuscule divergence n'a pas d'importance.

Les nombres à virgule flottante nous permettent de travailler avec une gamme de valeurs beaucoup plus large que les entiers, y compris des nombres très grands et très petits. Ils sont essentiels pour les calculs scientifiques, les graphismes et bien d'autres applications.

Travailler avec des chaînes de caractères

Notre dernier sujet pour ce laboratoire concerne les chaînes de caractères (Strings). En programmation, une chaîne est une séquence de caractères, comme des mots ou des phrases. Les chaînes sont cruciales pour manipuler du texte dans nos programmes.

Ouvrez le fichier StringDemo.java. Vous verrez ce code de départ :

public class StringDemo {
    public static void main(String[] args) {
        // TODO: Declare and manipulate strings
    }
}

Remplaçons le commentaire TODO par du code démontrant diverses opérations sur les chaînes :

String greeting = "Hello";
String name = "Alice";

// String concatenation
String message = greeting + ", " + name + "!";
System.out.println(message);

// String length
System.out.println("The length of the message is: " + message.length());

// Accessing characters in a string
System.out.println("The first character is: " + message.charAt(0));

// Converting to uppercase
System.out.println("Uppercase message: " + message.toUpperCase());

// Substring
System.out.println("First five characters: " + message.substring(0, 5));

Analysons cela :

Nous créons des chaînes en utilisant des guillemets doubles.
Nous pouvons concaténer (joindre) des chaînes en utilisant l'opérateur +.
Les chaînes en Java sont accompagnées de nombreuses méthodes utiles comme length(), charAt(), toUpperCase() et substring().
Les chaînes sont "indexées à zéro", ce qui signifie que le premier caractère est à la position 0.

Enregistrez votre fichier, puis compilez et exécutez le programme :

javac ~/project/StringDemo.java
java -cp ~/project StringDemo

Vous devriez voir une sortie démontrant diverses opérations sur les chaînes :

Hello, Alice!
The length of the message is: 13
The first character is: H
Uppercase message: HELLO, ALICE!
First five characters: Hello

Les chaînes en Java sont incroyablement polyvalentes et disposent de nombreuses méthodes intégrées pour les manipuler. Au fur et à mesure que vous poursuivrez votre apprentissage de Java, vous découvrirez bien d'autres opérations utiles sur les chaînes.

Mettre tout cela ensemble

Pour notre dernière étape, créons un programme qui rassemble tout ce que nous avons appris. Nous allons réaliser un convertisseur de température simple qui utilise des entiers, des nombres à virgule flottante et des chaînes de caractères.

Ouvrez le fichier TemperatureConverter.java. Vous verrez ce code de départ :

public class TemperatureConverter {
    public static void main(String[] args) {
        // TODO: Implement temperature conversion
    }
}

Remplacez le commentaire TODO par le code suivant :

int fahrenheit = 98;
double celsius = (fahrenheit - 32) * 5.0 / 9.0;

String message = fahrenheit + " F is equal to " + celsius + " C";
System.out.println(message);

// Rounding to two decimal places
double roundedCelsius = Math.round(celsius * 100.0) / 100.0;
String formattedMessage = String.format("%d F is equal to %.2f C", fahrenheit, roundedCelsius);
System.out.println(formattedMessage);

// Converting the other way
celsius = 37.0;
fahrenheit = (int) (celsius * 9.0 / 5.0 + 32);
System.out.println(celsius + " C is approximately " + fahrenheit + " F");

Ce programme démontre :

L'utilisation des types int et double
L'exécution de calculs impliquant différents types
La concaténation de chaînes pour l'affichage
L'utilisation de la méthode Math.round() pour l'arrondi
L'utilisation de String.format() pour un meilleur contrôle du formatage de sortie
Le transtypage (casting) d'un double vers un int (dans la seconde conversion)

Enregistrez, compilez et exécutez le programme :

javac ~/project/TemperatureConverter.java
java -cp ~/project TemperatureConverter

Vous devriez voir une sortie affichant les conversions de température avec différents niveaux de précision :

98 F is equal to 36.666666666666664 C
98 F is equal to 36.67 C
37.0 C is approximately 98 F

Ce programme final rassemble tous les concepts que nous avons abordés : entiers, nombres à virgule flottante, chaînes de caractères, opérations arithmétiques et transtypage. Il introduit également quelques nouveaux concepts comme l'arrondi et le formatage de sortie, qui vous seront très utiles dans votre parcours de programmation Java.

Résumé

Félicitations ! Vous avez terminé le laboratoire sur les types de données et les opérations de base en Java. Récapitulons ce que vous avez appris :

Travailler avec des nombres entiers et effectuer des opérations arithmétiques de base
Utiliser des nombres à virgule flottante pour des calculs plus précis
Manipuler des chaînes de caractères et effectuer des concaténations
Combiner différents types de données dans un programme pratique (convertisseur de température)
Utiliser des opérations de formatage et d'arrondi de base

Ces compétences constituent la base de la programmation Java et seront essentielles pour la suite de votre parcours dans le développement logiciel. N'oubliez pas que la programmation est une compétence qui s'améliore avec la pratique. N'hésitez pas à expérimenter avec les concepts appris ici. Essayez de modifier les programmes, de changer les valeurs ou d'ajouter de nouveaux calculs.

À mesure que vous avancerez, vous construirez sur ces bases pour créer des programmes plus complexes et puissants. Continuez à coder, continuez à apprendre et, surtout, amusez-vous ! Vous êtes sur la bonne voie pour devenir un expert Java.

Types de données et opérations de base en Java