Badr Benmammar bbm@badr-benmammar

1. Formation Développeur Java Introduction à la programmation en Java Badr Benmammar bbm@badr-benmammar.com

2. Plan • Introduction générale • Langages compilés • Langages interprétés • Langages intermédiaires • Introduction au JAVA • Environnement de programmation • JVM, JRE, JDK et SDK • Quelques packages • Package de base : java.lang • Historique des versions • J2SE, J2EE et J2ME • Terminologie • JAR, JCP et JSR • JAVA, interprété ou compilé ?

3. Plan • Syntaxe et éléments de bases de Java • Types primitifs • Variables • Constantes • Conversion de type de données • Conversion explicite • Conversion implicite • Lire les entrées clavier • Opérateurs • Fonctions mathématiques • Structures de contrôles des instructions • Tableaux • Fonctions • Procédures

4. Langages de programmation • Les langages de programmation actuels sont majoritairement de deux sortes : • Langages compilés. • Langages interprétés. • Lors du choix d’un langage pour un projet, cet aspect fondamental peut faire pencher la balance.

5. Langage machine • Le langage machine, ou code machine, c’est le langage natif d'un processeur, c'est-à-dire le seul qu'il puisse traiter. • C’est la suite de bits qui est interprétée par le processeur d'un ordinateur exécutant un programme informatique. • Il est composé d'instructions et de données à traiter codées en binaire. • Le code machine est généré, généralement par la compilation d'un langage de programmation.

6. Langage compilé • Un programme écrit dans un langage compilé va être traduit une fois pour toutes par un compilateur, afin de générer un fichier exécutable. • Exemple : C, C++, Pascal, Fortran, Cobol, ADA. • Le langage C : • gcc -o essai.o -c essai.c • gcc -o essai essai.o • Ou • gcc –o essai essai.c • Avantage : rapide. • Inconvénient : fermé si on n’a pas le source, besoin de l’outil de développement pour modifier.

7. Langageinterprété • Un langage informatique se dit interprété lorsque les instructions qui le composent sont décodées les unes après les autres et exécutées aussitôt. • Son fonctionnement est le suivant : • Lire l’instruction ; • Exécuter l’instruction ; • Passer à l’instruction suivante et recommencer.

8. Langage interprété • Un langage interprété a besoin d’un interpréteur. • BASIC, MATLAB, PHP, Prolog, Perl. • Le QBasic se lançait avec la commande : qbasic /run prog.bas • Avantage : le programme prog.bas est un fichier texte, facilement modifiable. • Inconvénient : c’est forcément plus lent que quand c’est compilé.

9. Quelques langages

10. Langages intermédiaires • Certains langages appartiennent en quelque sorte aux deux catégories : • LISP, Python, … • Le programme écrit avec ces langages peut dans certaines conditions subir une phase de compilation intermédiaire vers un fichier écrit dans un langage différent du fichier source et non exécutable (nécessité d’un interpréteur).

11. JAVA : portabilité et fiabilité • JAVA a été développé par Sun au début des années 90 dans une filiation avec le langage C et surtout le langage objet C++ mais dans une optique de plus grande portabilité d’une machine à une autre et d’une plus grande fiabilité . • Les programmes JAVA sont compilés en "bytecode", un langage intermédiaire indépendant de la plateforme. • Ce "bytecode" est interprété par une machine virtuelle sur des machines différentes : Mac, Pc, Windows, Linux, Unix, ... • Exemple :applets Java, petits programmes insérés parfois dans les pages Web, sont des fichiers qui sont compilés mais que l’on ne peut exécuter qu'à partir d’un navigateur internet.

12. JAVA : compilé ou interprété ? • Un langage compilé est un langage pour lequel le compilateur va traduire le code écrit par les développeurs en code exécutable directement par la machine. • Un langage interprété est un langage pour lequel la traduction en code machine n'est fait qu’à l'exécution. • Pour le java, on à une étape de compilation qui produit du code qui sera exécuté par une machine virtuelle, c’est une solution intermédiaire qui permet de rester indépendant du type de machine qui exécutera le code tout en ayant un code déjà optimisé pour l'exécution.

13. Fichier source (*.java) Compilateur (javac) Bytecode (*.class) Interpréteur (java) JAVA : compilé ou interprété ?

14. JAVA : environnement de programmation • JAVA est un environnement de programmation objet composé de : • Langage orienté objet JAVA. • JVM (machine virtuelle Java) : permettant d’interpréter et d’exécuter le bytecode Java. • API (application programming interface) : un ensemble de classes standards (bibliothèque). • JRE (Java Runtime Environment) :l’environnement d’exécution Java désigne un ensemble d’outils permettant l’exécution de programmes Java sur toutes les plates-formes supportées. • JRE est constitué de la JVM et d’une bibliothèque standard à partir de laquelle doivent être développés tous les programmes en Java. • java.lang est le package de base qui contient les classes qui seraient toujours utilisées (System, Thread, Math, String, …). • Toutes les classes et interfaces de java.lang sont automatiquement importées par le compilateur.

15. JAVA : environnement de programmation • Java Development Kit (JDK) : le nouveau terme c’est SDK (Standard Development Kit) qui est l’environnement dans lequel le code Java est compilé pour être transformé en bytecode afin que la machine virtuelle Java (JVM) puisse l'interpréter. Les composants primaires du JDK sont une sélection d’outils de programmation, incluant : • javac :le compilateur, qui convertit le code source en fichier .class (contenant le bytecode Java). • javadoc : le générateur de documentation, qui génère automatiquement de la documentation à partir des commentaires du code source. • jar : l’archiveur, qui met sous forme d’un paquetage unique l’ensemble des fichiers class en un fichier JAR. • jdb : le débogueur. • JRE :environnement d’exécution Java.

16. Quelques packages • Package de base : java.lang • Toutes les classes et interfaces de java.lang sont automatiquement importées par le compilateur. • Gestion de données et utilitaires : java.util • Rassemble des classes d'utilitaires (gestion des collections de données, génération de nombres aléatoires, énumération, date,...). • Définit les classes d'exceptions : • EmptyStackException. • NoSuchElementException. • Gestion des applets : java.applet • La classe Applet et les interfaces de ce package permettent de programmer une applet Java et d'intégrer une applet dans un navigateur. • Manipulation d'images : java.awt.image • Les classes de ce package permettent de manipuler les images (gestion du chargement des images, filtres, gestion des couleurs,...).

17. Quelques packages • Entrées-sorties : java.io • Rassemble les classes permettant de gérer les entrées-sorties (accès fichiers, gestion de répertoires,...). • Définit les classes d'exceptions : • IOException. • EOFException. • FileNotFoundException. • InterruptedIOException. • UTFDataFormatException. • Accès réseau : java.net • Rassemble les classes permettant de gérer les accès réseau. • Définit les classes d'exceptions : • MalformedURLException. • ProtocolException. • SocketException. • UnknownHostException. • UnknownServiceException.

18. Quelques packages • Interface utilisateur : • java.awt : utilise les composant graphiques natifs (peers). • Définit les classes d'exceptions : • AWTException. • AWTError. • Interface utilisateur : • javax.swing :librairie très puissante, composants très évolués (arbres, tables, …). • Définit l’exception : UnsupportedLookAndFeelException • Java 3D : javax.media.j3d • Rassemble les classes de l’API Java 3D (interface de programmation pour la plateforme Java visant la synthèse d'image 3D).

19. Historique des versions • Le langage Java a connu plusieurs évolutions depuis le JDK 1.0 (Java Development Kit) avec l’ajout de nombreuses classes et packages à la bibliothèque standard. • JDK 1.0 (23 janvier 1996 - 211 classes et interfaces) : version initiale. • JDK 1.1 (19 février 1997 - 477 classes et interfaces) : de nombreux ajouts avec notamment : • Une refonte complète du modèle événementiel AWT. • Les classes internes sont ajoutées au langage. • JavaBeans. • JDBC. • Java Remote Invocation (RMI).

20. Historique des versions • J2SE 1.2 (9 décembre 1998 - 1524 classes et interfaces) : cette version et les suivantes jusque J2SE 5.0 sont rebaptisées Java 2 et l’édition nommée J2SE remplace JDK pour distinguer la plate-forme de base de l’édition J2EE et de l’édition J2ME. • J2SE : (Java 2 Standard Edition) comprenant les API et bibliothèques de bases, ainsi que les API destinés au poste client (comme par exemple Java Foundation Classes (JFC) qui est un framework graphique pour Java composé de AWT, Swing et Java2D). • J2EE : (Java 2 Enterprise Edition) destinée aux développements des applications d’entreprises. Sun propose en plus des spécifications, des mises en œuvre illustratives. • J2ME : (Java 2 Micro Edition) destinée aux systèmes mobiles tel que par exemple, les assistants personnels ou les téléphones portables. • Plusieurs ajouts par rapport à la version précédente dont : • Le framework Collections. • L’API graphique Swing est intégrée.

21. Historique des versions • J2SE 1.3 (8 mai 2000 - 1 840 classes et interfaces) : changements principaux : • Changement pour les RMI pour être basé sur CORBA. • JavaSound. • JNDI (Java Naming and Directory Interface) inclus de base (disponible auparavant comme extension) pour utiliser différents services de nommages ou d'annuaires. • JPDA (Java Platform Debugger Architecture) pour les outils de type débogueur.

22. Historique des versions • J2SE 1.4 (6 février 2002 - 2 723 classes et interfaces) : les principaux changements sont : • Mot-clé assert. • Expressions rationnelles modélisées en s’inspirant du langage Perl. • Chaînage d’exception. • API de journalisation. • API Image I/O pour lire et écrire des images dans des formats comme JPEG et PNG. • Intégration d’un parser XML (pour extraire les données d’un document XML et pour vérifier sa validité) et du moteur XSLT nommé JAXP. • JAXP (Java API for XML Processing) est une API permettant la création, la manipulation et le traitement de fichiers XML à bas niveau. • Intégration des extensions de sécurité JCE (Java Cryptography Extension), JSSE et JAAS. • Java Web Start (introduit pour la première fois en mars 2001 pour J2SE 1.3).

23. Historique des versions • J2SE 5.0 (30 septembre 2004 - 3 270 classes et interfaces) : (initialement numérotée 1.5, qui est toujours utilisé comme numéro de version interne), ajoute un nombre significatif de nouveautés au langage : • Programmation générique. • Metadata, également appelées annotations, permet au langage de construire des classes et des méthodes étiquetées avec des données additionnelles qui peuvent être utilisées en tant que méta-données. • Autoboxing/unboxing, conversion automatique entre des types primitifs (comme le type int) et le Wrapper de classe correspondant (comme la classe Integer). • Énumérations : le mot-clé enum permet de créer une liste ordonnée de valeurs sans type. • Extension du for pour les boucles, la syntaxe du for est étendue avec une syntaxe spéciale pour itérer sur n’importe quel objet itérable comme un tableau, ou une collection.

24. Historique des versions • Java SE 6 (11 décembre 2006 - 3 777 classes et interfaces) : avec cette version, Sun remplace le nom J2SE par Java SE et supprime le .0 au numéro de version. • Java SE 7 : Une des nouveautés majeures de cette version sera l’ajout des closures (en cours de spécifications). Il s’agira de la première version sous la licence GPL. • closure est un bloc de code référençable, manipulant optionnellement des variables dites "libres", libres en ce sens qu'elles sont définies non dans le bloc de code, ni de façon globale, mais par le contexte dans lequel le bloc est exécuté.

25. Caractéristiques du JAVA • Simple : plus simple que le C ou le C++ car on lui a retiré les caractéristiques peu utilisées ou difficile à utiliser : • Pointeurs. • Surcharge d'opérateurs. • Héritage multiple. • Le mécanisme de libération de la mémoire (garbage collection) est transparent contrairement au C++. • Le ramasse-miettes qui est une fonctionnalité de la JVM est appelé régulièrement et automatiquement pendant l'exécution du programme. • L'espace mémoire nécessaire à chaque objet créé est alloué dans un tas de mémoire réservé à cet usage. • Le programme peut ensuite accéder à chaque objet grâce à sa référence dans le tas. • Quand il n'existe plus aucune référence permettant d'atteindre un objet, le ramasse-miettes le détruit automatiquement puisque qu'il est devenu inaccessible libérant la mémoire et prévenant ainsi toute fuite de mémoire.

26. Mots-clés du C/C++ absent en Java Exemple de pointeurs en C #include <stdio.h> echanger (int *a, int *b) { int c; c=*a; *a=*b; *b=c; } void main() { int x=5; int y =10; printf("avant\n"); printf("%d\n",x); printf("%d\n",y); echanger (&x,&y); printf("apres\n"); printf("%d\n",x); printf("%d\n",y); } Une procédure echanger pour échanger les deux valeurs contenues dans les variables x et y.

27. Caractéristiques du JAVA • Orienté objet : l’ensemble des instructions de base a été réduit pour augmenter sa fiabilité mais donne accès à de nombreuses classes permettant de définir et de manipuler des objets. • Une classe contient des données et du code. • Le code est sous forme de fonctions ou procédures appelées méthodes. • Principe de l'encapsulation. • Distribué : les fonctions d'accès au réseau et les protocoles Internet les plus courants (HTTP, FTP, Telnet) font partie de Java. • Il est donc facile de mettre en place une architecture Client-Serveur pour travailler avec des fichiers situés sur un ordinateur distant.

28. Caractéristiques du JAVA • Robuste : le typage des données est très strict, tant à la compilation qu'à l'exécution. Les pointeurs utilisés dans Java ne sont pas accessibles au programmeur. • Sûr : L'interpréteur de java vérifie que le byte code n'a pas été altéré depuis sa compilation. Sun travaille sur un système qui permettra à terme la transmission codée des informations sur le réseau. • Dynamique : contrairement au C++, les classes de Java peuvent être modifiées sans modification du programme qui les utilise. • Indépendant des architectures matérielles : Le compilateur java fabrique du byte code "universel". Pour l'exécuter sur une machine quelconque, il faut qu'un interpréteur java (machine virtuelle) existe pour cette machine.

29. Caractéristiques du JAVA • Portable : les types de données sont indépendants de la plate-forme. • Une variable int sera toujours définie dans un entier 32 bits en complément à 2 aussi bien sur un PC 486 que sur un Power Macintosh. • Les float, double et long se conforment à la spécification IEEE754. • Les char relèvent du standard Unicode. • Les boolean prennent toujours les valeurs true et false. • Multithread : pour l'exécution simultanée de plusieurs processus. Java est fourni avec un jeu de primitives qui facilitent l'écriture de ce genre de programmes. • Haute performance : bien que java soit un langage interprété, le compilateur java génère du byte code optimisé en incluant des instructions qui permettront à chaque interpréteur de tirer la meilleure performance possible du code. La vitesse d'exécution du code peut être semblable à celle de C ou C++.

30. Terminologie : fichier JAR • Un fichier JAR (Java ARchive) est utilisé pour distribuer un ensemble de classes Java. Ce format est utilisé pour stocker des classes compilées, ainsi que des métadonnées constituant l’ensemble d’un programme (images, sons, des fichiers de paramétrages, …). • Créer un fichier Jar : jar cfv fichier.jar fichier1.class fichier2.class • Visualiser le contenu d’un fichier Jar : jar tf fichier.jar • Extraire le contenu d’un fichier Jar : jar xfv fichier.jar • Modifier un fichier Jar : jar uf fichier.jar fichier3.class • L’option c indique qu’il faut créer une archive Jar. • L’option f indique que le résultat sera redirigé dans un fichier. • L’option v fait afficher les commentaires associés à l’exécution de la commande, en particulier, les noms des éléments ajoutés au fichier d’archive au fur et à mesure qu’ils y sont ajoutés. • L’option t fait afficher le contenu de l’archive Jar. • L’option u indique qu’il faut mettre à jour une archive Jar. • L’option x indique qu’il faut extraire le contenu d'une archive Jar.

31. Terminologie : JCP et JSR • Java Community Process (JCP) est une organisation créée par Sun en 1998. • Son but est de coordonner l'évolution du langage Java et des technologies qui lui sont associées. • Le JCP s'est doté d'un processus formalisé permettant aux différentes parties intéressées d'être impliquées dans la définition des futures versions et fonctionnalités de la plateforme Java. • Le JCP émet des Java Specification Requests (JSR), qui décrivent les spécifications et technologies proposées pour un ajout à la plateforme Java. • Des revues publiques formelles des JSRs sont menées avant qu'une JSR ne devienne finale et qu'elle ne soit votée par le comité exécutif du JCP.

32. JCP et JSR • Une JSR finale fournit une implémentation de référence qui offre : • Une implémentation gratuite de la technologie sous la forme de code source. • Un ensemble de tests TCK (Technology Compatibility Kit) pour vérifier la compatibilité d'une implémentation avec la spécification. • Le JCP est composé d'entreprises du domaine Java, comme Sun, IBM, Oracle, Borland, BEA, Nokia, Sony, mais aussi de fondations du monde du logiciel libre, comme la fondation Apache ou OW2 quiregroupe des entreprises et des organismes de recherche tels que l’INRIA, Bull, France Télécom, Thales Group ou Red Hat, ainsi que de particuliers, pour lesquels l'adhésion est libre.

33. Premier programme JAVA // mon premier programme java class Prog1 { public static void main(String args[]) { System.out.println ("bonjour tous le monde"); } } Un programme JAVA est une classe qui doit être enregistrée dans un fichier de même nom et d'extension .java.

34. Lignes du programme • // introduit un commentaire. • Le programme Java comporte au moins 1 classe qui contient elle-même au moins la méthode main. • La méthode main est toujours celle qui est "lancée" à l'exécution du programme. • La seule instruction de la méthode est l'affichage d'une chaîne de caractères sur la sortie standard (l'écran) avec ajout d'un passage à la ligne : appel à la méthode println de la classe System. • Compilation puis exécution : • javac Prog1.java • java Prog1 bonjour tous le monde

35. Types primitifs en JAVA

36. Variables • Une variable est un objet repéré par son nom, pouvant contenir des données, qui pourront être modifiées lors de l'exécution du programme. • Les variables en langage Java sont typées, c'est-à-dire que les données contenues dans celles-ci possèdent un type, ainsi elles sont donc stockées à une adresse mémoire et occupent un nombre d'octets dépendant du type de donnée stockée. • La déclaration de variables : int nb; nb=8; int x=nb+2; float toto = 125.36f; System.out.println("Le nombre entier vaut : " + x + "\n"+"Le nombre reel vaut : " +toto );

37. Constantes • Une constante est une variable dont la valeur est inchangeable lors de l'exécution d'un programme. • Le mot clé final permet de définir une variable dont la valeur ne peut pas être modifiée après son initialisation. • final int d = 12; final double b = 12.6; b=b*2;

38. Conversion de type de données • Conversions implicites : • Une conversion de type implicite sans perte d'informations est réalisée d'un type primitif vers un type plus grand (élargissement) : • byte short int long float double • char int • Exemple: int i=7; double x=i;

39. Conversion de type de données • Conversion explicite : • Une conversion explicite consiste en une modification du type de donnée forcée. • Cela signifie que l'on utilise un opérateur dit de cast pour spécifier la conversion. • L'opérateur de cast est tout simplement le type de donnée, dans lequel on désire convertir une variable, entre des parenthèses précédant la variable. • Une conversion de type explicite se fait avec perte d'informations est réalisée d'un type primitif vers un type plus petit. • Exemple : double x=4.667; int i= (int) x;

40. Lire les entrées clavier import java.util.Scanner; class Prog1 { public static void main(String args[]) { Scanner sc = new Scanner (System.in); System.out.println("Veuillez saisir un mot :"); String str = sc.nextLine(); System.out.println("Vous avez saisi : " + str); System.out.println("Veuillez saisir un caractere :"); char carac = sc.nextLine().charAt(0); System.out.println("Vous avez saisi le caractère : " + carac); System.out.println("Veuillez saisir un entier :"); int x = sc.nextInt(); System.out.println("Vous avez saisi le nombre : " + x); System.out.println("Veuillez saisir un reel :"); double d = sc.nextDouble(); System.out.println("Vous avez saisi le nombre : " + d); System.out.println("Veuillez saisir un boolean :"); boolean bool=sc.nextBoolean(); System.out.println("Vous avez saisi : " + bool); } }

41. Chaînes de caractères • La classe String permet de gérer les chaînes de caractères. • La méthode length() retourne le nombre de caractères de la chaîne concernée. • String s = "java" ; • System.out.println (s.length ( ) ) ; // affiche 4 • La méthode charAt (int i) retourne le caractère d’indice i de la chaîne. • String s = "java" ; • System.out.println (s.charAt ( 2 ) ) ; // affiche v • La méthode equals (String c) retourne true si la chaîne concernée est identique à la chaîne c et false sinon. • String s = "java" ; • String t = "lundi" ; • String u = "ja" + "va" ; // Concaténation de 2 chaine s • System.out.println (s.equals ( t ) ) ; // Affiche false • System.out.println (s.equals (u ) ) ; // Affiche true

42. Chaînes de caractères • public String concat (String str) • Renvoie la chaîne, résultat de la concaténation de str à la fin d'une chaîne de caractères. • public String replace (char oldChar, char newChar) • Renvoie une chaîne où tous les caractères oldChar sont convertis en newChar. • public String toLowerCase ( ) • public String toUpperCase ( ) • Renvoie une chaîne où tous les caractères majuscules sont convertis en minuscules, et inversement. • public String trim ( ) • Renvoie une chaîne où tous espaces en tête et en queue d'une chaîne de caractères sont supprimés.

43. Opérateurs • Les opérateurs sont des symboles qui permettent de manipuler des variables. • On distingue plusieurs types d’opérateurs : • Opérateurs de calcul. • Opérateurs d’assignation. • Opérateurs d’incrémentation. • Opérateurs de comparaison. • Opérateurs logiques. • Opérateurs bit-à-bit. • Opérateurs de rotation de bit.

44. Opérateurs de calcul Permettent de modifier mathématiquement la valeur d’une variable

45. Opérateursd’assignation • Ces opérateurs permettent de simplifier des opérations telles que ajouter une valeur dans une variable et stocker le résultat dans la variable. • Exemple : • x=x+2 x+=2 • Les autres opérateurs du même type sont les suivants :

46. Opérateursd’incrémentation • Ce type d’opérateur permet de facilement augmenter ou diminuer d’une unité une variable. • Ces opérateurs sont très utiles pour des structures telles que des boucles qui ont besoin d’un compteur (variable qui augmente de un en un).

47. i++ et ++i i++ : on retourne la valeur de i et après on l’incrémente. 1 2 ++i : on incrémente la valeur de i et on la retourne. 2 2 • int i=1; • int j=i++; • System.out.println (j); • System.out.println (i); • int i=1; • int j=++i; • System.out.println (j); • System.out.println (i);

48. Opérateurs de comparaison

49. Opérateurs logiques (booléens) Ce type d’opérateur permet de vérifier si plusieurs conditions sont vraies :

50. Opérateurs bit-à-bit • Ce type d’opérateur traite ses opérandes comme des données binaires, plutôt que des données décimales, hexadécimales ou octales. • Ces opérateurs traitent ces données selon leur représentation binaire mais retournent des valeurs numériques standards dans leur format d’origine. • Les opérateurs suivants effectuent des opérations bit-à-bit, c’est-à-dire avec des bits de même poids.