Polycopié du cours POO en Java - V2024-11-27 (1) PDF

Département Génie Informatique Département Génie Informatique Support de cours Programmation Orientée Objet en Java Réalisé par :...

Département Génie Informatique Département Génie Informatique Support de cours Programmation Orientée Objet en Java Réalisé par : A.Mazoul Mise à jour : 27 novembre 2024 2 Table des matières Chapitre 1: Introduction à Java et Syntaxe de base........................................................ 10 1 Historique et évolution de Java.................................................................................................. 10 1.1 Naissance de Java............................................................................................................. 10 1.2 Évolution de Java............................................................................................................... 10 2 Environnement de développement............................................................................................ 10 2.1 JVM (Java Virtual Machine)................................................................................................ 10 2.2 Code source et Bytecode Java........................................................................................... 11 2.3 Installation du JDK.............................................................................................................. 11 2.4 Configuration des IDE........................................................................................................ 12 3 Structure d’un programme Java................................................................................................. 13 3.1 La méthode main()............................................................................................................. 13 3.2 Instructions et blocs de code.............................................................................................. 15 3.3 Exercices............................................................................................................................ 15 4 Types de données primitifs en Java........................................................................................... 16 4.1 Types de données primitifs................................................................................................. 16 4.2 Règle pour le Type de Résultat d'Opérations avec des Types Primitifs.............................. 18 4.3 Types de Variables Non-Primitives (Instances) en Java..................................................... 18 5 Opérateurs et expressions......................................................................................................... 19 5.1 Opérateurs arithmétiques................................................................................................... 19 5.2 Opérateurs relationnels...................................................................................................... 20 5.3 Opérateurs logiques........................................................................................................... 20 5.4 Opérateurs d'assignation.................................................................................................... 20 5.5 Incrément et décrément...................................................................................................... 20 5.6 Exemples d'expressions..................................................................................................... 22 6 Instructions conditionnelles........................................................................................................ 22 6.1 Structure if et else.......................................................................................................... 22 6.2 Instruction switch............................................................................................................. 23 6.3 Instructions conditionnelles imbriquées.............................................................................. 23 6.4 Utilisation de l'opérateur ternaire........................................................................................ 24 7 Boucles..................................................................................................................................... 24 7.1 Boucle for........................................................................................................................... 24 7.2 Boucle while....................................................................................................................... 25 7.3 Boucle do-while.................................................................................................................. 25 8 Tableaux en Java...................................................................................................................... 26 8.1 Déclaration et initialisation des tableaux............................................................................. 26 8.2 Accès aux éléments d’un tableau....................................................................................... 26 8.3 Parcourir un tableau avec des boucles............................................................................... 26 3  8.4 Tableaux multidimensionnels.............................................................................................. 27 9 Entrées et Sorties en Java......................................................................................................... 28 9.1 Introduction à la classe Scanner......................................................................................... 28 9.2 Méthodes de la Classe Scanner......................................................................................... 28 10 Formatage de code Java........................................................................................................... 30 10.1 Alignement du code............................................................................................................ 30 10.2 Utilisation des accolades.................................................................................................... 30 10.3 Espaces et lignes vides...................................................................................................... 31 10.4 Longueur des lignes........................................................................................................... 32 10.5 Commentaires.................................................................................................................... 32 11 JavaDoc.................................................................................................................................... 32 11.1 Importance de JavaDoc...................................................................................................... 32 11.2 Comment utiliser JavaDoc.................................................................................................. 32 11.3 Balises JavaDoc courantes................................................................................................ 33 11.4 Génération de documentation............................................................................................. 34 11.5 Génération de documentation avec Eclipse........................................................................ 34 Chapitre 2: Programmation orientée objet (POO)............................................................ 36 1 Principe de la Programmation Orientée Objet (POO)................................................................ 36 1.1 Programmation Procédurale............................................................................................... 36 1.2 Programmation Orientée Objet (POO)................................................................................ 37 2 Concepts fondamentaux............................................................................................................ 38 2.1 Classes et objets................................................................................................................ 38 2.2 Constructeurs et initialisation des objets............................................................................. 39 2.3 Attributs et Méthodes.......................................................................................................... 42 3 Comprendre les Packages en Java........................................................................................... 52 3.1 Caractéristiques des Packages.......................................................................................... 52 3.2 Syntaxe pour Créer un Package......................................................................................... 53 3.3 Utilisation d'un Package..................................................................................................... 54 3.4 Types de Packages............................................................................................................ 55 4 Encapsulation............................................................................................................................ 55 4.1 Modificateurs d'accès (public, private, protected)............................................................... 55 4.2 Getter et setter................................................................................................................... 58 5 Héritage..................................................................................................................................... 61 5.1 Héritage simple.................................................................................................................. 61 5.2 Mot-clé super.................................................................................................................... 62 5.3 Cas pratique : Création et utilisation d'une sous-classe...................................................... 64 5.4 L’héritage multiple en Java................................................................................................. 65 5.5 Empêcher l’héritage d’une classe avec final................................................................... 66 6 Polymorphisme.......................................................................................................................... 67 4  6.1 Polymorphisme et Affectation............................................................................................. 67 6.2 Redéfinition des Méthodes (Overriding).............................................................................. 68 6.3 Surcharge des Méthodes.................................................................................................... 72 6.4 Polymorphisme comme Argument d'une Fonction.............................................................. 73 6.5 Polymorphisme dans les Tableaux..................................................................................... 74 7 Interfaces et classes abstraites.................................................................................................. 75 7.1 Classes Abstraites.............................................................................................................. 75 7.2 Interfaces........................................................................................................................... 77 7.3 Implémentation Multiple des Interfaces............................................................................... 78 7.4 Différences entre Classes Abstraites et Interfaces.............................................................. 80 7.5 L’Opérateur instanceof.................................................................................................. 80 8 Redéfinition des méthodes toString() & equals()........................................................................ 82 8.1 La méthode toString()......................................................................................................... 82 8.2 la méthode equals()............................................................................................................ 83 9 Méthodes et Classes Génériques (Généricité).......................................................................... 85 9.1 Introduction à la Généricité................................................................................................. 85 9.2 Méthodes Génériques........................................................................................................ 88 9.3 Restrictions sur les Types Paramétrés............................................................................... 89 9.4 Classe générique & l’héritage............................................................................................. 90 9.5 Limitations des Types Paramétrés en Java........................................................................ 91 9.6 La généricité et les var-args............................................................................................... 92 10 Classe Interne........................................................................................................................... 93 10.1 Introduction aux Classes Internes (inner classes)............................................................... 93 10.2 Visibilité des Classes Internes............................................................................................ 94 10.3 Classes internes Static et non-static................................................................................... 95 10.4 Classes Internes Locales.................................................................................................... 97 10.5 Compilation des Classes Internes Locales......................................................................... 97 11 Les classes anonymes.............................................................................................................. 98 11.1 Utilisation des Classes Anonymes...................................................................................... 98 11.2 Compilation des Classes Anonymes................................................................................... 99 12 Expressions Lambda............................................................................................................... 100 12.1 Interfaces fonctionnelles................................................................................................... 101 12.2 Syntaxe d'une Expression Lambda en Java..................................................................... 102 12.3 Utilisation avec une Interface Générique.......................................................................... 103 Chapitre 3: Les exceptions en Java................................................................................ 105 1 Introduction aux exceptions..................................................................................................... 105 1.1 Définition d'une exception................................................................................................. 105 1.2 Types d'exceptions (Exceptions vérifiées et non vérifiées)............................................... 105 1.3 L'importance de la gestion des exceptions....................................................................... 106 5  2 Gestion des exceptions........................................................................................................... 106 2.1 Le bloc try-catch.......................................................................................................... 106 2.2 Le bloc finally.............................................................................................................. 107 2.3 Le mot-clé throw............................................................................................................. 108 2.4 Le mot-clé throws........................................................................................................... 108 3 Hiérarchie des classes d'exceptions........................................................................................ 109 3.1 La classe Throwable...................................................................................................... 109 3.2 Les sous-classes Exception et Error.......................................................................... 110 3.3 Les exceptions courantes (NullPointerException, IOException, etc.).................. 111 4 Création d'exceptions personnalisées...................................................................................... 112 4.1 Pourquoi créer ses propres exceptions............................................................................. 112 4.2 Comment créer une exception personnalisée................................................................... 113 4.3 Gestion des exceptions personnalisées............................................................................ 114 5 Types d'exceptions : Checked et Unchecked........................................................................... 116 5.1 Checked Exceptions (Exceptions vérifiées)...................................................................... 116 5.2 Unchecked Exceptions (Exceptions non vérifiées)............................................................ 118 5.3 Différences principales entre Checked et Unchecked Exceptions :................................... 119 Chapitre 4: Collections..................................................................................................... 120 1 Introduction aux Collections..................................................................................................... 120 2 Interfaces de Collection........................................................................................................... 121 2.1 Collection......................................................................................................................... 121 2.2 List................................................................................................................................... 121 2.3 L'interface Iterator............................................................................................................. 123 2.4 Manipulation des données d’une List................................................................................ 125 3 Sets (Les ensembles).............................................................................................................. 127 3.1 HashSet........................................................................................................................... 127 3.2 TreeSet............................................................................................................................ 128 3.3 LinkedHashSet................................................................................................................. 128 4 Maps....................................................................................................................................... 130 4.1 HashMap.......................................................................................................................... 130 4.2 TreeMap........................................................................................................................... 131 4.3 LinkedHashMap................................................................................................................ 131 5 Structures de Données............................................................................................................ 132 5.1 Piles (Stacks)................................................................................................................... 132 5.2 Files (Queues).................................................................................................................. 133 5.3 Comparaison entre Piles et Files...................................................................................... 134 Chapitre 5: Threads en Java............................................................................................ 135 1 Introduction aux Threads en Java............................................................................................ 135 6  1.1 Objectifs des Threads....................................................................................................... 135 1.2 Bases des Threads en Java............................................................................................. 135 1.3 Rôle du Système d'Exploitation........................................................................................ 135 2 Création d’un Thread en Java.................................................................................................. 136 2.1 Étendre la classe java.lang.Thread................................................................................... 136 2.2 Implémenter l’interface java.lang.Runnable...................................................................... 137 3 Threads avec Classes Anonymes et Expressions Lambdas.................................................... 137 3.1 Utilisation avec la classe Thread..................................................................................... 138 3.2 Utilisation avec l'interface Runnable............................................................................... 138 3.3 Avec des Lambdas (Depuis Java 8)................................................................................. 139 4 Contrôle et Arrêt d’un Thread en Java..................................................................................... 140 4.1 Interruption d’un Thread................................................................................................... 140 4.2 Arrêt Contrôlé d’un Thread............................................................................................... 141 5 Synchronisation des Threads.................................................................................................. 142 5.1 Synchronisation de Méthodes........................................................................................... 142 5.2 Synchronisation des Méthodes Statiques......................................................................... 143 5.3 Synchronisation d’un Bloc de Code.................................................................................. 145 5.4 L'analogie avec un billet d'avion et le nombre de places disponibles................................ 146 Chapitre 6: Les Entrées/Sorties en Java........................................................................ 149 1 Introduction.............................................................................................................................. 149 2 Les flux d'octets....................................................................................................................... 150 2.1 L’écriture sur un fichier avec FileOutputStream................................................................ 150 2.2 La lecture sur un fichier avec FileInputStream.................................................................. 151 3 Les flux de caractères tamponnés avec un fichier................................................................... 153 3.1 Les classes tamponnées pour les flux.............................................................................. 154 4 Utilisation de FileWriter et FileReader...................................................................................... 156 4.1 FileWriter — Écriture de caractères dans un fichier.......................................................... 156 4.2 FileReader — Lecture de caractères à partir d'un fichier.................................................. 157 5 Lecture et d'écriture avec FileWriter et FileReader tamponnés...................................... 159 5.1 Utilisation de BufferedWriter avec FileWriter pour l'écriture tamponnée............................ 159 5.2 Utilisation de BufferedReader avec FileReader pour la lecture tamponnée...................... 160 6 Sérialisation d'objets en Java.................................................................................................. 161 6.1 Pourquoi sérialiser un objet ?........................................................................................... 161 6.2 Comment sérialiser un objet en Java ?............................................................................. 161 6.3 Désérialisation d'un objet.................................................................................................. 163 6.4 Gestion des versions avec serialVersionUID.................................................................... 163 6.5 Non-sérialisation d'un champ sensible.............................................................................. 164 6.6 Exemple complet de sérialisation et de désérialisation..................................................... 164 Chapitre 7: Les Enums en Java....................................................................................... 167 7  1 Introduction aux Enums........................................................................................................... 167 1.1 Définition et rôle des Enums............................................................................................. 167 1.2 Exemple simple de déclaration d'un Enum....................................................................... 167 1.3 Utilisation des Enums dans un programme....................................................................... 167 1.4 Accéder à toutes les valeurs d'un Enum........................................................................... 168 1.5 Comparaison avec des constantes définies avec final...................................................... 168 2 Déclaration et utilisation des Enums........................................................................................ 169 2.1 Structure de base d'un Enum........................................................................................... 169 2.2 Utilisation des Enums dans le code.................................................................................. 169 3 Méthodes et propriétés dans les Enums.................................................................................. 169 3.1 Ajout de méthodes dans les Enums.................................................................................. 169 3.2 Ajouter des champs à un Enum........................................................................................ 170 3.3 Utilisation avec des interfaces.......................................................................................... 170 4 Cas pratiques simples............................................................................................................. 171 5 Limitations des Enums............................................................................................................. 171 Chapitre 8: La Connexion JDBC en Java....................................................................... 172 1 Introduction à la Connexion JDBC en Java.............................................................................. 172 2 Configuration de l’Environnement Java pour JDBC................................................................. 172 3 Connexion à une Base de Données avec JDBC...................................................................... 172 4 Exécution de Requêtes SQL avec JDBC................................................................................. 173 5 Utilisation de PreparedStatement pour la Sécurité................................................................... 174 6 Gestion des Transactions JDBC.............................................................................................. 175 7 Fermeture des Ressources JDBC........................................................................................... 176 8 9 Chapitre 1: Introduction à Java et Syntaxe de base 1 Historique et évolution de Java 1.1 Naissance de Java Java a vu le jour en 1991 sous le nom de Oak, un projet secret de Sun Microsystems dirigé par James Gosling. L’objectif initial était de créer un langage de programmation pour des appareils électroniques tels que des décodeurs TV. Ce projet visait à offrir un langage portable, c’est-à-dire capable de fonctionner sur différents systèmes sans nécessiter de réécriture du code. Cette idée révolutionnaire est aujourd'hui connue sous le nom de WORA (Write Once, Run Anywhere). En 1995, Oak a été renommé Java et utilisé pour créer des applets pour le web, ce qui a popularisé le langage. Grâce à sa capacité d'exécution sur différents systèmes via la Java Virtual Machine (JVM), Java a rapidement gagné en popularité dans de nombreux secteurs, notamment les applications d'entreprise, les jeux vidéo, et les appareils mobiles. 1.2 Évolution de Java Depuis son lancement, Java a continuellement évolué. Les versions majeures ont introduit des fonctionnalités importantes qui ont changé la manière de programmer. En voici quelques exemples :  Java 1.2 (1998) : Introduction de l'API Swing pour les interfaces graphiques.  Java 5 (2004) : Introduction des génériques, annotations, énumérations, et de la boucle for- each.  Java 8 (2014) : Introduction des expressions lambda et des Streams, apportant un style de programmation fonctionnelle.  Java 11 (2018) : Version avec Support à Long Terme (LTS), utilisée largement dans l'industrie pour sa stabilité et ses nouvelles fonctionnalités telles que les inférences de type. 2 Environnement de développement 2.1 JVM (Java Virtual Machine) Une machine virtuelle Java (JVM) est un environnement virtuel qui fonctionne sur un ordinateur physique. Elle dispose de son propre langage natif et est capable de traduire un programme écrit en Java en langage machine. La JVM définit également les spécifications matérielles de la plateforme sur laquelle elle s'exécute. Elle lit le bytecode compilé, qui est indépendant de la 10 plateforme, permettant ainsi l'exécution des programmes Java sur différents systèmes. L'API (Application Programming Interface) Java est un ensemble de bibliothèques standards que les développeurs peuvent utiliser (importer) pour écrire leur code. Cette API est structurée en packages, qui regroupent des ensembles fonctionnels de composants, tels que des classes, des types de données, des objets, des chaînes de caractères, des tableaux, des vecteurs, des opérations d'entrée/sortie, et des manipulations de dates. 2.2 Code source et Bytecode Java Le code source Java est écrit dans un fichier texte avec l'extension «.java ». Il contient les instructions et la logique de programmation que le développeur rédige à l'aide de la syntaxe Java. Ce code est lisible par l'homme et peut contenir des classes, des méthodes, des variables et d'autres éléments qui définissent le comportement d'une application. Pour exécuter un programme Java, le code source doit d'abord être compilé. Cela se fait à l'aide du compilateur Java (javac), qui convertit le code source en bytecode.  Le bytecode est un format intermédiaire qui n'est pas spécifique à une plateforme. Il est stocké dans un fichier avec l'extension «..class».  Le bytecode est une représentation binaire qui est efficace pour l'exécution par la JVM. 2.3 Installation du JDK Le JDK (Java Development Kit) contient tous les outils nécessaires pour le développement (API), et pour compiler, exécuter, et déboguer des programmes Java. Étapes d'installation sur Windows :  Téléchargement du JDK : Allez sur https://www.oracle.com/java/technologies/javase- downloads.html et téléchargez la dernière version du JDK.  Installation : Suivez l'assistant d'installation pour installer le JDK sur votre machine.  Configuration des variables d'environnement :  Ouvrez le Panneau de configuration → Système → Paramètres système avancés → Variables d'environnement.  Sous « Variables système », trouvez la variable « Path » et ajoutez-y le chemin du répertoire « bin » du JDK, par exemple : « C:\Program Files\Java\jdk-17\bin ». 11 2.4 Configuration des IDE Les IDE (Integrated Development Environment) facilitent le travail des développeurs en offrant des outils d'édition de code, de débogage, de compilation et des suggestions de code. a) Eclipse : Un IDE open-source très utilisé, disponible à l'adresse https://www.eclipse.org/downloads. Il dispose de nombreuses extensions pour rendre le développement Java plus rapide et plus intuitif.  Étapes d'installation :  Téléchargez la version pour Java Developers.  Lancez l'installation et sélectionnez l’emplacement d’installation.  Ouvrez Eclipse, configurez le JDK installé en allant dans Preferences → Java → Installed JREs et ajoutez le chemin vers le JDK. b) IntelliJ IDEA : Cet IDE, très populaire pour son interface fluide et ses fonctionnalités avancées, est disponible à l'adresse https://www.jetbrains.com/idea.  Étapes d'installation :  Téléchargez IntelliJ IDEA depuis le site officiel.  Installez-le et ouvrez un projet Java en configurant le JDK. c) Les autres IDE :  NetBeans  Un IDE open-source, soutenu par Oracle.  Offre un bon support pour Java SE, Java EE, et la création d'applications web et desktop.  Fournit des fonctionnalités intégrées comme l'auto-complétion de code, le débogage, et l'intégration avec des outils comme Git et Maven.  BlueJ  Principalement conçu pour l'enseignement de la programmation en Java.  Très simple à utiliser pour les débutants, avec une interface intuitive.  Excellent pour les petits projets et l'exploration des concepts de base de Java.  JDeveloper  Un IDE gratuit proposé par Oracle, avec un bon support pour les technologies Java et la base de données Oracle.  Ciblé principalement sur le développement d'applications d'entreprise Java. 12 3 Structure d’un programme Java Un programme Java est construit autour de la méthode main, qui est le point d'entrée de l'exécution. Il est essentiel de respecter certaines règles concernant la déclaration de la classe contenant la méthode main, ainsi que le nom du fichier source. 3.1 La méthode main() La méthode main est définie comme suit : public class NomDeClasse { public static void main(String[] args) { // Instructions à exécuter } } Éléments de la méthode main :  Public : Cette visibilité permet à la méthode d'être accessible par la Java Virtual Machine (JVM), ce qui est essentiel pour que le programme puisse s'exécuter correctement.  Static : Cela signifie que la méthode peut être appelée sans avoir besoin de créer une instance de la classe, ce qui est crucial pour le démarrage initial de l'application.  String[] args : Il s'agit d'un tableau de chaînes qui reçoit les arguments passés lors de l'exécution du programme. Si aucun argument n'est fourni, args sera un tableau vide.  Main() : Cette méthode est exécutée lorsque l'application démarre, agissant comme le point d'entrée principal du programme.  Void : Cela indique que la méthode ne renvoie pas de résultat, ce qui signifie qu'il s'agit d'une procédure et non d'une fonction. Exemple de méthode main : public class HelloWorld { public static void main(String[] args) { System.out.println("Bonjour, tout le monde !"); if (args.length > 0) { System.out.println("Argument passé : " + args); } } } Dans cet exemple, lorsque le programme est exécuté avec un argument, L'exécution de la commande >java HelloWorld Test produit l'output suivant : 13 Règles importantes : a) La classe contenant la méthode main doit être déclarée comme public :  Cela signifie que cette classe est accessible depuis l'extérieur, notamment par la Java Virtual Machine (JVM) pour démarrer l'exécution.  Si la classe n’est pas déclarée comme public, la JVM ne pourra pas y accéder pour exécuter la méthode main. b) Le fichier source doit avoir le même nom que la classe public :  Si une classe est déclarée public, le fichier qui la contient doit avoir exactement le même nom que cette classe, avec l'extension.java.  Par exemple, si la classe est nommée HelloWorld, le fichier doit être nommé HelloWorld.java.  Si le nom du fichier ne correspond pas au nom de la classe public, le compilateur Java génèrera une erreur. Exemple : Classe déclarée dans le fichier HelloWorld.java : public class HelloWorld { public static void main(String[] args) { System.out.println("Bonjour !"); } } Si le fichier est nommé Test.java au lieu de HelloWorld.java, une erreur de compilation se produira. Pourquoi cette règle est-elle importante ?  En Java, chaque fichier source.java ne peut contenir qu'une seule classe publique. Cela facilite l'organisation et la recherche des classes dans un projet.  Le nom du fichier devant correspondre à celui de la classe publique permet à la JVM et aux outils de développement (IDE, compilateurs) de localiser et d'exécuter correctement la classe contenant la méthode main. 14 3.2 Instructions et blocs de code Un programme Java se compose de différentes instructions qui s'exécutent séquentiellement. Les instructions sont généralement regroupées en blocs de code, délimités par des accolades {}. Exemple d'instructions et de blocs : public class Exemple { public static void main(String[] args) { // Bloc de code int a = 10; int b = 20; int somme = a + b; // Instruction d'addition System.out.println("La somme est : " + somme); } } Types d'instructions :  Déclaration : Pour déclarer des variables, par exemple int a = 10;.  Assignation : Pour attribuer des valeurs, par exemple a = 20;.  Appel de méthode : Pour exécuter des méthodes, comme System.out.println(...). Utilisation des commentaires : Les commentaires sont essentiels pour documenter le code. Ils peuvent être de deux types :  Commentaire sur une seule ligne : Commence par //.  Commentaire multi-lignes : Encadré par. Exemple de commentaires : public class Commentaires { public static void main(String[] args) { // Ceci est un commentaire sur une seule ligne System.out.println("Les commentaires aident à comprendre le code !"); } } 3.3 Exercices  Exercice 1 : Création d'un programme simple Créez une classe MonPremierProgramme avec une méthode main() qui affiche "Bienvenue dans le monde de Java!". public class MonPremierProgramme { 15  public static void main(String[] args) { // Affichage du message System.out.println("Bienvenue dans le monde de Java!"); } }  Exercice 2 : Utilisation de variables et de la méthode main() Dans une classe InformationsPersonnelles, déclarez trois variables (String nom, int age, double taille) et affichez leurs valeurs. public class InformationsPersonnelles { public static void main(String[] args) { // Déclaration et initialisation des variables String nom = "Ali"; int age = 30; double taille = 1.80; // Affichage des valeurs System.out.println("Nom : " + nom); System.out.println("Âge : " + age + " ans"); System.out.println("Taille : " + taille + " mètres"); } } 4 Types de données primitifs en Java En Java, il existe 8 types de données primitifs, chacun ayant une taille en mémoire fixe et une plage de valeurs prédéfinie. Les types primitifs permettent de stocker des valeurs simples telles que des entiers, des nombres décimaux, des caractères, ou des valeurs booléennes. Ces types sont plus efficaces en termes de mémoire et de traitement par rapport aux objets. 4.1 Types de données primitifs Type Taille en Plage de valeurs Valeur par Exemple bits défaut byte 8 bits -128 à 127 0 byte age = 25; short 16 bits -32 768  32 767 0 short distance = 15000; int 32 bits -2 147 483 648  2 147 483 0 int population = 1000000; 647 long 64 bits -9 223 372 036 854 775 808 0L long bigNumber = 123456789L; 16   9 223 372 036 854 775 807 float 32 bits ±1.4E-45  ±3.4028235E38 0.0f float pi = 3.14f; double 64 bits ±4.9E-324  0.0d double price = 99.99; ±1.7976931348623157E308 char 16 bits 0 à 65 535 (caractères '\u0000' char lettre = 'A'; Unicode) boolean 1 bit true ou false false boolean isOpen = true; Détails sur chaque type :  Types numériques entiers :  byte : Utilisé pour de très petits nombres, permet d'économiser de la mémoire.  short : Utilisé pour des valeurs modérées, comme des indices.  int : Le type d’entier le plus couramment utilisé en Java.  long : Utilisé pour de très grands nombres. On ajoute un L à la fin du nombre pour indiquer un long.  Types numériques à virgule flottante :  float : Utilisé pour des nombres à virgule flottante de précision simple. On ajoute un f à la fin du nombre.  double : Utilisé pour des nombres à virgule flottante de double précision, plus précis que float.  Type caractère :  char : Utilisé pour stocker un seul caractère Unicode (lettres, chiffres, symboles).  Type booléen :  boolean : Utilisé pour stocker une valeur logique : true (vrai) ou false (faux). Exemples d’utilisation : byte age = 25; // Petite valeur entière short distance = 15000; // Valeur modérée int population = 1000000; // Valeur entière standard long bigNumber = 123456789L; // Très grande valeur float pi = 3.14f; // Valeur à virgule flottante de précision simple double price = 99.99; // Valeur à virgule flottante de précision double char lettre = 'A'; // Caractère unique 17 boolean isOpen = true; // Valeur booléenne (vrai ou faux) 4.2 Règle pour le Type de Résultat d'Opérations avec des Types Primitifs a) Promotion des Types : Lorsqu'une opération implique des types primitifs différents, Java effectue une promotion automatique vers le type le plus large. b) Types de Données Primitifs : Les types primitifs en ordre de taille (de plus petit à plus grand) sont :  byte < short < int < long < float < double. c) Règles de Promotion :  Si un int est combiné avec un double, le résultat est un double.  Si un int est combiné avec un float, le résultat est un float.  Si un byte ou un short est combiné avec un int, le résultat est un int.  Les opérations entre float et double donnent un résultat de type double. Exemples  Exemple 1 : int a = 5; double b = 2.0;  z = a + b; → z est de type double.  Exemple 2 : int x = 10; float y = 5.0f;  result = x * y; → result est de type float.  Exemple 3 : byte p = 3; short q = 5;  total = p + q; → total est de type int. 4.3 Types de Variables Non-Primitives (Instances) en Java Les variables non-primitives, également appelées références d'objets, sont des types qui permettent de créer des instances d'objets. Contrairement aux types primitifs, qui stockent directement des valeurs, les variables non-primitives stockent des références à des objets. Lorsqu’on déclare une variable objet en Java, on réserve en réalité de l’espace mémoire pour la référence à cet objet, et non pour l’objet lui-même. La déclaration de la variable crée une référence qui peut pointer vers un objet, mais tant que l'objet n'est pas instancié (créé avec le mot-clé new), la référence ne pointe vers aucune donnée valide. 18 Le programmeur Java n'a pas à se soucier de la libération de la mémoire en supprimant les objets devenus inutiles, car cette tâche est automatiquement gérée par le ramasse ramasse-miettes, miettes, également connu sous le nom de Garbage Collector (GC). Ce dernier identifie et récupère la mémoire occupée par les objets qui ne sont plus référencés, permettant ainsi une gestion efficace des ressources. 5 Opérateurs et expressions Les opérateurs en Java sont utilisés pour effectuer des opérations sur de dess variables et des valeurs. Les expressions sont des combinaisons de valeurs, de variables et d'opérateurs qui produisent un résultat. 5.1 Opérateurs arithmétiques  Addition (+) : Ajoute deux valeurs.  Soustraction (-) : Soustrait la deuxième valeur de la prem première.  Multiplication (*) : Multiplie deux valeurs.  Division (/) : Divise la première valeur par la seconde.  Modulo (%) : Renvoie le reste d'une division. 19 5.2 Opérateurs relationnels  Égalité (==) : Vérifie si deux valeurs sont égales.  Inégalité (!=) : Vérifie si deux valeurs ne sont pas égales.  Supérieur à (>) : Vérifie si la première valeur est supérieure à la seconde.  Inférieur à (=) : Vérifie si la première valeur est supérieure ou égale à la seconde.  Inférieur ou égal à ( 0 && b > 0); // Vérifie si a et b sont positifs 6 Instructions conditionnelles Les instructions conditionnelles permettent à un programme de prendre des décisions en fonction de certaines conditions. Elles exécutent des blocs de code différents selon que la condition est vraie ou fausse. 6.1 Structure if et else La structure if est utilisée pour exécuter un bloc de code si une condition est vraie. L'instruction else permet d'exécuter un bloc de code alternatif si la condition est fausse. Syntaxe : if (condition) { // Bloc de code exécuté si la condition est vraie } else { // Bloc de code exécuté si la condition est fausse } Exemple : int age = 18; if (age >= 18) { System.out.println("Vous êtes majeur."); } else { System.out.println("Vous êtes mineur."); } 22 6.2 Instruction switch L'instruction switch est utilisée pour sélectionner l'une des nombreuses options possibles en fonction de la valeur d'une expression. Syntaxe : switch (expression) { case valeur1: // Bloc de code exécuté si l'expression est égale à valeur1 break; case valeur2: // Bloc de code exécuté si l'expression est égale à valeur2 break; // D'autres cas peuvent être ajoutés ici default: // Bloc de code exécuté si aucune valeur ne correspond } Exemple : char grade = 'B'; switch (grade) { case 'A': System.out.println("Excellent !"); break; case 'B': System.out.println("Bien !"); break; case 'C': System.out.println("Satisfaisant !"); break; default: System.out.println("Note non valide."); } 6.3 Instructions conditionnelles imbriquées Il est possible d'imbriquer des instructions if pour vérifier plusieurs conditions. Exemple : int note = 85; if (note >= 90) { System.out.println("Mention Très Bien"); } else if (note >= 80) { System.out.println("Mention Bien"); 23 } else if (note >= 70) { System.out.println("Mention Assez Bien"); } else { System.out.println("Mention Insuffisante"); } 6.4 Utilisation de l'opérateur ternaire L'opérateur ternaire ? : est une manière concise d'écrire une condition simple. Syntaxe : resultat = (condition) ? valeurSiVrai : valeurSiFaux; Exemple : int nombre = 10; String parite = (nombre % 2 == 0) ? "Pair" : "Impair"; System.out.println("Le nombre est " + parite); 7 Boucles Les boucles permettent d'exécuter un bloc de code plusieurs fois, selon une condition spécifiée. Elles sont utiles pour automatiser les tâches répétitives. 7.1 Boucle for La boucle for est généralement utilisée lorsque le nombre d'itérations est connu à l'avance. Elle permet de parcourir des séquences (comme des tableaux). Syntaxe : for (initialisation; condition; incrément) { // Bloc de code à exécuter } Exemple : for (int i = 0; i < 5; i++) { System.out.println("Itération : " + i); } Explication :  Initialisation : int i = 0 initialise la variable i.  Condition : i < 5 vérifie si i est inférieur à 5.  Incrément : i++ augmente i de 1 à chaque itération. 24 7.2 Boucle while La boucle while continue à exécuter un bloc de code tant qu'une condition est vraie. Elle est utilisée lorsque le nombre d'itérations n'est pas prédéfini. Syntaxe : while (condition) { // Bloc de code à exécuter } Exemple : int j = 0; while (j < 5) { System.out.println("Itération : " + j); j++; // N'oubliez pas d'incrémenter j pour éviter une boucle infinie } Explication :  La boucle s'exécute tant que j est inférieur à 5. Il est crucial d'incrémenter j pour sortir de la boucle. 7.3 Boucle do-while La boucle do-while est similaire à la boucle while, mais elle garantit que le bloc de code s'exécute au moins une fois, même si la condition est fausse. Syntaxe : do { // Bloc de code à exécuter } while (condition); Exemple : int k = 0; do { System.out.println("Itération : " + k); k++; // Incrémentation de k } while (k < 5); Explication :  Le bloc de code s'exécute d'abord, puis vérifie si k est inférieur à 5. Si c'est le cas, la boucle continue. 25 8 Tableaux en Java 8.1 Déclaration et initialisation des tableaux Les tableaux en Java sont des structures de données permettant de stocker plusieurs valeurs de même type dans une seule variable. La déclaration et l'initialisation d'un tableau se fait en deux étapes :  Déclaration : spécifier le type des éléments et utiliser des crochets [] pour indiquer qu'il s'agit d'un tableau. Les crochets [] peuvent être placés avant ou après le nom du tableau. int[] monTableau; // Les crochets avant le nom du tableau int monTableau[]; // Les crochets après le nom du tableau  Initialisation : allouer de la mémoire pour le tableau avec le mot-clé new et spécifier sa taille. monTableau = new int; // initialisation d'un tableau avec 5 entiers  Déclaration et initialisation combinées : int[] monTableau = new int;  Initialisation avec des valeurs prédéfinies : int[] monTableau = {10, 20, 30, 40, 50}; 8.2 Accès aux éléments d’un tableau Chaque élément d'un tableau est accessible à l'aide d'un index, qui commence à 0.  Accéder à un élément spécifique : int premierElement = monTableau; // accède au premier élément  Modifier un élément spécifique : monTableau = 100; // modifie le troisième élément du tableau  Les tableaux ont une propriété length qui indique la taille du tableau : int taille = monTableau.length; // renvoie la taille du tableau (ici 5) 8.3 Parcourir un tableau avec des boucles Il est courant de parcourir les éléments d’un tableau à l’aide de boucles. Voici les différentes méthodes pour le faire :  Avec une boucle for classique : 26  for (int i = 0; i < monTableau.length; i++) { System.out.println(monTableau[i]); }  Avec une boucle for-each (boucle améliorée) : for (int element : monTableau) { System.out.println(element); } 8.4 Tableaux multidimensionnels Java prend également en charge les tableaux multidimensionnels (comme les matrices). Voici comment déclarer et utiliser des tableaux à deux dimensions (tableaux 2D).  Déclaration d’un tableau 2D : int[][] matrice = new int; // tableau 2D avec 3 lignes et 3 colonnes  Initialisation d'un tableau 2D : int[][] matrice = { {1, 2, 3}, {4, 5, 6}, {7, 8, 9} };  Accès aux éléments d’un tableau 2D : int valeur = matrice; // accède à l'élément de la 2e ligne et 3e colonne  Parcourir un tableau 2D avec des boucles imbriquées : for (int i = 0; i < matrice.length; i++) { for (int j = 0; j < matrice[i].length; j++) { System.out.println(matrice[i][j]); } }  Parcourir un tableau 2D Avec une boucle for-each: for (int[] ligne : matrice) { // Parcourir chaque sous-tableau (ligne) for (int element : ligne) { // Parcourir chaque élément dans la ligne System.out.println(element); } } 27 9 Entrées et Sorties en Java 9.1 Introduction à la classe Scanner La classe Scanner fait partie du package java.util et est utilisée pour obtenir l'entrée de l'utilisateur via la console. Elle permet de lire différents types de données, comme des chaînes de caractères, des entiers et des nombres à virgule flottante. Importation de la classe Scanner : import java.util.Scanner; 9.2 Méthodes de la Classe Scanner Voici un aperçu des principales méthodes disponibles dans la classe Scanner :  next() : Cette méthode lit le prochain mot (jusqu'à l'espace) de l'entrée. Scanner scanner = new Scanner(System.in); System.out.print("Entrez un mot : "); String mot = scanner.next(); System.out.println("Vous avez saisi : " + mot);  nextLine() : Cette méthode lit toute la ligne jusqu'à ce que l'utilisateur appuie sur Entrée. System.out.print("Entrez une phrase : "); String ligne = scanner.nextLine(); System.out.println("Vous avez saisi : " + ligne);  nextInt() : Cette méthode lit un entier. System.out.print("Entrez un nombre entier : "); int nombre = scanner.nextInt(); System.out.println("Vous avez saisi : " + nombre);  nextDouble() : Cette méthode lit un nombre à virgule flottante (double). System.out.print("Entrez un nombre décimal : "); double decimal = scanner.nextDouble(); System.out.println("Vous avez saisi : " + decimal);  nextFloat() : Cette méthode lit un float (nombre à virgule flottante). System.out.print("Entrez un nombre à virgule flottante : "); float floatNombre = scanner.nextFloat(); System.out.println("Vous avez saisi : " + floatNombre);  nextLong() : Cette méthode lit un long (entier long). System.out.print("Entrez un nombre long : "); long longNombre = scanner.nextLong(); 28  System.out.println("Vous avez saisi : " + longNombre);  nextShort() : Cette méthode lit un short (entier court). System.out.print("Entrez un nombre court : "); short shortNombre = scanner.nextShort(); System.out.println("Vous avez saisi : " + shortNombre);  nextBoolean() : Cette méthode lit une valeur booléenne (true ou false). System.out.print("Entrez true ou false : "); boolean valeur = scanner.nextBoolean(); System.out.println("Vous avez saisi : " + valeur);  Vérification de l'entrée  hasNext() : Vérifie s'il y a un autre élément dans l'entrée. System.out.print("Entrez un mot : "); if (scanner.hasNext()) { String prochain = scanner.next(); System.out.println("Vous avez saisi : " + prochain); }  hasNextInt(), hasNextDouble(), etc : Ces méthodes vérifient si l'entrée suivante est du type spécifié. System.out.print("Entrez un nombre entier : "); if (scanner.hasNextInt()) { int entier = scanner.nextInt(); System.out.println("Vous avez saisi : " + entier); } else { System.out.println("Ce n'est pas un entier valide."); }  close() : Ferme le scanner et libère les ressources. Il est important de fermer le scanner pour éviter les fuites de mémoire. scanner.close();  Gestion des exceptions Utiliser un bloc try-catch pour gérer les exceptions, par exemple, lors de la saisie d'un type incorrect. Voici un exemple qui utilise une boucle do-while avec un bloc try-catch pour demander à l'utilisateur d'entrer un nombre entier. Si l'utilisateur saisit un type incorrect, le programme continue de lui demander une entrée valide jusqu'à ce qu'il réussisse. Scanner scanner = new Scanner(System.in); int nombre = 0; boolean valide; 29 do { System.out.print("Veuillez entrer un nombre entier : "); valide = true; // On suppose que l'entrée est valide try { nombre = scanner.nextInt(); // Tentative de lecture d'un entier } catch (Exception e) { System.out.println("Erreur : Ce n'est pas un nombre entier valide."); valide = false; // On marque l'entrée comme invalide scanner.next(); // On consomme l'entrée incorrecte } } while (!valide); // Répète tant que l'entrée n'est pas valide System.out.println("Vous avez saisi : " + nombre); scanner.close(); // Fermeture du scanner 10 Formatage de code Java Le formatage de code est essentiel pour la lisibilité et la maintenance d’un programme. Un code bien formaté facilite la compréhension et réduit le risque d'erreurs. 10.1 Alignement du code L'alignement consiste à organiser le code de manière à ce qu'il soit clair et cohérent. Cela inclut l'indentation des blocs de code, ce qui aide à visualiser la structure du programme. Un bon formatage de code en Java améliore non seulement la lisibilité mais aussi la collaboration entre développeurs. Je vous encourage à suivre ces bonnes pratiques dès le début de votre apprentissage. Des outils de formatage de code (par exemple, Eclipse, IntelliJ IDEA) peuvent également être utilisés pour appliquer automatiquement ces règles de formatage. Exemple d'alignement correct : if (condition) { // Bloc de code statement1(); statement2(); } else { // Bloc alternatif statement3(); } 10.2 Utilisation des accolades Les accolades {} délimitent les blocs de code. Elles doivent toujours être utilisées, même pour un seul bloc d’instructions, afin de prévenir les erreurs lors de l'ajout de nouvelles lignes. Exemple : 30 // Correct if (condition) { statement(); } // Incorrect (peut entraîner des erreurs à l'avenir) if (condition) statement(); 10.3 Espaces et lignes vides Espaces : Utilisez des espaces pour améliorer la lisibilité. Par exemple, après une virgule dans les listes et avant et après les opérateurs. Exemple : int sum = a + b; // Correct int sum=a+b; // Incorrect Lignes vides : Ajoutez des lignes vides pour séparer logiquement les différentes sections du code, comme entre les méthodes, les déclarations de variables, ou avant les instructions conditionnelles et les boucles. Il n'y a pas de règle stricte pour les lignes vides si le code est clair et logique. Sauf que cela va permettre de mieux organiser le code. Exemple 1: public class Exemple { public void methode1() { // Code de la méthode } public void methode2() { // Code de la méthode } public void verifier() { if (condition) { // Bloc conditionnel } } } Exemple 2: public static void main(String args[]) { for (int i = 0; i < 5; i++) { 31  System.out.println("Itération : " + i); } // Ligne vide avant la boucle while int j = 0; while (j < 5) { System.out.println("Itération : " + j); j++; } } 10.4 Longueur des lignes Il est recommandé de ne pas dépasser 80 à 120 caractères par ligne. Cela facilite la lecture du code sans avoir à faire défiler horizontalement. 10.5 Commentaires Les commentaires doivent être utilisés pour expliquer des sections complexes du code ou pour donner des informations sur l'intention derrière certaines décisions de codage. Exemple : // Calcul de la moyenne des notes double moyenne = (note1 + note2 + note3) / 3; 11 JavaDoc 11.1 Importance de JavaDoc JavaDoc est un outil intégré au langage Java qui permet de générer automatiquement de la documentation à partir des commentaires dans le code source. En utilisant des commentaires clairs et des balises appropriées, vous pouvez faciliter la compréhension et l'utilisation de votre code par d'autres développeurs.  Clarté : La documentation aide à clarifier l'intention du code.  Maintenance : Facilite la mise à jour et la maintenance du code à long terme.  Partage : Rend le code plus accessible pour d'autres développeurs. 11.2 Comment utiliser JavaDoc Les commentaires JavaDoc sont placés juste au-dessus des classes, méthodes ou champs à documenter. Ils commencent par. À l'intérieur, vous pouvez utiliser des balises spéciales pour structurer l'information. 32 Exemple de commentaire JavaDoc : public class Etudiant { private String nom; private int age; public Etudiant(String nom, int age) { this.nom = nom; this.age = age; } public String getNom() { return nom; } public int getAge() { return age; } } 11.3 Balises JavaDoc courantes Voici quelques balises couramment utilisées dans JavaDoc :  @param : Décrit un paramètre d'une méthode.  @return : Décrit ce que la méthode renvoie.  @throws ou @exception : Indique les exceptions que la méthode peut lancer.  @see : Fait référence à une autre classe ou méthode.  @deprecated : Indique que la méthode est obsolète. 33 11.4 Génération de documentation Pour générer la documentation à partir des commentaires JavaDoc, vous pouvez utiliser la commande suivante dans le terminal : >javadoc -d chemin/vers/dossier source*.java Cela créera un site HTML avec la documentation générée dans le dossier spécifié. 11.5 Génération de documentation avec Eclipse La génération de documentation avec Eclipse simplifie le processus grâce à son interface graphique. a) Eclipse facilite la génération de documentation JavaDoc grâce à des options intégrées. Voici comment procéder : b) Écrire des commentaires JavaDoc : Assurez-vous d'avoir ajouté des commentaires JavaDoc à vos classes et méthodes comme décrit précédemment. c) Sélectionner le projet : Dans l'Explorateur de projpet, sélectionnez le projet pour lequel vous souhaitez générer la documentation. d) Accéder au menu JavaDoc :  Cliquez avec le bouton droit de la souris sur le projet.  Allez dans le menu "Exporter".  Sélectionnez "Java" > "Générer JavaDoc...". e) Configurer les options JavaDoc :  Dans la fenêtre qui s'ouvre, vous pouvez sélectionner les classes, les packages et les types à inclure.  Vous pouvez également spécifier le dossier de sortie où la documentation sera générée.  Cochez les options supplémentaires selon vos besoins, comme l'inclusion de la documentation des membres privés ou protégés. f) Générer la documentation :  Cliquez sur "Terminer" pour commencer la génération.  Eclipse créera la documentation dans le dossier que vous avez spécifié, sous forme de fichiers HTML. 34 g) Visualiser la documentation : Ouvrez le fichier index.html dans le dossier de sortie pour visualiser la documentation générée dans un navigateur. 35 Chapitre 2: Programmation orientée objet (POO) 1 Principe de la Programmation Orientée Objet (POO) La Programmation Orientée Objet (POO) est un paradigme de programmation basé sur la notion d'objets. Contrairement à la programmation procédurale, qui se concentre sur la séquence d'instructions à exécuter, la POO organise le programme autour d'entités appelées objets. Chaque objet regroupe des attributs (données) et des méthodes (comportements) en une seule unité cohérente. Le principe fondamental de la POO est de favoriser la modularité, la réutilisabilité et la maintenance du code en structurant un programme sous forme d'interactions entre différents objets. Voici les quatre principaux piliers de la POO :  Encapsulation : Protéger les données des objets en limitant leur accès et leur modification via des méthodes spéciales (getter/setter).  Héritage : Permettre à une classe d'hériter des propriétés et méthodes d'une autre classe, facilitant ainsi la réutilisation du code.  Polymorphisme : Offrir la capacité de traiter des objets de différentes classes de manière uniforme via la surcharge ou la redéfinition des méthodes.  Abstraction : Dissimuler les détails d'implémentation tout en exposant uniquement les fonctionnalités essentielles via des interfaces ou des classes abstraites. 1.1 Programmation Procédurale La programmation procédurale est un paradigme de programmation qui repose sur l'idée que le programme est une série d'instructions ou de procédures à exécuter séquentiellement. Chaque procédure, aussi appelée fonction, est un bloc de code autonome conçu pour accomplir une tâche spécifique. Les données sont passées comme arguments aux fonctions, et ces dernières agissent sur ces données. Caractéristiques principales de la programmation procédurale :  Séquentielle : Le programme suit un flux linéaire d'exécution, de haut en bas.  Utilisation de fonctions : Le code est organisé en fonctions ou procédures, ce qui permet de le réutiliser.  Faible modularité : Les données et fonctions sont séparées, rendant difficile leur encapsulation dans une unité commune.  Manque d'abstraction : Il n'y a pas de distinction claire entre les différentes entités manipulées dans le programme, ce qui peut rendre difficile la gestion de programmes complexes. 36 Exemple : En C, un programme typique suit la programmation procédurale où les fonctions main(), fct1(),fct2(), fct_n(), etc., sont exécutées séquentiellement. 1.2 Programmation Orientée Objet (POO) La programmation orientée objet (POO) repose sur la création d'objets qui modélisent des entités du monde réel ou abstraites. Chaque objet est une instance d'une classe, qui définit les attrib attributs (caractéristiques) et les méthodes (comportements) que l'objet peut avoir. La POO permet une organisation plus intuitive et flexible du code, en regroupant à la fois les données et les comportements qui leur sont associés dans un même concept. Les objets ts interagissent entre eux via des messages (appels de méthodes), permettant ainsi de simuler des interactions complexes. Ce paradigme met l'accent sur la réutilisation du code et l'extension des fonctionnalités sans modifier les classes de base. Principes clés de la POO :  Modularité : Chaque objet est autonome et peut être développé et testé de manière indépendante.  Réutilisabilité : Grâce à l'héritage, il est possible de réutiliser du code sans duplication.  Encapsulation : Les attributs sont cachés à l'e l'extérieur xtérieur de l'objet et ne peuvent être modifiés que via des méthodes spécifiques.  Polymorphisme : Les objets peuvent être manipulés via des interfaces communes, même s'ils appartiennent à des classes différentes. Exemple : En Java, la classe Voiture peut avoir des attributs comme couleur et vitesse, ainsi que des méthodes comme accélérer() ou freiner(). Un programme orienté objet consisterait à instancier des objets de type Voiture et à interagir avec ces objets via leurs méthodes. 37 2 Concepts fondamentaux 2.1 Classes et objets Une classe est une description abstraite d'un objet. Elle sert de modèle pour créer des objets (instances) et définit les caractéristiques et comportements de ces objets.  Instanciation : Instancier une classe signifie cré créer er un objet basé sur ce modèle. Chaque objet créé possède ses propres valeurs pour les attributs définis dans la classe.  Méthodes : Une classe définit des fonctions, appelées méthodes,, qui opèrent sur ses attributs. Ces méthodes permettent d'interagir avec les données de l'objet et de modifier son état.  Objet:: On peut considérer un objet comme une variable de type classe. classe Les objets sont construits à partir de la classe classe, par un processus appelé instanciation. instanciation De ce fait, tout objet est une instance (une variable iable) de classe.  Composition d'une classe :  Attributs : Ce sont les propriétés ou caractéristiques de la classe. Dans l'exemple ci ci-dessus, attribut1 et attribut2 sont des attributs. Ils décrivent les informations que chaque objet de cette classe peut stocker.  Méthodes : Ce sont les fonctions qui définissent les comportements des objets. La méthode faireQuelqueChose() () dans l'exemple est une action que l'objet peut exécuter.  Constructeur : C'est une méthode spéciale qui est appelée lors de la création d'un objet. Il sert à initialiser les attributs de l'objet.  Getters et Setters : Ce sont des méthodes qui permettent de lire (getter) et de modifier (setter) les valeurs des attributs. 38 Exemple : public class Personne { // Attributs private String nom; private String prenom; private int age; } public class Main { public static void main(String[] args) { Personne p = new Personne(); // Création d'un objet de type Personne } }  Règle : Il est préférable qu’on commence le nom de la classe par une Majiscule. public class CompteBancaire{ public class AgenceVoyage{ } } 2.2 Constructeurs et initialisation des objets Les constructeurs en Java sont des méthodes spéciales qui permettent d'initialiser des objets lors de leur création. Ils jouent un rôle essentiel dans la programmation orientée objet, garantissant que les objets sont correctement configurés avant d'être utilisés.  Types de constructeurs  Constructeur par défaut : Le constructeur par défaut est celui qui n’a pas de paramètres. Si aucun constructeur n’est défini dans une classe, Java crée automatiquement un constructeur par défaut qui initialise les attributs à leurs valeurs par défaut (par exemple, 0 pour les types numériques, null pour les objets). Exemple : public class Personne { private String nom; private String prenom; private int age; // Constructeur par défaut public Personne() { nom = "Inconnu"; prenom = "Inconnu"; age = 0; } } 39   Constructeur paramétré : Le constructeur paramétré prend des arguments pour initialiser les attributs de l'objet, permettant ainsi de créer des objets avec des valeurs spécifiques. Exemple : public class Personne { private String nom; private String prenom; private int age; // Constructeur paramétré public Personne(String nom, String prenom, int age) { this.nom = nom; // 'this' fait référence à l'attribut this.prenom = prenom; // 'this' fait référence à l'attribut this.age = age; // 'this' fait référence à l'attribut } }  Surcharge de constructeur La surcharge de constructeur permet de définir plusieurs constructeurs avec des paramètres différents. Cela offre une flexibilité pour initialiser des objets de manière adaptée à différents contextes. Exemple de surcharge : public class Personne { private String nom; private String prenom; private int age; // Constructeur par défaut public Personne() { nom = "Inconnu"; prenom = "Inconnu"; age = 0; } // Constructeur avec nom et prénom public Personne(String nom, String prenom) { this.nom = nom; this.prenom = prenom; age = 0; // Valeur par défaut pour l'âge } // Constructeur avec tous les paramètres public Personne(String nom, String prenom, int age) { this.nom = nom; this.prenom = prenom; this.age = age; } } 40  Initialisation des objets Lorsqu'un objet est créé en utilisant un constructeur, Java alloue de la mémoire pour cet objet et appelle le constructeur approprié pour initialiser ses attributs. Exemple d'utilisation : public class Main { public static void main(String[] args) { // Utilisation du constructeur par défaut Personne personne1 = new Personne(); System.out.println("Personne 1: " + personne1.getNom() + " " + personne1.getPrenom() + ", Âge: " + personne1.getAge()); // Utilisation du constructeur paramétré Personne personne2 = new Personne("Dupont", "Alice"); System.out.println("Personne 2: " + personne2.getNom() + " " + personne2.getPrenom() + ", Âge: " + personne2.getAge()); // Utilisation du constructeur avec tous les paramètres Personne personne3 = new Personne("Martin", "Bob", 30); System.out.println("Personne 3: " + personne3.getNom() + " " + personne3.getPrenom() + ", Âge: " + personne3.getAge()); } }  Le mot-clé : this Le mot-clé this est une référence à l'objet courant, c'est-à-dire l'instance de la classe dans laquelle il est utilisé. Il est particulièrement utile dans plusieurs situations :  Différencier les attributs des paramètres : Lorsque les noms des paramètres d'un constructeur ou d'une méthode sont identiques à ceux des attributs, this permet de distinguer les deux. Exemple : public class Personne { private String nom; public Personne(String nom) { this.nom = nom; // 'this.nom' fait référence à l'attribut } }  Appeler d'autres constructeurs : this peut également être utilisé pour appeler un autre constructeur de la même classe, facilitant ainsi la surcharge de constructeurs. 41 Exemple : public class Personne { private String nom; private int age; public Personne() { this("Inconnu", 0); // Appelle le constructeur avec paramètres } public Personne(String nom, int age) { this.nom = nom; this.age = age; } } 2.3 Attributs et Méthodes a) Attributs : Les attributs d'une classe sont des variables qui définissent les caractéristiques d'un objet. Chaque objet a ses propres valeurs pour ces attributs. Dans la classe Personne, les attributs peuvent être définis comme suit : Exemple : public class Personne { // Attributs private String nom; private String prenom; private int age; } Règles:  Les noms de variables sont sensibles à la casse.  Les espaces ne sont pas autorisés.  Il est préférable que le nom de la variable commence par une lettre minuscule.  N'utilise pas de mots réservés de Java (par exemple, class, int, static, etc.) Exemple : int quantiteStock = 10;  Les mots réservés de java 42 b) Constantes en Java Une constante en Java est une variable dont la valeur ne peut pas être modifiée après son initialisation. On déclare une constante à l'aide du mot-clé final. Déclaration et initialisation d'une constante  Déclaration et initialisation en une seule ligne : final int MAX_PLACE = 100;  Déclaration puis initialisation ultérieure : final int NBR_PLACE; // Initialisation plus tard dans le code NBR_PLACE = 10; Dans ce cas, seule la première affectation est autorisée. Toute tentative de réaffectation entraînera une erreur : NBR_PLACE = 20; // Erreur : la constante NBR_PLACE a déjà été initialisée Règles de nommage des constantes :  Le nom d'une constante doit être en MAJUSCULES.  Si le nom est composé de plusieurs mots, il est recommandé d'utiliser le caractère de soulignement ( _ ) pour séparer les mots. Exemple : final int CAPACITE_DANS_STOCK = 50; 43 c) Méthodes : Les méthodes définissent les actions ou comportements d'un objet. Elles peuvent manipuler les attributs d'un objet et effectuer des opérations. Exemple de méthodes dans la classe Personne : public class Personne { private String nom; private String prenom; private int age; // Constructeur paramétré public Personne(String nom, String prenom, int age) { this.nom = nom; this.prenom = prenom; this.age = age; } // Méthode pour afficher les informations de la personne public void afficherInfos() { System.out.println("Nom: " + nom); System.out.println("Prénom: " + prenom); System.out.println("Âge: " + age); } // Méthode pour vérifier si la personne est majeure public boolean estMajeur() { return age >= 18; } } Dans cet exemple :  afficherInfos() est une méthode qui affiche les informations de la personne.  estMajeur() est une méthode qui vérifie si la personne a atteint l'âge de la majorité (18 ans ou plus).  Appel des méthodes Les méthodes sont appelées à partir d'un objet de la classe Personne : Exemple d'utilisation des méthodes : public class Main { public static void main(String[] args) { // Création d'un objet de type Personne Personne personne = new Personne("Alice", "Dupont", 25); // Appel de la méthode pour afficher les infos 44  personne.afficherInfos(); // Vérification si la personne est majeure if (personne.estMajeur()) { System.out.println("Cette personne est majeure."); } else { System.out.println("Cette personne est mineure."); } } } d) Variables et méthodes d'instance (d'objet) et de classe en Java En Java, les variables et méthodes sont des concepts fondamentaux qui peuvent être soit d'instance (associées à un objet spécifique), soit de classe (partagées par tous les objets d'une classe). Voici une explication détaillée de ces deux types.  Variables et méthodes d'instance : Associées à un objet spécifique, chaque objet a ses propres valeurs pour les variables d'instance, et les méthodes d'instance sont appelées via un objet.  Variables et méthodes de classe : Partagées par tous les objets d'une classe, les variables et méthodes de classe sont appelées via le nom de la classe et ne dépendent pas d'une instance.  Variables d'instance Une variable d'instance est une variable déclarée au niveau de la classe, mais qui est propre à chaque objet créé à partir de cette classe. Chaque instance de la classe possède sa propre copie de cette variable.  Déclaration : Une variable d'instance est déclarée sans le mot-clé static dans la classe.  Accessibilité : Chaque objet a une copie unique de la variable d'instance, et ses valeurs peuvent différer entre les objets.  Durée de vie : La variable d'instance existe aussi longtemps que l'objet auquel elle appartient existe. Exemple : public class Personne { // Variables d'instance private String nom; private int age; // Constructeur public Personne(String nom, int age) { this.nom = nom; this.age = age; } // Méthode pour afficher les informations de l'objet 45  public void afficherInfos() { System.out.println("Nom: " + nom + ", Âge: " + age); } } Dans cet exemple, chaque objet de la classe Personne aura sa propre valeur pour nom et age. Personne p1 = new Personne("Ali", 30); Personne p2 = new Personne("Leila", 25); Personne p3 = new Personne("Omar", 40); // Affichage des informations de chaque personne p1.afficherInfos(); // Nom: Ali, Âge: 30 p2.afficherInfos(); // Nom: Leila, Âge: 25 p3.afficherInfos(); // Nom: Omar, Âge: 40  Variables de classe Une variable de classe (ou variable statique) est partagée par tous les objets d'une classe. Elle est déclarée avec le mot-clé static, et il n'est pas nécessaire de créer une instance de la classe pour y accéder.  Déclaration : Une variable de classe est déclarée avec le mot-clé static.  Accessibilité : Il n'y a qu'une seule copie d'une variable de classe, et cette copie est partagée entre toutes les instances de la classe.  Durée de vie : Elle existe pendant toute la durée d'exécution du programme, dès que la classe est chargée en mémoire. Exemple : public class Personne { // Variable de classe private static int compteurPersonnes = 0; private String nom; // Variables d'instance // Constructeur public Personne(String nom) { this.nom = nom; compteurPersonnes++; // Incrémente le compteur à chaque création d'objet } // Méthode statique pour afficher le nombre total de personnes créées public static int getCompteurPersonnes() { return compteurPersonnes; } } 46 Dans cet exemple, la variable compteurPersonnes est une variable de classe qui garde une trace du nombre total d'instances de Personne créées. Elle est partagée par toutes les instances de la classe Personne. // Création de plusieurs objets Personne Personne p1 = new Personne("Ali", 30); Personne p2 = new Personne("Leila", 25); Personne p3 = new Personne("Omar", 40); // Affichage du nombre - total de personnes créées : 3 System.out.println("Total de personnes créées: " + Personne.getCompteurPersonnes());  Méthodes d'instance Une méthode d'instance est une méthode qui agit sur les variables d'instance et qui nécessite un objet pour être appelée. Elle peut accéder aux variables d'instance de l'objet auquel elle appartient.  Déclaration : Une méthode d'instance est déclarée sans le mot-clé static.  Accessibilité : Elle doit être appelée via un objet. Exemple : public void afficherInfos() { System.out.println("Nom: " + nom + ", Âge: " + age); } Cette méthode doit être appelée à partir d'une instance de la classe Personne comme ceci : Personne p = new Personne("Ali", 30); p.afficherInfos();  Méthodes de classe Une méthode de classe (ou méthode statique) est une méthode qui agit sur les variables de classe et qui ne nécessite pas d'instance pour être appelée. Elle est associée à la classe elle-même, et non à un objet particulier.  Déclaration : Une méthode de classe est déclarée avec le mot-clé static.  Accessibilité : Elle peut être appelée directement via le nom de la classe, sans qu'il soit nécessaire de créer une instance. Exemple : public static int getCompteurPersonnes() { return compteurPersonnes; } Cette méthode peut être appelée directement avec le nom de la classe comme ceci : 47 int total = Personne.getCompteurPersonnes(); System.out.println("Total de personnes créées : " + total);  La différence entre les variables et méthodes d'instance et de classe Accessible Accessible par Valeur Type Mot-clé utilisé par objet classe partagée Variable d'instance Aucun Oui Non Non Variable de classe static Oui Oui Oui Méthode d'instance Aucun Oui Non Non Méthode de classe static Non Oui Oui  Surcharge des Méthodes en Java La surcharge de méthodes (ou overloading) est un concept en programmation orientée objet qui permet à une classe de définir plusieurs méthodes avec le même nom mais avec des signatures différentes. La signature d'une méthode est déterminée par son nom et le type et le nombre de ses paramètres. La surcharge est couramment utilisée pour créer des méthodes qui effectuent des opérations similaires mais nécessitent des paramètres différents.  Caractéristiques de la Surcharge de Méthodes  Nom Identique : Toutes les méthodes surchargées doivent avoir le même nom.  Paramètres Différents : Les méthodes doivent avoir un nombre différent de paramètres ou des types de paramètres différents.  Retour de Type : Le type de retour peut être identique ou différent, mais il ne peut pas être utilisé pour distinguer les méthodes surchargées.  Exemple de Surcharge de Méthodes Voici un exemple simple qui illustre la surcharge de méthodes dans une classe MathOperations : public class MathOperations { // Méthode pour additionner deux entiers public int add(int a, int b) { return a + b; } // Surcharge de la méthode pour additionner trois entiers public int add(int a, int b, int c) { return a + b + c; } 48  // Surcharge de la méthode pour additionner deux nombres décimaux public double add(double a, double b) { return a + b; } } // Utilisation de la classe MathOperations public class Main { public static void main(String[] args) { MathOperations math = new MathOperations(); // Appel de la méthode pour additionner deux entiers System.out.println("Somme de 5 et 10 : " + math.add(5, 10)); // Affiche 15 // Appel de la méthode pour additionner trois entiers System.out.println("Somme de 5, 10 et 15 : " + math.add(5, 10, 15)); // Affiche 30 // Appel de la méthode pour additionner deux nombres décimaux System.out.println("Somme de 5.5 et 10.5 : " + math.add(5.5, 10.5)); // Affiche 16.0 } }  Avantages de la Surcharge de Méthodes  Clarté et Lisibilité : En utilisant le même nom de méthode pour des opérations similaires, le code devient plus clair et lisible.  Flexibilité : Les méthodes surchargées permettent d'utiliser une même méthode pour différents types et nombres d'arguments, ce qui simplifie l'interface de la classe.  Réduction de la Duplication de Code : Au lieu de créer des méthodes distinctes pour des opérations similaires, vous pouvez les regrouper sous un même nom, réduisant ainsi la duplication de code.  Méthode Var-Args en Java La fonctionnalité Var-Args (ou arguments variables) en Java permet à une méthode de recevoir un nombre variable d'arguments d'un type spécifique. Cela simplifie la définition des méthodes lorsque vous ne savez pas à l'avance combien d'arguments seront passés. Cette fonctionnalité a été introduite dans Java 5 et est souvent utilisée pour traiter des listes d'éléments.  Syntaxe des Méthodes Var-Args Pour définir une méthode avec des arguments variables, vous utilisez trois points de suspension (...) après le type des paramètres. Voici la syntaxe générale : public void maMethode(Type... nomDuParametre) { // Corps de la méthode 49 }  Exemple de Méthode Var-Args Voici un exemple simple qui illustre l'utilisation de méthodes Var-Args : public class VarArgsExample { // Méthode pour additionner un nombre variable d'entiers public int sum(int... numbers) { int total = 0; for (int number : numbers) { total += number; // Additionne chaque nombre } return total; // Retourne la somme totale } } // Utilisation de la classe VarArgsExample public class Main { public static void main(String[] args) { VarArgsExample example = new VarArgsExample(); // Appel de la méthode sum avec différents nombres d'arguments System.out.println("Somme de 5 et 10 : " + example.sum(5, 10)); // Affiche 15 // Affiche 15 System.out.println("Somme de 1, 2, 3, 4, 5 : " + example.sum(1, 2, 3, 4, 5)); System.out.println("Somme sans arguments : " + example.sum()); // Affiche 0 } }  Caractéristiques des Méthodes Var-Args  Un Seul Var-Arg : Une méthode peut avoir un seul paramètre Var-Args, et il doit être le dernier paramètre de la méthode.  Type d'Argument : Vous pouvez utiliser des types primitifs ou des types d'objets comme Var- Args.  Tableau en Arrière-Plan : Les arguments var-args sont traités comme un tableau à l'intérieur de la méthode. Vous pouvez donc accéder aux éléments en utilisant des index.  Pas de combinaison avec d'autres types : Si vous utilisez des var-args, vous ne pouvez pas avoir d'autres paramètres après les var-args dans la signature de la méthode. Par exemple, la méthode suivante est invalide : public void maMethode(int x, String... args) { // Valide // Corps } 50  public void maMethode(String... args, int x) { // Invalide // Corps }  tableau d'objets Un tableau d'objets est une collection de références à des objets d'une même classe. En Java, les tableaux sont de taille fixe, ce qui signifie que vous devez définir leur taille lors de leur création.  Déclaration et Initialisation  Déclaration : Pour déclarer un tableau d'objets, vous spécifiez le type d'objet suivi des crochets. Par exemple, pour un tableau d'objets de la classe Personne : Personne[] personnes;  Initialisation : Vous pouvez initialiser un tableau de plusieurs façons : o Avec une taille fixe : personnes = new Personne; // Un tableau pour 3 objets Personne o Avec des objets lors de la déclaration : Personne[] personnes = new Personne[] { new Personne("Alice", 30), new Personne("Bob", 25), new Personne("Charlie", 35) };  Accéder aux Objets dans un Tableau Pour accéder à un objet dans le tableau, utilisez son index (les indices commencent à 0): personnes.afficherInfos(); // Affiche les informations de la première personne  Exemple Complet Voici un exemple complet qui illustre la déclaration, l'initialisation et l'utilisation d'un tableau d'objets : public class Personne { private String nom; private int age; public Personne(String nom, int age) { this.nom = nom; this.age = age; } 51  public void afficherInfos() { System.out.println("Nom: " + nom + ", Âge: " + age); } } public class Main { public static void main(String[] args) { // Initialisation du tableau d'objets Personne Personne[] personnes = new Personne; // Création des objets Personne et affectation au tableau personnes = new Personne("Alice", 30); personnes = new Personne("Bob", 25); personnes = new Personne("Charlie", 35); // Affichage des informations de chaque personne for (Personne p : personnes) { p.afficherInfos(); } } } 3 Comprendre les Packages en Java Un package en Java est un mécanisme qui permet d'organiser des classes et des interfaces en regroupant des éléments connexes sous un même nom. Il agit comme un conteneur pour des ensembles de classes et facilite la gestion, la distribution et la réutilisation du code. Les packages permettent également d'éviter les conflits de noms entre classes qui peuvent avoir le même nom mais qui appartiennent à des packages différents.  Toutes les classes en Java sont organisées en packages (ou bibliothèques).  un package est associé à un dossier et un sous- package à un sous-dossier. 3.1 Caractéristiques des Packages  Organisation du Code : Les packages aident à organiser les classes et interfaces d'un projet en les regroupant selon leur fonctionnalité ou leur utilisation. Cela améliore la lisibilité et la maintenance du code.