Variables et opérateurs en Java

Introduction

Dans ce laboratoire (lab), nous explorerons les concepts fondamentaux de la programmation Java : les variables et les opérateurs. Nous apprendrons à déclarer différents types de variables, à comprendre plusieurs types de données primitifs et à utiliser divers opérateurs et expressions. Cette expérience pratique fournira une base solide aux débutants en programmation Java.

Skills Graph

Comprendre les variables et les types de données

Les variables sont des emplacements de stockage nommés qui contiennent des valeurs en programmation. Java propose plusieurs types de données primitifs, chacun conçu pour stocker des types spécifiques de valeurs. Explorons ces concepts à travers des exemples pratiques.

Tout d'abord, nous allons créer un fichier Java pour démontrer la déclaration et l'utilisation de variables. Dans le WebIDE (qui est similaire à VS Code), créez un nouveau fichier nommé VariableDemo.java. Vous pouvez le faire en cliquant avec le bouton droit dans le panneau de l'explorateur de fichiers, en sélectionnant "Nouveau fichier" et en entrant le nom de fichier.

Copiez et collez le code suivant dans le fichier :

public class VariableDemo {
    public static void main(String[] args) {
        // Declaring and initializing variables of different types
        byte smallNumber = 127;
        short mediumNumber = 32000;
        int largeNumber = 2000000000;
        long veryLargeNumber = 9000000000000000000L;
        float decimalNumber = 3.14f;
        double preciseDecimal = 3.14159265359;
        char singleCharacter = 'A';
        boolean isJavaFun = true;

        // Printing the values
        System.out.println("byte: " + smallNumber);
        System.out.println("short: " + mediumNumber);
        System.out.println("int: " + largeNumber);
        System.out.println("long: " + veryLargeNumber);
        System.out.println("float: " + decimalNumber);
        System.out.println("double: " + preciseDecimal);
        System.out.println("char: " + singleCharacter);
        System.out.println("boolean: " + isJavaFun);
    }
}

Décortiquons ce code pour mieux le comprendre :

1. Nous commençons par déclarer une classe nommée VariableDemo. En Java, chaque programme doit avoir au moins une classe.

2. À l'intérieur de la classe, nous avons la méthode main. C'est le point d'entrée de notre programme Java, où l'exécution commence.

3. Nous déclarons ensuite et initialisons des variables de différents types de données primitifs :

   • byte : Utilisé pour de très petites valeurs entières (-128 à 127)
   • short : Utilisé pour de petites valeurs entières (-32 768 à 32 767)
   • int : Utilisé pour des valeurs entières (environ -2 milliards à 2 milliards)
   • long : Utilisé pour de très grandes valeurs entières (environ -9 quintillions à 9 quintillions)
   • float : Utilisé pour les nombres décimaux (précision simple)
   • double : Utilisé pour les nombres décimaux avec une précision plus élevée
   • char : Utilisé pour les caractères simples
   • boolean : Utilisé pour les valeurs vraies/fausses

4. Notez le suffixe L pour la valeur long et le suffixe f pour la valeur float. Ceux-ci sont nécessaires pour indiquer à Java que ces littéraux doivent être traités respectivement comme des long et des float.

5. Enfin, nous affichons chaque variable à l'aide de System.out.println(). L'opérateur + ici est utilisé pour la concaténation de chaînes de caractères, joignant la chaîne descriptive à la valeur de la variable.

Maintenant, exécutons ce programme. Dans le WebIDE, ouvrez le panneau du terminal et exécutez la commande suivante :

javac VariableDemo.java
java VariableDemo

Vous devriez voir une sortie similaire à ceci dans le panneau de la console :

byte: 127
short: 32000
int: 2000000000
long: 9000000000000000000
float: 3.14
double: 3.14159265359
char: A
boolean: true

Cette sortie montre les valeurs de chaque variable que nous avons déclarées et initialisées. Prenez un moment pour vérifier que chaque valeur affichée correspond à celle que nous avons assignée dans le code.

Utilisation des opérateurs arithmétiques

Les opérateurs arithmétiques en Java nous permettent d'effectuer des calculs mathématiques. Créons un nouveau fichier pour démontrer ces opérateurs.

Dans le WebIDE, créez un nouveau fichier nommé ArithmeticDemo.java. Copiez et collez le code suivant :

public class ArithmeticDemo {
    public static void main(String[] args) {
        int a = 10;
        int b = 3;

        System.out.println("Addition: " + (a + b));
        System.out.println("Subtraction: " + (a - b));
        System.out.println("Multiplication: " + (a * b));
        System.out.println("Division: " + (a / b));
        System.out.println("Modulus: " + (a % b));

        // Increment and decrement
        int c = 5;
        System.out.println("c before increment: " + c);
        System.out.println("c after increment: " + (++c));
        System.out.println("c after decrement: " + (--c));
    }
}

Décortiquons ce code :

1. Nous déclarons deux variables entières, a et b, et leur assignons respectivement les valeurs 10 et 3.

2. Nous effectuons ensuite diverses opérations arithmétiques :

   • Addition (+) : Ajoute deux nombres
   • Soustraction (-) : Soustrait l'opérande de droite de l'opérande de gauche
   • Multiplication (*) : Multiplie deux nombres
   • Division (/) : Divise l'opérande de gauche par l'opérande de droite
   • Modulo (%) : Renvoie le reste lorsque l'opérande de gauche est divisé par l'opérande de droite

3. Nous démontrons également les opérateurs d'incrémentation (++) et de décrémentation (--) :

   • ++c incrémente la valeur de c de 1 avant qu'elle ne soit utilisée dans l'expression
   • --c décrémente la valeur de c de 1 avant qu'elle ne soit utilisée dans l'expression

Exécutez ce programme dans le WebIDE. Vous devriez voir une sortie similaire à ceci :

Addition: 13
Subtraction: 7
Multiplication: 30
Division: 3
Modulus: 1
c before increment: 5
c after increment: 6
c after decrement: 5

Notez que lors de la division d'entiers (a / b), Java effectue une division entière, tronquant toute partie décimale. C'est pourquoi 10 / 3 donne 3 et non 3.33333....

Observez également comment les opérateurs d'incrémentation et de décrémentation affectent la valeur de c. Comprendre ces opérateurs est crucial pour de nombreuses tâches de programmation, en particulier lorsqu'on travaille avec des boucles.

Comprendre les opérateurs binaires

Les opérateurs binaires (bitwise operators) en Java permettent de manipuler les bits individuels des types entiers. Ces opérateurs sont moins utilisés dans la programmation quotidienne, mais sont cruciaux dans certains scénarios, comme le traitement de données binaires ou l'optimisation de certains algorithmes.

Dans le WebIDE, créez un nouveau fichier nommé BitwiseDemo.java. Copiez et collez le code suivant :

public class BitwiseDemo {
    public static void main(String[] args) {
        int a = 60;  // 60 = 0011 1100 in binary
        int b = 13;  // 13 = 0000 1101 in binary

        System.out.println("a & b = " + (a & b));   // AND
        System.out.println("a | b = " + (a | b));   // OR
        System.out.println("a ^ b = " + (a ^ b));   // XOR
        System.out.println("~a = " + (~a));         // NOT
        System.out.println("a << 2 = " + (a << 2)); // Left Shift
        System.out.println("a >> 2 = " + (a >> 2)); // Right Shift
    }
}

Décortiquons ces opérations binaires :

1. ET (&) : Renvoie 1 si les deux bits sont à 1, sinon 0.

   • 60 & 13 = 0011 1100 & 0000 1101 = 0000 1100 (12 en décimal)

2. OU (|) : Renvoie 1 si au moins un bit est à 1, sinon 0.

   • 60 | 13 = 0011 1100 | 0000 1101 = 0011 1101 (61 en décimal)

3. OU exclusif (^) : Renvoie 1 si les bits sont différents, 0 s'ils sont identiques.

   • 60 ^ 13 = 0011 1100 ^ 0000 1101 = 0011 0001 (49 en décimal)

4. NON (~) : Inverse tous les bits.

   • ~60 = ~0011 1100 = 1100 0011 (-61 en décimal, en raison de la représentation en complément à deux)

5. Décalage à gauche (<<) : Décale tous les bits vers la gauche du nombre de positions spécifié.

   • 60 << 2 = 0011 1100 << 2 = 1111 0000 (240 en décimal)

6. Décalage à droite (>>) : Décale tous les bits vers la droite du nombre de positions spécifié.

   • 60 >> 2 = 0011 1100 >> 2 = 0000 1111 (15 en décimal)

Exécutez ce programme dans le WebIDE. Vous devriez voir une sortie similaire à ceci :

a & b = 12
a | b = 61
a ^ b = 49
~a = -61
a << 2 = 240
a >> 2 = 15

Comprendre les opérateurs binaires peut être difficile au début, mais ils sont très puissants pour certains types d'opérations, en particulier lorsqu'on travaille avec la programmation de bas niveau ou qu'on optimise le code pour des raisons de performance.

Explorer les opérateurs logiques

Les opérateurs logiques en Java sont utilisés pour effectuer des opérations logiques sur des valeurs booléennes. Ces opérateurs sont essentiels pour créer des conditions complexes dans vos programmes.

Dans le WebIDE, créez un nouveau fichier nommé LogicalDemo.java. Copiez et collez le code suivant :

public class LogicalDemo {
    public static void main(String[] args) {
        boolean a = true;
        boolean b = false;

        System.out.println("a && b = " + (a && b)); // Logical AND
        System.out.println("a || b = " + (a || b)); // Logical OR
        System.out.println("!a = " + (!a));         // Logical NOT

        // Short-circuit evaluation
        int x = 5;
        int y = 10;
        System.out.println("x < 0 && y++ > 5 = " + (x < 0 && y++ > 5));
        System.out.println("y after evaluation: " + y);
    }
}

Décortiquons ces opérations logiques :

1. ET logique (&&) : Renvoie true si les deux opérandes sont true, sinon false.

   • true && false = false

2. OU logique (||) : Renvoie true si au moins un opérande est true, sinon false.

   • true || false = true

3. NON logique (!) : Inverse la valeur booléenne.

   • !true = false

4. Évaluation à court-circuit (short-circuit evaluation) : Dans l'expression x < 0 && y++ > 5, Java évalue d'abord x < 0. Comme cela est false, il n'essaie pas d'évaluer la deuxième partie (y++ > 5), car le résultat global doit être false dans tous les cas. C'est pourquoi y reste égal à 10 après l'évaluation.

Exécutez ce programme dans le WebIDE. Vous devriez voir une sortie similaire à ceci :

a && b = false
a || b = true
!a = false
x < 0 && y++ > 5 = false
y after evaluation: 10

Comprendre les opérateurs logiques est crucial pour créer des conditions dans vos programmes, par exemple dans les instructions if ou les boucles while. Le comportement à court-circuit des opérateurs && et || peut également être utilisé pour optimiser votre code dans certaines situations.

Mettre tout en pratique

Maintenant que nous avons exploré différents types d'opérateurs, créons un simple programme de calculatrice qui utilise plusieurs types d'opérateurs. Cela nous aidera à consolider ce que nous avons appris et à montrer comment ces concepts peuvent être appliqués dans un scénario pratique.

Dans le WebIDE, créez un nouveau fichier nommé SimpleCalculator.java. Copiez et collez le code suivant :

public class SimpleCalculator {
    public static void main(String[] args) {
        int a = 10;
        int b = 5;

        // Arithmetic operations
        System.out.println("Arithmetic Operations:");
        System.out.println("a + b = " + (a + b));
        System.out.println("a - b = " + (a - b));
        System.out.println("a * b = " + (a * b));
        System.out.println("a / b = " + (a / b));
        System.out.println("a % b = " + (a % b));

        // Bitwise operations
        System.out.println("\nBitwise Operations:");
        System.out.println("a & b = " + (a & b));
        System.out.println("a | b = " + (a | b));
        System.out.println("a ^ b = " + (a ^ b));
        System.out.println("~a = " + (~a));

        // Logical operations
        boolean x = a > b;
        boolean y = a < b;
        System.out.println("\nLogical Operations:");
        System.out.println("x && y = " + (x && y));
        System.out.println("x || y = " + (x || y));
        System.out.println("!x = " + (!x));

        // Combining operations
        System.out.println("\nCombined Operations:");
        System.out.println("(a + b) * 2 = " + ((a + b) * 2));
        System.out.println("(a > b) && (a % b == 0) = " + ((a > b) && (a % b == 0)));
    }
}

Décortiquons ce code et expliquons chaque partie :

1. Opérations arithmétiques :

   • Nous effectuons des opérations arithmétiques de base (addition, soustraction, multiplication, division et modulo) sur a et b.
   • Ces opérations démontrent comment utiliser les opérateurs arithmétiques que nous avons appris précédemment.

2. Opérations binaires (bitwise operations) :

   • Nous effectuons des opérations binaires ET (AND), OU (OR), OU exclusif (XOR) et NON (NOT) sur a et b.
   • Ces opérations montrent comment les opérateurs binaires fonctionnent sur les représentations binaires des entiers.

3. Opérations logiques :

   • Nous créons deux variables booléennes, x et y, basées sur des comparaisons entre a et b.
   • Nous démontrons ensuite des opérations logiques ET (AND), OU (OR) et NON (NOT) sur ces valeurs booléennes.

4. Opérations combinées :

   • Nous montrons comment différents types d'opérateurs peuvent être combinés dans des expressions plus complexes.
   • (a + b) * 2 démontre l'utilisation de parenthèses pour contrôler l'ordre des opérations.
   • (a > b) && (a % b == 0) combine une comparaison, une opération de modulo et un ET logique.

Exécutez ce programme dans le WebIDE. Vous devriez voir une sortie similaire à ceci :

Arithmetic Operations:
a + b = 15
a - b = 5
a * b = 50
a / b = 2
a % b = 0

Bitwise Operations:
a & b = 0
a | b = 15
a ^ b = 15
~a = -11

Logical Operations:
x && y = false
x || y = true
!x = false

Combined Operations:
(a + b) * 2 = 30
(a > b) && (a % b == 0) = true

Cette sortie démontre comment chaque type d'opérateur fonctionne :

• Les opérations arithmétiques produisent les résultats mathématiques attendus.
• Les opérations binaires montrent les résultats de la manipulation des représentations binaires de a et b.
• Les opérations logiques montrent comment les valeurs booléennes peuvent être combinées.
• Les opérations combinées démontrent comment nous pouvons créer des expressions plus complexes en utilisant plusieurs types d'opérateurs.

Comprendre comment combiner ces opérateurs est crucial pour écrire des programmes Java plus complexes et efficaces. Au fur et à mesure de votre progression dans l'apprentissage du Java, vous utiliserez ces opérateurs en diverses combinaisons pour résoudre des problèmes de plus en plus complexes.

Résumé

Dans ce laboratoire, nous avons exploré les concepts fondamentaux de la programmation Java : les variables et les opérateurs. Nous avons appris à déclarer et à utiliser différents types de variables, y compris les types de données primitifs tels que int, boolean et char. Nous avons ensuite approfondi les différents opérateurs en Java :

1. Les opérateurs arithmétiques pour les calculs mathématiques de base
2. Les opérateurs binaires (bitwise operators) pour manipuler les bits individuels des types entiers
3. Les opérateurs logiques pour travailler avec des valeurs booléennes

À travers des exemples pratiques, nous avons vu comment ces opérateurs peuvent être utilisés individuellement et en combinaison pour effectuer une grande variété d'opérations. Nous avons créé un simple programme de calculatrice qui a démontré l'utilisation de plusieurs types d'opérateurs dans une seule application.