2024_UE105_POO_Q1.pdf

POO Programmation JAVA (UE105) HELHA – Campus Mons – IRAM Cours de M. Altares, de Mme Boulogne, de M...

POO Programmation JAVA (UE105) HELHA – Campus Mons – IRAM Cours de M. Altares, de Mme Boulogne, de M. Colmant, de M. Godefroid et de M. Palermo Année académique 2024-2025 V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 1 Table des matières 1 Présentation de Java................................................................................................................4 1.1 Le langage de programmation Java................................................................................4 1.2 Code source, code exécutable.........................................................................................5 1.2.1 Génération de code exécutable :...............................................................................5 1.3 La machine virtuelle.......................................................................................................6 1.4 Différents modes d’exécution..........................................................................................8 1.5 Robustesse, récupération des erreurs, gestion de la mémoire..........................................9 1.5.1 La gestion de mémoire..............................................................................................9 1.6 Exemple d’une application Java simple..........................................................................9 1.6.1 Compilation et exécution de Demo.java................................................................10 1.7 Introduction à la modularité:classes et packages..........................................................11 1.8 Architecture générale d’un fichier source.....................................................................11 1.9 Utiliser la documentation...............................................................................................12 2 Identificateurs, mots-clés......................................................................................................13 2.1 Syntaxe : généralités.....................................................................................................13 2.2 Variables et identificateurs...........................................................................................13 2.3 Mots-clés........................................................................................................................14 2.4 Séparateurs de structure.................................................................................................14 2.5 Commentaires...............................................................................................................15 3 Types.....................................................................................................................................17 3.1 Types primitifs, types objets.........................................................................................17 3.2 Types primitifs: numériques entiers..............................................................................18 3.2.1 Littéraux entiers.....................................................................................................18 3.3 Types primitifs: numériques flottants...........................................................................19 3.3.1 Littéraux flottants...................................................................................................19 3.4 Types primitifs : logiques.............................................................................................20 3.5 Types primitifs: caractères............................................................................................20 3.5.1 Littéraux de type caractère.....................................................................................21 3.6 Type String....................................................................................................................21 3.7 Déclaration et initialisation d’une variable...................................................................21 3.8 Conventions de codage.................................................................................................22 3.9 Portée des variables, cycle de vie.................................................................................22 3.9.1 Variables locales....................................................................................................23 3.9.2 Variables d’instance, variables de classe...............................................................23 3.10 Initialisations implicites..............................................................................................24 4 Opérateurs............................................................................................................................25 4.1 Opérateurs arithmétiques...............................................................................................25 4.1.1 Opérateurs unaires: + , -..........................................................................................25 4.1.2 Opérateurs binaires : +, -, *, /, %............................................................................25 4.1.3 Conversions d’ajustement de types........................................................................26 4.1.4 Promotions numériques.........................................................................................26 4.2 Opérateur d’affectation =...............................................................................................26 4.2.1 Affectations multiples.............................................................................................27 4.2.2 Conversion par affectation......................................................................................27 4.3 Opérateurs d’affectation élargie.....................................................................................27 4.4 Opérateurs d’incrémentation..........................................................................................28 V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 2  4.5 Opérateurs relationnels..................................................................................................29 4.6 Opérateurs logiques.......................................................................................................29 4.6.1 Évaluation des opérations de court circuit && et ||...............................................30 4.7 Opérateur conditionnel : ? :..........................................................................................30 4.8 Opérateurs logiques “bit-à-bit”......................................................................................31 4.9 Opérateurs de décalage de bits......................................................................................31 4.9.1 Priorités des opérateurs...........................................................................................32 4.9.2 Forçages de type....................................................................................................33 5 Structures de contrôle..........................................................................................................34 5.1 Structures de contrôle alternatives : if, if else...............................................................34 5.1.1 Instruction alternative: if........................................................................................34 5.1.2 Instruction alternative: if-else................................................................................35 5.1.3 Instruction conditionnelle : else if...........................................................................36 5.2 Instruction conditionnelle multiple : switch.................................................................37 5.3 Structures de contrôle itératives.....................................................................................40 5.3.1 Structures itératives : for........................................................................................40 5.3.2 Structures itératives : while....................................................................................41 5.3.3 Structures itératives : do... while..........................................................................42 5.4 Instructions de branchement dans une boucle..............................................................43 6 Tableaux...............................................................................................................................44 6.1 Tableaux:initialisations.................................................................................................45 6.2 Tableaux multidimensionnels.......................................................................................45 6.3 Limites d’un tableau.....................................................................................................46 7 Méthodes d’instance et de classe..........................................................................................48 7.1 Notions de méthode: principes, paramètres, résultats...................................................48 7.2 Méthodes de classe :.....................................................................................................48 7.3 Méthodes d’instance.....................................................................................................49 7.4 Passage de paramètres...................................................................................................49 V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 3 1 Présentation de Java 1.1 Le langage de programmation Java Le langage Java (appelé Oak à l’origine) a débuté dans les années 90 avec James Gosling qui souhaitait développer un langage de programmation indépendant du matériel. Le but de Java à l'époque était de proposer un langage de programmation pouvant être intégré dans les appareils électroménagers afin de les rendre interactifs. L’objectif du projet appelé Green, était de créer une télécommande universelle susceptible de contrôler l'ensemble des appareils électroménagers de la maison. Ce projet fut un échec… Par la suite Bill Joy (co-fondateur de la firme Sun Microsystems) proposa une nouvelle version d'Oak appelée « Java ». Son but était de pallier une déficience des langages de programmation de l’époque en produisant un langage conçu pour des machines et des logiciels hétérogènes qu'englobe Internet. Ainsi, Java a connu un très grand développement grâce à l’explosion du Web. La communauté des développeurs a rapidement adopté ce langage pour  sa clarté,  sa puissance d’expression,  son organisation de langage à objets,  sa portabilité,... Fin 2006, Sun annonce le passage de Java, sous licence GPL (general public license). Java devient donc un logiciel libre. Historique des versions (LTS = long-term support)  JDK 1.0 : 1996 : Version initiale : 211 classes et interfaces.  JDK 1.1 : 1997 : Ajout de JDBC pour les connexions aux bases de données, fichier jar, et sérialisation entre autres  J2SE 1.2 : 1998 : Playground : API graphique SWING, framework Collections, les versions J2SE 1.2 jusque J2SE 5 sont appelées JAVA 2  J2SE 1.3 : 2000 : Kestrel : Grandes améliorations de performances  J2SE 1.4 : 2002 : Merlin : JDBC 3, API de Logging et Java Web Start  J2SE 5.0 : 2004 : Tiger (3270 classes et interfaces): Grandes améliorations du langage (boucle for each, types génériques,...)  Java SE 6 : 2006 : Mustang : meilleure intégration avec le système d'exploitation, avec les classes Desktop et Systrays. V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 4   Java 7.0 (support terminé pour toutes les versions jusqu'à la 7) : 2011 : Dolphin : modifications entre autres de la gestion des fichiers et des exceptions.  Java 8 (LTS : support jusqu'en 2030 via OpenJDK) : 2014 : Kenai : interfaces fonctionnelles, expressions lambdas, nouveau format pour les dates.  Java 9 : 2017 : Umbrella : fichiers JSON, amélioration de l'initialisation d'une liste, meilleure modularisation.  Java 10 : 2018 : comme Java 9, il s'agit d'une version à court terme dont la maintenance est déjà terminée.  Java 11 (LTS : support jusqu'en 2032) : 2018  Java 12 : 03/2019 : comportement de la JVM adaptable manuellement.  Java 13 : 09/2019  Java 14 : 03/2020 : simplification du instanceof  Java 15 : 09/2020 : bloc de textes (chaîne de caractères sur plusieurs lignes)  Java 16 : 03/2021  Java 17 (LTS : support au moins jusqu'en 2029) : 09/2021 : apparition des pattern matching (motifs de correspondance)  Java 18 : 03/2022  Java 19 : 09/2022  Java 20 : 03/2023  Java 21 (LTS : support au moins jusqu'en 2031) : 09/2023 : modification, entre autres, du fonctionnement du switch  Java 22 : 03/2024  Java 23 : 09/2024 1.2 Code source, code exécutable 1.2.1 Génération de code exécutable : Le fichier source d'un programme Java est un fichier texte dont l'extension est par convention.java. Lorsque le programme est prêt à être testé, il faut le compiler (le traduire en langage machine) à l'aide d'un compilateur. V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 5 Dans les langages compilés traditionnels (C, C++, Cobol, …), le compilateur crée un fichier binaire directement exécutable par un processeur donné (c'est-à-dire un fichier binaire contenant des instructions spécifiques à un processeur). A la différence des langages compilés traditionnels, le code source Java est compilé en un langage intermédiaire (appelé pseudo-code ou bytecode) dans un fichier portant le même nom que le fichier source à l'exception de son extension (.class). C’est cette caractéristique qui fait qu'un programme écrit en Java est portable, c'est- à-dire qu'il ne dépend pas d'une plate-forme donnée. Fichier source : Demo.java public class Demo { public static void main (String[] args) { System.out.println("Hello World!") ; } } Fichier binaire : Demo.class (414 octets) V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 6.... Décompilation du fichier binaire : Method void main(java.lang.String[]) 0 getstatic #7 3 ldc #1 5 invokevirtual #8 8 return... 1.3 La machine virtuelle En réalité le byte code n'est exécutable sur aucune plate-forme sans la présence d'une machine virtuelle, un interpréteur (la machine virtuelle est d'ailleurs parfois appelée interpréteur Java) tournant sur une plate-forme donnée, et capable d'interpréter le code intermédiaire. Que ce soit pour un navigateur ou pour une application autonome il y a un exécuteur de code Java. V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 7 Ce programme interprète le byte code comme un code d’une machine virtuelle. Les spécifications du langage Java définissent très précisément la description et le comportement de cette machine virtuelle. Pour exécuter un code Java sur un Système et une architecture donnée on doit donc trouver localement:  Une implantation de la JVM (au sein d’un navigateur, ou pour lancer des applications autonomes),  Les librairies constituant le noyau des classes standard Java. La plus grande partie est constituée de code Java. Les applications Java peuvent être exécutées sur tous les systèmes d'exploitation pour lesquels a été développée une plateforme Java, dont le nom technique est JRE (Java Runtime Environment - Environnement d'exécution Java). La plateforme Java correspond à une machine virtuelle Java avec en plus des spécifications d'API. Il existe 3 versions de la plateforme (JRE) Java, chacune adaptée à un environnement particulier : JSE (Java Platform, Standard Edition) qui contient les API de base, est destiné aux applications autonomes, JEE (Java Platform, Enterprise Edition) contient, en plus de JSE, les API orientées entreprise et est destiné aux serveurs d’application, JME (Java Platform, Micro Edition) est préconisé pour les appareils mobiles tels que les PDAs ou les smartphones. V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 8 1.4 Différents modes d’exécution  Interprétation: Le fichier de bytecode est lu et exécuté au fur et à mesure par le programme qui implante le comportement de la JVM.  JIT (Just-In-Time, compilation à la volée): La machine virtuelle compile directement le pseudo-code en code natif de la plate-forme locale, puis l’OS l'exécute. Le temps perdu par la compilation sera rattrapé du fait de la rapidité d’exécution du code natif. V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 9   HotSpot : Un optimiseur décide, au moment de l’exécution, s’il y a lieu de compiler ou d’interpréter (exemple : boucle exécutée N fois : la situation n’est pas la même si N vaut 2 ou vaut des milliers). 1.5 Robustesse, récupération des erreurs, gestion de la mémoire. 1.5.1 La gestion de mémoire Dans de nombreux langages comme C/C++ la gestion dynamique des objets en mémoire est une source constante de bugs très subtils et très coûteux en maintenance. Les “fuites mémoire” peuvent passer au travers des tests de validation et nécessitent des outils spécifiques de recherche et de validation. Java entre dans la catégorie des langages disposant d’un “ramasse-miettes”, garbage collector. Un processus de priorité basse est réactivé de temps en temps et récupère automatiquement la mémoire occupée par des objets qui ne sont plus référencés. Ce processus compacte également la mémoire occupée et gère de manière optimale la place disponible. Cette gestion est facilitée par le fait que le programmeur n’a aucun moyen d’accéder directement à la mémoire (pas de pointeurs). 1.6 Exemple d’une application Java simple Fichier source nommé Demo.java // // application “Hello World” // public class Demo { public static void main (String[ ] args) { System.out.println("Bonjour le Monde!") ; } } Ces quelques lignes représentent un programme autonome minimum pour imprimer un message à l’écran.  Les trois premières lignes (commençant par “//”) constituent des commentaires.  Le bloc suivant (public class Demo {...} ) constitue une définition de classe. V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 10   Il n’y a pas de code en dehors des classes (à l'exception de la déclaration du package et des imports).  Pour toute classe déclarée dans un fichier, le compilateur crée un fichier “.class” de même nom.  Pour commencer l’exécution d’une application autonome à partir d’une classe donnée, l’interprète recherche dans cette classe le point d’entrée standard désigné exactement par public static void main (String[] args). 1.6.1 Compilation et exécution de Demo.java  A partir du fichier source Demo.java la compilation se fait par : javac Demo.java  Si le compilateur ne renvoie pas d’erreur, un fichier exécutable Demo.class sera créé dans le répertoire courant.  Pour exécuter l’application il suffit d’invoquer : java Demo NB : variable Path (à adapter éventuellement en fonction du répertoire dans lequel se trouve le JDK) : SET PATH = %PATH% ; C:\Program Files\Java\jdk1.8.0_01\bin; Quelques problèmes courants :  A la compilation : non correspondance entre le nom de la classe publique et le nom du fichier.  A la compilation : erreurs de saisie dans le texte - erreurs de syntaxe, erreurs sur les noms, etc.  A l’exécution: l’exécuteur ne trouve pas la classe.  Une autre source d’erreurs est une mauvaise définition du “main” qui serait absente ou qui ne correspondrait pas exactement à la signature : public static void main (String[ ] args ) 1.7 Introduction à la modularité:classes et packages Comme nous l’avons vu une classe constitue un module fonctionnel qui permet de regrouper un certain nombre de fonctionnalités. V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 11 Le Kit de développement logiciel Java SDK offre un ensemble de classes standard qui implantent des services pour les tâches courantes de programmation. Toute JVM doit avoir accès localement à ces classes. Les classes sont regroupées en packages en fonction de leurs affinités et de leur domaine d’action. Ainsi on retrouve dans le SDK un certain nombre de packages standard dont, en particulier:  java.lang (seul package qui ne nécessite pas d'import) : contient les classes fondamentales du langage comme String (les chaînes), Thread (les processus légers), System, Math, etc ;  java.util : contient des classes utilitaires pour le programmeur comme les collections (Vector, HashMap, Properties,..), les dates (Calendar), l’internationalisation (Locale, ResourceBundle,..) ;  java.awt : construction et gestion d’interfaces graphiques ;  java.io : entrées/sorties portables ;  java.net : opérations au travers du réseau ; ... 1.8 Architecture générale d’un fichier source Bien que cela ne soit pas strictement obligatoire il est très vivement conseillé de développer des classes Java comme faisant partie d’un package. Dans ces conditions l’architecture générale d’un fichier source Java se présente obligatoirement de la manière suivante (abstraction faite des commentaires) :  une déclaration d’appartenance à un package package herb.iram.info ; // noter l’organisation hiérarchique des packages  éventuellement une liste de clauses import qui permet au compilateur de connaître les classes d’autres packages pour vérifier la cohérence du source local et lever toute ambiguïté. Le package java.lang est toujours visible et n’a pas besoin de figurer dans une clause import. import java.io.ObjectInputStream ; import java.io.FileInputStream ; import herb.iram.info.*; V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 12  // permet de voir toutes les classes appartenant // directement à ce package // mais pas les classes des sous-packages  les définitions de classes et d’interfaces (un autre type de définition de premier niveau que nous verrons ultérieurement). public class Test {..... } 1.9 Utiliser la documentation Disponible sur : https://docs.oracle.com/javase/8/docs/api/ La documentation de référence a une structure d’hypertexte consultable par un navigateur HTML. Il est essentiel d’apprendre à rechercher des informations par ce biais. La documentation des APIs Java a été directement extraite des sources de Java lui- même au moyen de l’utilitaire javadoc. Java dispose d’un formalisme standard qui permet d’inclure de la documentation directement dans le code. V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 13 2 Identificateurs, mots-clés 2.1 Syntaxe : généralités Un source Java est composé de “mots” qui sont délimités par des caractères (ou des ensembles de caractères) particuliers. Ces “mots” peuvent être :  des identificateurs : nomDeVariable, nomDeMethode,...  des mots-clefs réservés : if , while,...  des littéraux : 3.14, 6.02e-9 , “une chaîne”,...  des séparateurs : o séparateurs de structure : { , [ , ; ,... o espacements : espace, tabulation, retour chariot.  des commentaires,  des opérateurs : + , * , =, && , >>,... 2.2 Variables et identificateurs Une variable est un objet repéré par son nom qui peut contenir des données, qui pourront être modifiées lors de l'exécution du programme. Le nom de la variable est encore appelé identificateur. Les variables sont typées: les données contenues dans celles-ci possèdent un type, elles sont stockées à une adresse mémoire et occupent un nombre d'octets qui dépend du type de donnée stockée. Les identificateurs peuvent être aussi longs que l'on désire. Ils doivent répondre à certains critères :  commencer par une lettre Unicode,  les caractères suivants peuvent également comporter des chiffres,  les identificateurs peuvent contenir des mots-clés, mais ne doivent pas eux- mêmes être des mots-clés: Exemple : “longueur” est un identificateur valide mais “long” ne l’est pas ! Exemples identificateurs valides: numClient, fenêtre,nomUtilisateur, MaClasse, _var_sys, $argent LES IDENTIFICATEURS SONT SENSIBLES À LA CASSE. V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 14 2.3 Mots-clés Ce sont des mots réservés par le langage pour un usage bien défini. abstract continue for new switch assert default if package synchronized boolean do goto private this break double implements protected throw byte else import public throws case enum instanceof return transient catch extends int short try char final interface static void class finally long strictfp volatile const float native super while _ (underscore) A cette liste de mots-clés s'ajoutent les littéraux true et false (pour les boolean), null (référence vers aucun objet) et var (identificateur spécial) qui ne peuvent pas être utilisés comme identificateurs. 2.4 Séparateurs de structure Une instruction se termine par un point virgule (;). Elle peut tenir sur une ou plusieurs lignes. total = ix + iy + iz + ij + ik+ il ; est la même chose que : total = ix + iy + iz + ij + ik + il ; Un bloc regroupe un ensemble d’instructions, il est délimité par des accolades. { ix = iy + 1 ; iz = 25 ; } Les blocs peuvent s’emboîter les uns dans les autres : { int ix = iy + 1 ; while ( ik < min ) { ik = ik * ix; ix=4; } } Les espacements (caractère espace, tabulation, retour chariot) peuvent se répéter à V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 15 l’intérieur du code source. On peut les utiliser pour améliorer la présentation. if(ix long -> float -> double 4.1.4 Promotions numériques Les opérateurs arithmétiques ne sont pas définis pour les types byte, char et short. Java prévoit que toute valeur de l’un de ces deux types apparaissant dans une expression sera d’abord convertie en int. 4.2 Opérateur d’affectation = L’instruction d’affectation a pour syntaxe : V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 27  variable = expression ; Cette instruction signifie que la variable (destination) reçoit la valeur de l’expression (source). La valeur initiale de la variable est écrasée par l’opérateur =. La destination (variable) et la source (expression) doivent être de types compatibles. Il n’est pas possible de faire apparaître une expression comme premier opérande de l’opérateur =. L’expression a+3=b; n’a pas de sens. 4.2.1 Affectations multiples L’associativité de droite à gauche de l’opérateur d’affectation permet l’emploi d’instructions du type : int i, j ; i = j = 10 ; //équivaut à (i = (j = 10) ) 4.2.2 Conversion par affectation Considérons la situation suivante : float x ; int i , n;... x=i+5; //ajustement de type n=x+5; //rejeté en compilation Les conversions qui sont permises lors d’une affectation sont celles qui ne modifient pas la valeur d’origine. Les conversions implicites sont celles qui se font suivant l’une des hiérarchies suivantes : byte => short => int => long => float => double char => int => long => float => double 4.3 Opérateurs d’affectation élargie Les opérateurs d’affectation élargie permettent de simplifier des opérations telles que ajouter une valeur dans une variable et stocker le résultat dans la variable. Une telle opération s'écrirait habituellement de la façon suivante par exemple: x = x+2 ; V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 28 Avec les opérateurs d’affectation élargie, il est possible d'écrire cette opération sous la forme suivante: x+=2 ; Ainsi, si la valeur de x était 20 avant opération, elle sera de 22 après. Les autres opérateurs du même type sont les suivants : Opérateur Effet += addition deux valeurs et stocke le résultat dans la variable (à gauche) -= soustrait deux valeurs et stocke le résultat dans la variable *= multiplie deux valeurs et stocke le résultat dans la variable /= divise deux valeurs et stocke le résultat dans la variable 4.4 Opérateurs d’incrémentation Les opérateurs d’incrémentation permettent d’augmenter ou de diminuer d'une unité une variable. Ces opérateurs s’avèrent très utiles pour des structures telles que des boucles, qui nécessitent un compteur. Un opérateur de type x++ permet de remplacer des notations telles que x=x+1 ou bien x+=1. Opérateur Dénomination Effet Syntaxe Résultat (avec x =20) ++ Incrémentation Augmente d'une unité la variable x++ 21 -- Décrémentation Diminue d'une unité la variable x-- 19 V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 29  4.5 Opérateurs relationnels Ces opérateurs permettent de comparer des variables. Ils renvoient tous un résultat de type boolean. Opérateur Dénomination Effet Exemple Résultat Compare deux valeurs et Retourne true si x est égal à 20, == opérateur d'égalité x==20 vérifie leur égalité sinon false Vérifie qu'une variable est opérateur d'infériorité Retourne true si x est inférieur < strictement inférieure à une x= opérateur de supériorité supérieure ou égale à une x>=20 ou égal à 20, sinon false valeur Vérifie qu'une variable est Retourne true si x est différent != opérateur de différence x!=20 différente d'une valeur de 20, sinon false 4.6 Opérateurs logiques Les opérateurs logiques permettent de vérifier si plusieurs conditions sont vraies. Opérateur Dénomination Effet Syntaxe || OU inclusif (cc) Vérifie qu'une des conditions est réalisée (condition1 || condition2) Vérifie que toutes les conditions sont && ET (cc) (condition1 && condition2) réalisées Inverse l'état d'une variable booléenne ! NEGATION (retourne la valeur true si la variable vaut (!condition) false, false si elle vaut true) Renvoie true seulement si une seule des ^ OU exclusif (condition1 ^ condition2) conditions est réalisée V. Altares, I. Boulogne, A. Colmant, L. Godefroid, O. Palermo 1BI: POO Programmation Java 30 Exemples : (a