Comprendre un programme

1. Introduction

Les variables permettent de mémoriser, pendant l’exécution d’une application, différentes valeurs utiles à son bon fonctionnement.

Avant d’utiliser une variable dans un programme, il est important de savoir où la déclarer, quel nom lui donner, et quel type lui associer. Ces aspects seront détaillés dans les prochaines sections.

2. Les emplacements

En Java, les variables peuvent être déclarées à différents endroits du code, tant qu’elles se trouvent à l’intérieur des accolades d’une classe, d’une interface ou d’une énumération. Il n’est pas possible de déclarer une variable en dehors de ces structures.

Une règle essentielle : une variable doit toujours être déclarée avant d’être utilisée.

Selon l’endroit où elle est déclarée, une variable appartient à l’une des catégories suivantes :

La structure suivante permet de visualiser l’emplacement de ces différentes catégories :

public class EmplacementDesVariables { 
 
    // variable d'instance 
    int instanceVariable; 
 
    // variable de classe 
    static int classVariable; 
 
    void uneMethode(int...

1. Fonctionnement

Il est possible de passer des arguments à un programme Java pour qu’il adapte son comportement en fonction des valeurs fournies. Ces arguments sont accessibles via le tableau de chaînes de caractères nommé args, qui est passé en paramètre à la méthode main.

Pour passer des arguments lors de l’exécution du programme, il suffit d’utiliser l’outil java et d’ajouter les arguments directement après le nom du programme sur la même ligne de commande. Le séparateur utilisé est l’espace. Par exemple :

java MyJavaProgram arg1 arg2 arg3 

Dans ce cas, le tableau args contiendra trois éléments : arg1, arg2 et arg3.

Si un argument contient un espace, il faut entourer la valeur avec des guillemets. Ainsi :

java MyJavaProgram arg1 arg2 "arg 3" 

Dans ce cas, le tableau args contiendra trois éléments : arg1, arg2 et arg3. 

Si un argument contient un espace, il faut entourer la valeur avec des guillemets. Ainsi :

java MyJavaProgram arg1 arg2 "arg \"3\"" 

Dans ce cas, args contiendra les chaînes arg1, arg2 et arg "3".

1. Les opérateurs unaires

Voici les principaux opérateurs unaires disponibles :

L’opérateur ! est uniquement utilisable sur des variables de type boolean ou sur des expressions produisant un résultat de type boolean, comme une comparaison.

Les opérateurs unaires peuvent être employés avec deux notations différentes : la notation préfixée, où l’opérateur est placé avant l’opérande, et la notation postfixée, où l’opérateur est placé après l’opérande. La position de l’opérateur influence le moment où l’opération est appliquée.

Si l’opérateur est en position préfixée, il agit sur l’opérande avant son utilisation dans l’expression.

Si l’opérateur est en position postfixée, il agit après l’utilisation de l’opérande.

Cette distinction peut avoir un impact sur le résultat. Par exemple :

int i; 
i = 3; 
System.out.println(i++); 

Dans cet exemple, l’instruction affiche 3, car l’incrémentation est effectuée après l’utilisation...

1. Présentation

Les structures de contrôle permettent d’agir sur le déroulement d’un programme. Grâce à elles, vous pouvez modifier l’ordre dans lequel les instructions sont exécutées.

On distingue deux grandes familles : les structures de décision, qui permettent de choisir entre plusieurs chemins d’exécution selon une condition, et les structures de boucle, qui permettent de répéter un bloc d’instructions tant qu’une condition est vérifiée, ou jusqu’à ce qu’elle le soit.

2. Structures de décision

if (condition) { 
    instruction; 
} 

if (condition) { 
    instruction1; 
    instruction2; 
    // etc. 
} 

if (condition) { 
    // instructions exécutées si la condition est vraie 
} else { 
    // instructions exécutées si la condition est fausse 
} 

if (condition1) { 
    // instructions si condition1 est vraie 
} else if (condition2) { 
    // instructions si condition2 est vraie 
} else { 
    // instructions exécutées si aucune des conditions précédentes 
    // n'est vraie 
} 

1. Exercice 1

Pour vous entraîner à manipuler des tableaux en Java, cet exercice vous propose de travailler avec un tableau de chaînes de caractères représentant des prénoms. L’objectif est d’apprendre à parcourir un tableau, à analyser son contenu, puis à modifier l’ordre des éléments.

Consignes :

Conseils :

Cet exercice vous permettra de mettre en pratique plusieurs notions abordées dans le chapitre : déclaration de tableaux, parcours avec des boucles, comparaison de chaînes, et modification des données.

2. Exercice 2

Dans cet exercice, vous allez créer...

1. Exercice 1

import java.util.Arrays; 
 
public class Exercice1 { 
    public static void main(String[] args) { 
        // Créer un tableau de cinq prénoms 
        String[] names = {"Alice", "Bob", "Charles", "David", "Eve"}; 
 
        // Afficher chaque prénom un par un dans la console 
        System.out.println("Affichage des prénoms :"); 
        for (String name : names) { 
            System.out.println(name); 
        } 
 
        // Trouver le prénom le plus long 
        String longestName = ""; 
        for (String name : names) { 
            if (name.length() > longestName.length()) { 
                longestName= name; 
            } 
        } 
        System.out.println("Le prénom le plus long est : " + longestName); 
 
        // Inverser l'ordre des prénoms dans le tableau 
        for (int i = 0; i < names.length / 2; i++) { 
            String temp = names[i]; 
            names[i] = names[names.length - 1 - i]; 
            names[names.length - 1 - i] = temp; 
        } 
 
        // Afficher à nouveau tous les prénoms dans l'ordre inversé ...