Introduction à Java

1. Laurent Henocque http://laurent.henocque.free.fr/ Enseignant Chercheur ESIL/INFO France http://laurent.henocque.perso.esil.univmed.fr/ mis à jour en Février 2008 Introduction à Java

2. Licence Creative Commons Cette création est mise à disposition selon le Contrat Paternité-Partage des Conditions Initiales à l'Identique 2.0 France disponible en ligne http://creativecommons.org/licenses/by-sa/2.0/fr/ ou par courrier postal à Creative Commons, 559 Nathan Abbott Way, Stanford, California 94305, USA.

3. Avertissement • Ceci est une présentation rapide de Java • un « rapide » survol • Doit conduire à l’envie d’entamer la découverte de Java • langage en tant que tel • outil de développement graphique et d’interfaces • immense source de logiciel libre • outil « WEB » • Tout existe dans la doc en ligne grâce à Javadoc : les commentaires des sources deviennent de la documentation

4. Introduction / histoire • Origine • années 90 (SUN) • Objectifs • développer un langage de programmation portable sur toutes les plates-formes sans recompiler • développer un micro langage pour calculettes, pda, téléphones, dont les applications pourraient être téléchargées par internet • Explosion • année 95 : apparition de HotJava : « Browser » WEB capable de supporter les « applets » (ou appliquettes) Java • aujourd'hui, apparition des premières applications Java vraiment opérationnelles (Eclipse, Poséidon, jfig, produits Ilog ...)

5. Introduction • Le formidable développement de Java est dû à : • ses possibilités graphiques, d’IHM et d'interopérabilité • ses liens avec l’internet • applets: applications aux droits limités exécutées directement dans les pages html • mise en oeuvre de rmi, de corba, • notions de servlets, d'ejb • triade Java (Java Server Pages JSP)/PhP/Asp • un faux ami: javascript: langage de script de bas niveau pour pages HTML (supporté par les « browsers ») • sa gratuité • sa simplicité • les très nombreuses bibliothèques disponibles • les outils (Eclipse)

6. Java est un langage (1/4) • orienté objets • les concepts sont proches de C++, parfois empruntés à smalltalk • quelques sensibles différences avec C++ en pratique • simple • le comportement par défaut est celui qui est le plus utile • « proche » de la syntaxe du C++ • non imprégné de C • « plus de pointeur » (seulement des pointeurs), « plus de delete » • distribué • les classes où les objets invoqués peuvent l’être à travers le réseau • les fichiers peuvent être locaux ou déportés • flots à travers le réseau

7. Java est un langage (2/4) compilateur interprète Java run-times Java Virtual Machine • interprété • code source byte-code (indépendant de la machine) • byte code exécution du programme • architecture neutre • il suffit d'une machine virtuelle Java • grâce à l’Abstract Windowing Toolkit (toujours la même apparence), puis à Swing • portable • architecture neutre • spécification complète du langage (comportement arithmétique, implémentation des types, …)

8. Java est un langage (3/4) • robuste • plus simple que C++, très typé • gestion très différente de la mémoire (pointeurs, libération) • nombreux contrôles de débordement, utilisation systématique des exceptions dans les bibliothèques d'outils • sécurisé • un grand nombre de sécurités intégrées dans le langage (en particulier au niveau des applets et de la gestion mémoire) • 3 niveaux de sécurité • Verifier : vérifie le byte code. (Chaque fichier ".class" possède une marque calculée, permettant d'interdire les modifications triviales : insertion de virus par simple ajout par exemple) • Class Loader : responsable du chargement des classes. • Security Manager : accès aux ressources

9. Java est un langage (4/4) • « hautes » performances • en fonctionnalités, mais pas en vitesse d’exécution • les performances sont restaurées par la compilation "Just In Time", qui permet à la machine virtuelle de mémoriser, puis ré exécuter le code natif correspondant à une portion de boucle • « multithreaded » (éventuellement sur une machine mono-processeur) • dynamique • adapté à un environnement évolutif • interprété • lié aux design patterns par essence: • itérateurs, objets fonction, inversion de contrôle etc...

10. Java en 3 acronymes • La Java Virtual Machine (JVM) • interpréteurs (java, javaw) • Le Java Development Kit (JDK) • compilateur (javac) • visualisateur d’applets (appletviewer) • générateur de documentation Java (javadoc) • déboggeur (jdb) • générateur de méthodes C (javah) • génère les .h, la définition des classes sous forme de structures, les entêtes des méthodes) • déassembleur de classes Java (javap) • ... • Les Application Programming Interfaces (API) • le cœur de Java … • lire la doc. !

11. Un exemple • Un premier programme Java • compilation et interprétation public class HelloWorld { public static void main (String [] args) { System.out.println ("bonjour à tous") ; } } serveur:~/essai_J> javac HelloWorld.java serveur:~/essai_J> java HelloWorld boujour à tous serveur:~/essai_J>

12. Quelques points faibles • Les JVM sont par défaut plus lentes que du code natif mais: • compilation "just in time": une boucle déroulée 10000 fois n'est interprétée qu'une seule fois • Java est gourmand en mémoire mais • les options de lancement "java -X..." permettent de contrôler les tailles des différentes piles et tas : • java -Xmx32m -Xms16m -Xss16m • depuis la V5, on peut donner des directives au gestionnaire de mémoire • Certaines constructions du langage sont limitées • pas de surcharge d'opérateurs • MAIS : des compilateurs évolués pallient certains manques (on peut en les utilisant perdre la portabilité)

13. De C++ à Java en quelques différences • Pas de structures ni d’unions • Pas d'alias de types (typedef) • Pas de préprocesseur (mais on peut l'utiliser) • Pas de variables ni de fonctions en dehors des classes • Pas d'héritage multiple de classes • Pas de surcharge d’opérateurs • Pas de passage par copie pour les objets • Pas de pointeurs, seulement des références • Pas d'appel de "delete"

14. De C++ à Java en quelques différences • Les varargs sont mieux faits • Les templates s'appellent generics, et sont différents • Java propose une syntaxe avancée pour la boucle for • Java permet la conversion automatique des types de base vers des objets (wrapping ou boxing/unboxing) • Les enums sont typés • Java permet d'attacher au code des annotations • Voir en particulier http://java.sun.com/j2se/1.5.0/docs/relnotes/features.html • Java a beaucoup évolué depuis la version 5 (Tiger)

15. Les bases de Java

16. Bases de Java : code • Java supporte un code source écrit en Unicode • Code sur 16 bits (7 ou 8 bits pour nos codes usuels) • un caractère Java est sur 16 bits • Permet • tous les caractères altérés • les langages comme • chinois • japonais • … • Les 256 premiers caractères sont nos caractères habituels • Codes utilisables partout dans le programme

17. Bases de Java : organisation • Hiérarchie imposée • Conséquence : • chaque désignation complète est de la forme : package.class.designation Il existe un paquetage sans nom par défaut Le paquetage (package) Les classes Les champs (membres C++) Les méthodes (fonctions membres C++)

18. Bases de Java : organisation Organisation pratique en fichiers (1/2) • un package= un dossier • pas de séparation entre la définition et l’implémentation d’une classe: on oublie les .h... • une classe publique (MaClasse) par fichier (MaClasse.java) • Le compilateur crée au moins un fichier objet (MaClasse.class) par fichier source • Un programme Java exécutable comprend au moins une classe ayant une méthode déclarée : public static void main(String argv[]) • public : pour pouvoir être utilisée partout • static : méthode de classe, non liée à un objet

19. Bases de Java : organisation Organisation pratique en fichiers (2/2) • import permet de rendre disponible une classe ou un paquetage pour simplifier les désignations • remarques : 1) Plusieurs syntaxes 2) Possibilité d’importer à travers le réseau • Variable d’environnement CLASSPATH • Argument -classpath de l’interpréteur • pour préciser les chemins d’accès • toute ressource utilisée par un programme doit être accessible via le "classpath" import monpaquetage ; // je peux maintenant utiliser directement maclasse au lieu de monpaquetage.maclasse maclasse objet1 ; monpaquetage.maclasse objet2 ;

20. Eléments du langage • Commentaires: comme C, plus javadoc /** ceci est un commentaire très particulier qui sera utilisé par javadoc du JDK pour générer automatiquement la doc (à lire !) en ligne */ x = y ; // ceci est un commentaire qui va jusqu’a la fin de la ligne // c’est aussi un commentaire /* cela marche aussi mais pas de mélange SVP */ • syntaxe habituelle pour les commentaires plus /** … */

21. Types • Les types sont : • Des types de base prédéfinis (boolean, char, byte, short, int, long, float, double) • Des versions "wrappées" (par des classes) de ces types de base (BigDecimal, BigInteger, Byte, Double, Float, Integer, Long, Short) • Les classes déclarées par le programme • Transtypage • il peut être • implicite • explicite (syntaxe du C) • Il est requis pour les spécialisations explicites, comme en C++ int i = 1 ; double x = 6.28 ; x = (float) i ;

22. Eléments du langage • Les constantes • tout identificateur d’une classe déclaré final est une constante static final int c1 = 12 ; public final float c2 = 1.2 ; • Création d’un objet MaClasse mon_objet ; // ne fait que déclarer une référence // par défaut initialisée à null mon_objet = new MaClasse () ; // mon_objet fait effectivement référence à un objet MaClasse mon_objetbis = new MaClasse () ; // le constructeur de MaClasse peut ne pas avoir de paramètres mon_objetbis = mon_objet ; // référence à un même objet mais pas copie de l’objet // Pour réaliser une copie : utiliser la méthode clone de tout objet mon_objetbis = mon_objet.clone () ;

23. Eléments du langage • Les opérateurs = et == appliqués à deux variables s’appliquent à des références et non aux objets référencés ! • pour = (copie) utiliser la méthode clone () (prédéfinie ou à définir) • pour == (comparaison) utiliser la méthode equals () (prédéfinie ou à définir) • Les chaînes de caractères • des chaînes constantes : classe String • des chaînes modifiables : classe StringBuffer • lire la doc. !

24. Eléments du langage • Les tableaux • suite d’objets de même type • les éléments sont d’un type prédéfini ou des références sur des objets • doivent être déclarés, créés, voire initialisés • sont des références // déclaration int[] array_of_int; // équivalent à : int array_of_int[]; Color rgb_cube[][][]; // création et initialisation array_of_int = new int [42] ; rgb_cube = new Color [256] [256] [256] ; // utilisation int longueur = array_of_int.length; // longueur = 42 int e = array_of_int[50]; // en dehors du tableau : lève une exception

25. Initialisation de tableaux • Java permet de construire un tableau lors de sa déclaration ou de son allocation, en fournissant une liste d'initialisation • Java connaît la longueur des tableaux, et celle ci est calculée automatiquement int[] dims={2,3,4}; String [] noms = {"toto","tata","tutu"}; A [] tabA={newA(1), new A(2)}; int i = dims.length; // la longueur du tableau

26. Eléments du langage • Structures de contrôle • Comme en C++ : for , while ... • Plus génial!: break et continue désignés boucle1 : while (...) { boucle2 : for (...) { boucle3 : while (...) { if (...) continue boucle1 ; // reprend sur la première boucle while if (...) break boucle2 ; // quitte la boucle for continue ; // reprend sur la deuxième boucle while … // instructions jamais atteintes } } }

27. Eléments du langage • varargs et la boucle "for" : énumération implicite d'une collection • write("line 1"); • write("line 2", "line 3"); • write("line 4", "line 5", "line 6", "line 7", "line 8", "line 9", "line 10"); public void write(String... records) { for (String record: records) System.out.println(record); }

28. Eléments du langage : Gestion mémoire • Allocation • new: retourne une "strong reference" • Libération • la libération de la mémoire est automatique et est gérée par un processus appelé garbage collector (= ramasseur de déchets ) qui détecte les objets sans référence • ce processus fonctionne en tâche de fond de faible priorité, dans un thread parallèle, mais peut être déclenché explicitement (méthode System.gc () ) • ne peut libérer que la mémoire allouée par Java • ne peut pas tout libérer malgré tout

29. Gestion de la mémoire • Plusieurs types de références, en plus de la référence "strong" • weakReference (n'empêche pas le gc s'il n'y a plus de strong ref) • softReference (comme weak, mais l'objet dure tant que la mémoire le permet) • utile pour mettre en œuvre des caches • phantomReference (permet de savoir quand un objet a été détruit). C'est une alternative saine à la redéfinition de "finalize"

30. Weak References • Illustration du problème des références. Cette structure de données associe une information à un Socket, au caractère volatile. • Que se passe t'il quand un socket disparaît? • (d'après http://www-128.ibm.com/developerworks/java/library/j-jtp11225/)

31. La fuite de mémoire en action • (d'après http://www-128.ibm.com/developerworks/java/library/j-jtp11225/)

32. Comportement du GC et utilisation de mémoire • (d'après http://www-128.ibm.com/developerworks/java/library/j-jtp11225/)

33. Solution: utiliser WeakHashMap à la place de HashMap: intuition du code • (d'après http://www-128.ibm.com/developerworks/java/library/j-jtp11225/)

34. Mots clés significativement différents de C++ consulter : http://www.cs.umb.edu/java/keywords • abstract méthode sans implantation/ classe en contenant • byte char signé • default utilisé comme échappement dans un switch • finally utilisé comme échappement dans un try • final pour une classe : pas d'héritage possible • final méthode : pas de redéfinition possible • final champ : traité comme une constante • instanceof test d'appartenance à classe • native déclare une méthode implantée en C/C++ • null la référence vide • super la superclasse • synchronized empêche l'accès simultané à un objet • volatile déclare un champ partagé et évite des optimisations abusives (suppression d'une variable par le compilateur, qui ne voit pas qu' elle est utilisée)

35. Les concepts des langages de classes ; implémentation en Java

36. Les classes • La classe est l’élément de base de Java. Tout est classe sauf les types primitifs (int, float, double, ...) et les tableaux • Il n’y a pas de fonctions, seulement des méthodes • Toutes les classes dérivent d'une superclasse commune java.lang.Object • L'objet support des méthodes est appelé : this • this est une référence sur l’objet manipulé this.champ

37. Déclaration d'une classe et de ses constructeurs class Point [extends Object]{ private float x=(float) 0.0; private float y=(float) 0.0; public Point(float x, float y){ this.x=x; this.y=y; } public Point(){ this((float)5.0, (float)2.3); } }

38. La classe Object • Object() Constructor • protected Object clone() • crée et retourne une copie de l'objet. • boolean equals(Object obj) • permet de comparer deux objets (requis pour les tables de hash code). • protected void finalize() • appelé par le garbage collector avant la récupération de l'esapce occupé par l'objet. • Class getClass() • renvoie la classe d'un objet • int hashCode() • renvoie la clé de hash code associée à l'objet • void notify() • réveille un thread bloqué sur cet objet. • void notifyAll() • réveille tous les threads en attente pour cet objet. • String toString() • retourne une chaîne de caractère. Utilisée par la jvm pour toutes les conversions en chaînes • void wait() • bloque un thread sur cet objet, en attendant qu'un autre appelle notify()

39. La classe "Class" public final class Class extends Object implements Serializable • Les classes sont construites par la JVM automatiquement, et sur appel de defineClass dans un class loader. void printClassName(Object boo) { System.out.println("La classe de " + boo + " est " + boo.getClass().getName()); } • La formulation suivante s'applique aussi à un type de base System.out.println("Le nom de classe de Boo est : "+Boo.class.getName());

40. Méthodes statiques de Class • static Class forName(String className) • renvoie l'objet Class d'un nom donné • Class t = Class.forName("java.lang.Thread") • static Class forName(String name, boolean initialize, ClassLoader loader) • pareil, mais en utilisant un class loader particulier, avec l'option d'initialiser ou non la classe désignée • La possibilité de charger dynamiquement une classe en Java, est à la base de possibilités d'utilisation extrêmement flexibles du langage. • Par exemple, un programme peut générer le source java d'une classe, invoquer le compilateur sur ce source, puis charger dynamiquement la classe avec la fonction "forName" pour enfin en créer des instances et appeler n'importe laquelle de ses fonctions : par exemple "main" dans Eclipse • Ce n'est possible en C++ qu'au prix de grandes difficultés (utilisation d'édition de liens dynamique (voir "ld")), sachant qu'on ne pourra de toutes façons appeler sur un objet que des méthodes déjà connues (par exemple des fonctions virtuelles définies pour une classe compilée statiquement)

41. Méthodes de Class • String getName() • le nom • Package getPackage() • le package • int getModifiers() • un int contenant des booléens pour public, static etc... • Class getSuperclass() • la superclasse • Class[] getInterfaces() • retourne les interfaces implantées par la classe • Class[] getClasses() • tableau de toutes les classes et interfaces publiques membres de cette classe • Class[] getDeclaredClasses() • tableau de toutes les classes et interfaces membres. • Class getDeclaringClass() • retourne la classe dont on est membre (éventuellement)

42. Accesseurs de Class • boolean isAssignableFrom(Class cls) • est ce que cls est une sous classe? • boolean isInstance(Object obj) • est ce que obj est une instance de cette classe • boolean isInterface() • interface?. • boolean isPrimitive() • type primitif? (int, void, etc...) • boolean isArray() • un tableau? • Class getComponentType() • le type des composants d'un "array".

43. Accès aux constructeurs • Constructor getConstructor(Class[] parameterTypes) • Constructor[] getConstructors() • Constructor getDeclaredConstructor(Class[] parameterTypes) • Constructor[] getDeclaredConstructors() • retournent les constructeurs publics, ou déclarés • Object newInstance() • crée une nouvelle instance

44. Accès aux membres • Field getDeclaredField(String name) • Field[] getDeclaredFields() • Field getField(String name) • Field[] getFields() • retournent les champs de la classe publics ou non • Method getDeclaredMethod(String name, Class[] parameterTypes) • Method[] getDeclaredMethods() • Method getMethod(String name, Class[] parameterTypes) • Method[] getMethods() • retournent les méthodes

45. Class: fonctions diverses • ClassLoader getClassLoader() • le chargeur de cette classe. • ProtectionDomain getProtectionDomain() • le domaine de protection de cette classe. • URL getResource(String name) • trouve une ressource de nom donné (les ressources sont tous les fichiers de paramètres, ou de données accessibles dans le classPath). • InputStream getResourceAsStream(String name) • id, mais renvoie directement un flux d'entrée sur cette ressource, prêt à en lire le contenu. • Object[] getSigners() • renvoie les "signers" de la classe - certificats d'authenticité-. • boolean desiredAssertionStatus() • renvoie le statut par défaut pour assert de la classe (les assertions peuvent être contrôlées sur une base "classe par classe")

46. Interfaces • Une classe ne contenant pas de données peut être déclarée comme interface public interface ... { ... } • Les interfaces n'ayant pas de données, elles servent juste à définir des interfaces de programmation (d’où leur nom), souvent encore appelées "protocoles". • On appelle une interface de programmation un protocole quand les appels possibles sont régis par un automate (par exemple, on ne peut appeler "dépile()" sur une pile vide)

47. Classes abstraites • Une classe contenant des méthodes abstraites doit être déclarée abstract public abstract class ... { ... public abstract void foo(); } • C++ ne prévoit pas cette déclaration, toute classe contenant une méthode définie par zéro (f()=0;) étant abstraite par nature • Aucun constructeur d'une classe abstraite ne peut être appelé explicitement.

48. Héritage • Au niveau des classes seul l’héritage simple est possible class B extends A { …} • L'héritage multiple des interfaces est possible class B extends A implements I1, I2 {...} • Il ne doit pas y avoir de conflit dans les noms de fonctions apportés par la classe héritée et les différentes interfaces. Java ne propose aucun mécanisme de désambiguïsation à ce propos (comme la syntaxe A::f() de C++) • Toute classe Java (sauf Object) possède exactement une superclasse (qui est Object par défaut), ce qui permet à Java d'introduire le mot clé "super" pour désigner cette superclasse

49. Les classes : masquage • Masquage de l’information • Pour les classes • public : visible de partout • par défaut : visibilité limitée au paquetage • Pour les champs et les méthodes, il s’effectue à 3 niveaux • public: accès illimité • protected : accès réservé aux sous classes • private : accès réservé à la classe • à préciser pour chaque champ et chaque méthode • Attention, comme en C++, protection au niveau de la classe, pas de l’objet

50. Les classes : constructeurs Les constructeurs (1/2) • Le constructeur par défaut • Des constructeurs avec des listes de paramètres différentes • Un cas particulier intéressant Class Maclasse { public Maclasse ( … première liste de paramètres … ) { … } public Maclasse ( … deuxième liste de paramètres … ) { … } public Maclasse () { // appel d’un autre constructeur. Le constructeur appelé // dépend de la concordance des arguments - paramètres this (une liste de paramètres) ; } }