INFO0101 - Introduction à Java

INFO0101 - Algorithmique et Programmation 1: Le langage Java

Plan de la séance

• Structure d'un programme Java

• Variables, types

• Mots-clés

• Opérateurs

• Structures de sélection

• Boucles

Historique et Caractéristiques de Java

• Créé en 1991 par SUN (maintenant Oracle).

• Conçu initialement pour le code embarqué et les applets pour navigateurs Web.

• Versions notables: Java 2 (1999), Java SE 6.0 (2006), Java SE 10-11 (2018).

• Dernières versions: Java SE 24 (sept. 2024) et Java SE 21 (LTS).

• Java est un langage de Programmation Orientée Objet (POO), caractérisé par:

  • Objets, classes, encapsulation.

  • Héritage.

  • Permet la programmation structurée.

  • Deux catégories de programmes : Interface console (écran + clavier) et Interface graphique (GUI) (souris, boutons, fenêtres).

  • Portabilité grâce à la JVM (Machine virtuelle Java).

Étapes de programmation et Structure de base

• Écriture du code source: dans un fichier `.java` (ex: `NomDuProgramme.java`) avec un éditeur de texte (Notepad++, Visual Studio Code).

• Compilation: `javac NomDuProgramme.java` génère un fichier `.class` (bytecode). La JVM interprète ce bytecode.

• Exécution: `java NomDuProgramme` lance la JVM et exécute le programme.

• Structure minimale d'un programme Java:

  class PremierProg {
          public static void main (String[] args) {
              System.out.println("Mon premier programme Java (et non le dernier !)");
          }
      }

  • `class PremierProg`: définit la classe principale.

  • `public static void main (String[] args)`: la procédure principale.

  • `System.out.println`: routine Java pour l'affichage à l'écran.

  • Les accolades `{...}` délimitent les blocs de code.

Entrées et Sorties

• Affichage à l'écran :

  • `System.out.print("texte")`: affiche sans retour à la ligne.

  • `System.out.println("texte")`: affiche avec un retour à la ligne.

• Entrées au clavier :

  • Importation de la classe Scanner: `import java.util.Scanner;`

  • Déclaration d'un objet Scanner: `Scanner clavier = new Scanner(System.in);`

  • Lecture des entrées selon le type: `clavier.nextLine()` (chaîne), `clavier.nextInt()` (entier), `clavier.nextDouble()` (réel).

Identificateurs et mots-clés

• Identificateurs :

  • Suites de caractères pour nommer les entités (variables, fonctions, classes).

  • Doivent commencer par une lettre, peuvent contenir des lettres, chiffres, `_` et `$`.

  • Java est sensible à la casse (ex: `Nom` et `nom` sont différents).

• Mots-clés :

  • Mots réservés par le langage (ex: `int`, `if`, `while`, `class`, `public`, `static`, etc.).

  • Ne peuvent être utilisés comme identificateurs.

Mise en forme d'un programme et commentaires

• Format libre :

  • Le code peut être écrit de manière flexible, mais une bonne pratique est d'avoir une instruction par ligne et d'indenter les blocs pour une meilleure lisibilité.

• Commentaires :

  • `/* ... */`: Bloc de commentaire sur plusieurs lignes.

  • `// ...`: Commentaire de fin de ligne.

Programmer Java à la maison (Windows)

• Télécharger le JDK (Java SE Development Kit) depuis le site d'Oracle (ex: JDK 21 ou 24).

• Installer le JDK en suivant les instructions.

• Des détails supplémentaires sont disponibles sur le Web-cours Moodle.

Types de données Java

• Entiers :

  • Types: `byte` (1 octet), `short` (2 octets), `int` (4 octets), `long` (8 octets).

  • Exemple `int n;` (variable de type entier).

  • L'amplitude varie selon le type (ex: `byte` de -128 à 127).

  • Représentation en binaire (complément à 2 pour les nombres négatifs).

• Réels (nombres à virgule flottante) :

  • Deux types principaux : `float` (simple précision, 4 octets) et `double` (double précision, 8 octets).

  • Exemple: `double x;` (variable de type double).

  • Les réels sont des valeurs approchées .

  • Les constantes peuvent être décimales (ex: `6567.4552`) ou scientifiques (ex: `6.5674552e3`). Pour `float`, ajouter `f` (ex: `12.123f`).

  • Représentation en binaire basée sur le signe, l'exposant et la mantisse.

• Caractères :

  • Mot-clé: `char`.

  • Représentés en Unicode (2 octets), permettant de gérer un éventail plus large de caractères que l'ASCII.

  • Constantes de type caractère sont entre guillemets simples (ex: `'a'`, `'E'`, `'+'`).

• Booléens :

  • Mot-clé: `boolean`.

  • Représentent des valeurs logiques `true` (vrai) ou `false` (faux).

  • Exemple: `boolean ordonne = (n < p);`.

• Initialisation des variables :

  • Une variable doit être déclarée et initialisée avant d'être utilisée.

  • Peut être fait en deux étapes: `int n; n = 15;` ou en une seule: `int n = 15;`.

  • Constantes: Utiliser le mot-clé `final` pour déclarer une variable qui ne peut pas être modifiée (ex: `final int n = 20;`).

Opérateurs en Java

• Opérateurs arithmétiques :

  • Binaires: `+` (addition), `-` (soustraction), `*` (multiplication), `/` (division), `%` (modulo).

  • Unaires: `+` (identité), `-` (opposé).

  • Conversions implicites : Java ajuste les types automatiquement (ex: `int n = 5; float x = 2.5f; double y = n * x;` convertira `n` en `float`).

• Opérateurs relationnels :

  • `<` (inférieur strict), `<=` (inférieur ou égal), `>` (supérieur strict), `>=` (supérieur ou égal), `==` (égal), `!=` (différent de).

• Opérateurs logiques :

  • `!` (négation), `&&` (ET logique avec court-circuit), `||` (OU inclusif avec court-circuit), `^` (OU exclusif).

  • Le court-circuit signifie que le second opérande n'est évalué que si nécessaire.

• Opérateur d'affectation :

  • `=` : Affecte une valeur à une variable. Le premier opérande doit être une variable ou une référence.

  • Soumis aux règles de conversion implicites (ex: `byte` -> `short` -> `int` -> `long` -> `float` -> `double`).

• Opérateurs d'incrémentation et de décrémentation :

  • `++` (incrément), `--` (décrément).

  • Peuvent être préfixés (`++i`, `--i`) ou postfixés (`i++`, `i--`).

  • L'effet sur l'expression diffère selon la position de l'opérateur (ex: si `i=5`, `n = ++i - 5` donne `n=1`, alors que `n = i++ - 5` donne `n=0`).

• Opérateurs d'affectation élargie :

  • Remplacent `variable = variable opérateur expression` par `variable opérateur= expression` (ex: `i += k` au lieu de `i = i + k`).

  • Valable pour les opérateurs arithmétiques.

• Opérateurs de cast (transtypage) :

  • `(type) expression` : Force la conversion d'une expression dans un type choisi.

  • Exemple : `(double) (n/p)` convertit le résultat entier de `n/p` en `double`.

  • Attention aux parenthèses pour le résultat d'une expression.

Premières Structures de Sélection en Java

• Blocs et instructions :

  • `Instruction` simple se termine par un point-virgule (`;`).

  • `Bloc` : suite d'instructions entre accolades (`{...}`).

• `if ... else` (Si... alors... Sinon) :

  if (condition) {
          Instruction1;
      } else {
          Instruction2;
      }

  • `condition`: expression booléenne.

  • Les accolades ne sont pas obligatoires si le bloc contient une seule instruction.

• `switch` (Cas... Parmi) :

  switch (expression) {
          case Constante1:
              Instruction1;
              break;
          case Constante2 :
              Instruction2;
              break;
          default :
              InstructionDefaut;
      }

  • `expression`: doit être de type entier, chaîne de caractères ou énumération.

  • `case`: chaque bloc `case` doit se terminer par `break` pour éviter l'exécution des `case` suivants.

  • `default`: est exécuté si aucune `case` ne correspond.

Structures Itératives en Java

• `for` (Pour) :

  for (initialisation; condition; incrémentation) {
          Instruction;
      }

  • Utile lorsque le nombre d'itérations est connu d'avance.

  • `initialisation`: exécutée une seule fois au début.

  • `condition`: vérifiée avant chaque itération.

  • `incrémentation`: exécutée après chaque itération.

• `while` (TantQue) :

  while (condition) {
          Instruction;
      }

  • La `Instruction` est exécutée tant que la `condition` est vraie. La condition est évaluée avant chaque itération.

• `do...while` (Faire...TantQue) :

  do {
          Instruction;
      } while (condition);

  • Similaire à `while`, mais la `Instruction` est exécutée au moins une fois, car la `condition` est évaluée après l'exécution du bloc.

Synthèse et Réflexion

• Ce cours fournit les bases pour commencer à écrire des programmes utiles.

• La programmation demande de la pratique constante (compléter les TP, faire des projets personnels).

• Un bon programme doit être correct, bien conçu et maintenable (facile à comprendre et à modifier).

• Comprendre et respecter les « bonnes pratiques » est essentiel pour le développement en équipe.