Language java

958 vues

Publié le

Slides du cours: Programmation en utilisant le langage JAVA.

Publié dans : Logiciels
0 commentaire
0 j’aime
Statistiques
Remarques
  • Soyez le premier à commenter

  • Soyez le premier à aimer ceci

Aucun téléchargement
Vues
Nombre de vues
958
Sur SlideShare
0
Issues des intégrations
0
Intégrations
13
Actions
Partages
0
Téléchargements
70
Commentaires
0
J’aime
0
Intégrations 0
Aucune incorporation

Aucune remarque pour cette diapositive
  • 1
  • 2
  • Language java

    1. 1. KACIMI Lamine / 20141 Programmation en JAVA
    2. 2. KACIMI Lamine / 20142 Sommaire I. Introduction II. Historique III. Structure d’un programme JAVA IV. Types primitifs, Opérateurs & Expressions V. Enoncés conditionnels & Itératifs VI. Les classes et les objets VII. Tableaux VIII. Héritage IX. Classes abstraites & Interfaces X. Collections XI. Chaînes de caractères & Types énumérés XII. Les Exceptions
    3. 3. KACIMI Lamine / 20143 Définition Généralités Définition de SUN : "Java est un langage simple, orienté objet, distribué, robuste, sûr, indépendant des architectures matérielles, portable, de haute performance, multithread et dynamique"
    4. 4. KACIMI Lamine / 20144 1. Simple 1. Pas de pointeurs 2. Pas d’héritage multiple 2. Distribué: Les fonctions d'accès au réseau et les protocoles internet les plus courants sont intégrés 1. Sockets 2. RMI 3. Portable: Les types de données sont indépendants de la plate forme 4. Robuste: pas d’arithmétiques pointeurs, typage strict Caractéristiques Généralités
    5. 5. KACIMI Lamine / 20145 5. Multithread Une application peut être décomposée en unités d'exécution fonctionnant simultanément 6. Dynamique: Les classes peuvent être modifiées sans pour autant modifier les programmes qui les utilisent. 7. Performance ?: Oui grâce aux améliorations successives dont la JVM a bénéficiée mais aussi grâce à l’amélioration des API Caractéristiques…suite Généralités
    6. 6. KACIMI Lamine / 20146 Historique Historique Année Evénements 1995 mai : premier lancement commercial du JDK 1.0 1996 janvier : JDK 1.0.1 1997 février : JDK 1.1 1998 décembre : lancement de J2SE 1.2 et lancement du JDC (Java Community Process) 1999 décembre : lancement J2EE 2000 mai : J2SE 1.3 2002 février : J2SE 1.4 2004 septembre : J2SE 5.0 2006 mai : Java EE 5 décembre : Java SE 6.0 2008 décembre : Java FX 1.0 2009 décembre : Java EE 6 2010 janvier : rachat de Sun par Oracle 2011 juillet : Java SE 7 2013 Juin: Lancement de JEE 7 2014 Mars: Java SE 8 https://jcp.org/en/participation/mail
    7. 7. KACIMI Lamine / 20147 Versions Versions Version Nom du projet Date de diffusion JDK 1.0 Oak Mai 1995 JDK 1.1 Février 1997 JDK 1.1.4 Sparkler Septembre 1997 JDK 1.1.5 Pumpkin Décembre 1997 JDK 1.1.6 Abigail Avril 1998 JDK 1.1.7 Brutus Septembre 1998 JDK 1.1.8 Chelsea Avril 1999 J2SE 1.2 Playground Décembre 1998 J2SE 1.2.1 Mars 1999 J2SE 1.2.2 Cricket Juillet 1999 J2SE 1.3 Kestrel Mai 2000 J2SE 1.3.1 Ladybird Mai 2001 J2SE 1.4.0 Merlin Février 2002 J2SE 1.4.1 Hopper Septembre 2002 J2SE 1.4.2 Mantis Juin, 2003 J2SE 5.0 (1.5) Tiger Septembre 2004 Java SE 6.0 (1.6) Mustang Décembre 2006 Java SE 7 (1.7) Dolphin Juillet 2011
    8. 8. KACIMI Lamine / 20148 Versions/Nombre de Classes Versions/Classes Java 1.0 Java 1.1 Java 1.2 J2SE 1.3 J2SE 1.4 J2SE 5.0 Java SE 6 Java SE 7 Packages 8 23 59 76 135 166 202 209 Classes 201 503 1520 1840 2990 3280 3780 4024
    9. 9. KACIMI Lamine / 20149 Editions Java & Outils de développement Généralités 1.Les environnements JAVA • Java SE (Standard Edition) • Java ME (Mobile, Micro Edition) • Java EE (Enterprise Edition) • Java FX (Enterprise Edition) 2. Les IDE •Visual J++ (Microsoft) •JBuilder (Borland/Inprise) •Eclipse •Netbeans
    10. 10. KACIMI Lamine / 201410 Que peut-on faire avec Java Généralités 1. Applications (Console, desktop) 2. Applets (pour le web) 3. Applications /Sites Web 4. Applications embarquées 5.…..tout!
    11. 11. KACIMI Lamine / 201411 Génération du code exécutableGénérationExécutable/Non JAVA
    12. 12. KACIMI Lamine / 201412 Génération du code exécutable GénérationExécutable/JAVA
    13. 13. KACIMI Lamine / 201413 Principe de la machine virtuelle Machinevirtuelle/Principe
    14. 14. KACIMI Lamine / 201414 Structure d’un programme JAVAUnpremierProgrammeou plutôtdeux
    15. 15. KACIMI Lamine / 201415 JAVA, les types primitifs JAVA,lestypesprimitifs Les types primitifs de Java se répartissent en quatre grandes catégories selon la nature des informations qu’ils permettent de représenter : • nombres entiers, • nombres flottants, • caractères, • booléens.
    16. 16. KACIMI Lamine / 201416 JAVA, Types entiers JAVA,lestypesentiers Valeur décimale Valeur binaire Valeur Hexadécimale 1 0000000000000001 0001 2 0000000000000010 0002 3 0000000000000011 0003 16 0000000000010000 00F0 127 0000000001111111 007F 255 0000000011111111 00FF -1 1111111111111111 FFFF -256 1111111100000000 FF00
    17. 17. KACIMI Lamine / 201417 JAVA, Types flottants JAVA,lestypesflottants n= 1.5 ∗ 1018 1.5: mantisse 18 : exposant Notation générale n≈ 𝑠𝑀. 10 𝑛
    18. 18. KACIMI Lamine / 201418 JAVA, Types flottants: ExempleJAVA,lestypesflottants. Exemple
    19. 19. KACIMI Lamine / 201419 JAVA, Types flottants: ConséquenceJAVA,lestypesflottants. Conséquence Valeur décimale Représentation en float 0.9 0.09 0.009 0.0009 0.00009 0.000009 9E-7 9E-8 9E-9 9E-10 0.9 0.089999996 0.0090 9.0E-4 9.0E-5 9.0E-6 9.0000003E-7 9.0E-8 9.0E-9 8.9999996E-10
    20. 20. KACIMI Lamine / 201420 JAVA, Types flottants JAVA,lestypesflottants. Le tableau suivant récapitule les caractéristiques des types float et double. Notez ici encore l’existence de constantes prédéfinies de la forme Float.MAX_VALUE qui fournissent les différentes limites.
    21. 21. KACIMI Lamine / 201421 JAVA, Type Caractère JAVA,letypecaractère. Comme la plupart des langages, Java permet de manipuler des caractères. Mais il offre l’originalité de les représenter en mémoire sur deux octets en utilisant le code universel Unicode
    22. 22. KACIMI Lamine / 201422 JAVA, Type booléen JAVA,letypebooléen. Ce type sert à représenter une valeur logique du type vrai/faux. Il n’existe pas dans tous les langages car il n’est pas aussi indispensable que les autres. En effet, on peut souvent se contenter d’expressions booléennes du genre de celles qu’on utilise dans une instruction if: if (n<p) ..... // n<p est une expression booléenne valant vrai ou faux En Java, on peut disposer de variables de ce type, ce qui permettra des affectations telles que : boolean ordonne ; // déclaration d’une variable de type booléen ..... ordonne = n<p ; // ordonne reçoit la valeur de l’expression booléenne n<p Les deux constantes du type booléen se notent true et false
    23. 23. KACIMI Lamine / 201423 JAVA, Constantes, le mot clé final JAVA,Déclareruneconstante. Java permet de déclarer que la valeur d’une variable ne doit pas être modifiée pendant l’exécution du programme. Par exemple, avec : on déclare la variable cst de type int, de valeur initiale 20. De plus, toute tentative ultérieure de modification de la valeur de n sera rejetée par le compilateur :
    24. 24. KACIMI Lamine / 201424 JAVA, Opérateurs & Expressions JAVA,Opérateurs&Expressions 1. Les opérateurs arithmétiques Opérateur Signification + Addition - Soustraction * Multiplication / Division % Modulo 2. Les opérateurs relationnels Opérateur Signification < Inférieur à <= Inférieur ou égal à > Supérieur à >= Supérieur ou égal à == Égal à != Différent de
    25. 25. KACIMI Lamine / 201425 JAVA, Opérateurs & Expressions JAVA,Opérateurs&Expressions 3. Les opérateurs logiques Opérateur Signification ! Non && Et logique || Ou logique 4. Les opérateurs bit à bit Opérateur Signification & Et bit à bit | Ou bit à bit ^ Ou exclusif bit à bit >>, <<, >>> Décalage 5. Autres opérateurs, Casting, instanceof et Opérateur conditionnel
    26. 26. KACIMI Lamine / 201426 JAVA, Instructions de contrôle JAVA,InstructionsdeContrôle A priori, dans un programme, les instructions sont exécutées séquentiellement, c’est-à-dire dans l’ordre où elles apparaissent. Or la puissance et le comportement intelligent d’un programme proviennent essentiellement de la possibilité de s’affranchir de cet ordre pour effectuer des choix et des boucles (répétitions). Tous les langages disposent d’instructions, nommées instructions de contrôle, permettant de les réaliser.
    27. 27. KACIMI Lamine / 201427 JAVA, Instructions de contrôle JAVA,InstructionsdeContrôle 1. Les choix (if, else et switch) 2. Les boucles (while, for et do …. while) 3. Les branchements inconditionnels: continue, break
    28. 28. KACIMI Lamine / 201428 JAVA, L’instruction if JAVA,L’Instructionif If Imbriqué
    29. 29. KACIMI Lamine / 201429 JAVA, L’instruction if. Exemple completJAVA,L’Instructionif.Exemple complet
    30. 30. KACIMI Lamine / 201430 JAVA, L’instruction switch JAVA,L’Instructionswitch
    31. 31. KACIMI Lamine / 201431 JAVA, Les instructions do… while et whileJAVA,Lesinstructionsdo… whileetwhile do … while while
    32. 32. KACIMI Lamine / 201432 JAVA, L’instruction for JAVA,L’Instructionfor Le JDK 5.0 a introduit une nouvelle structure de boucle souvent nommée for... each Elle ne s’applique toutefois qu’au parcours des éléments d’une collection, d’un tableau ou d’une chaîne et nous vous la présenterons par la suite dans ces différents contextes.
    33. 33. KACIMI Lamine / 201433 JAVA, Les instructions break et continueJAVA,Lesinstructionsbreaket continue L’instruction break dite ordinaire permet de sortir d’une boucle ou comme on l’a déjà vu d’un switch. Pour sortir de 2 boucles imbriquées, on utilisera toujours break mais avec une étiquette cette fois-ci. L’instruction continue permet de passer prématurément au tour de boucle suivant. Pensez par exemple à l’utiliser pour calculer la somme des nombre pairs inférieurs à 540.
    34. 34. KACIMI Lamine / 201434 JAVA, Les classes et les objets JAVA,Lesclassesetlesobjets 1. Notion de classe 2. Instanciation des objets 3. Notion de référence à un objet 4. Différence entre types primitifs et types objets 5. Notion de constructeur 6. Champs et méthodes d’objet vs Champs et méthodes de classe 7. Notion de paquetage
    35. 35. KACIMI Lamine / 201435 JAVA, Classe PointJAVA,Unepremièreclasse:La classePoint Nous supposerons ici qu’un objet de type Point sera représenté par deux coordonnées entières. Ils nous suffira de les déclarer ainsi :
    36. 36. KACIMI Lamine / 201436 JAVA, Classe Point: Ajout de méthodesJAVA,LassePoint,ajoutde méthodes Méthode: • Nom de la méthode • Mode (niveau ) d’accès • Arguments • Type de la valeur de retour
    37. 37. KACIMI Lamine / 201437 JAVA, Utiliser la classe Point JAVA,UtiliserlaclassePoint
    38. 38. KACIMI Lamine / 201438 JAVA, Notion de constructeur JAVA,Notiondeconstructeur Dans la définition de la classe Point, nous n’avons défini aucun constructeur, dans un tel cas, Java nous fournit un constructeur par défaut, sans paramètres. Un constructeur n’est qu’une méthode sans type de retour.
    39. 39. KACIMI Lamine / 201439 JAVA, Initialisation des attributs d’un objetJAVA,Initialisationdesattributs d’unobjet Il est également possible d’initialiser les attributs d’un objet à la déclaration.
    40. 40. KACIMI Lamine / 201440 JAVA, Eléments de conception des classes JAVA,Elémentsdeconception desclasses 1. Encapsuler les attributs: l’extérieur n’a pas à connaître ces attributs ni le corps des méthodes. L’extérieur utilisera uniquement l’interface de la classe. 2. Typologies des méthodes: a) Méthodes d’accès: getters b) Méthodes d’altération: setters c) Méthodes métier
    41. 41. KACIMI Lamine / 201441 JAVA, Eléments de conception des classes JAVA,Elémentsdeconception desclasses a et b désignent le même objet
    42. 42. KACIMI Lamine / 201442 JAVA, la notion de clone JAVA,lanotiondeclone Nous venons de voir que l’affectation de variables de type objet se limite à la recopie de références. Elle ne provoque pas la recopie de la valeur des objets. NB: On peut toujours utiliser les opérateurs logiques avec les objets, mais ceux-là ne porteront pas sur les objets mais plutôt sur leurs références.
    43. 43. KACIMI Lamine / 201443 JAVA, Attributs et méthodes de classeJAVA,Attributsetméthodesde classe En Java, on peut définir des champs qui, au lieu d’exister dans chacune des instances de la classe, n’existent qu’en un seul exemplaire pour toutes les instances d’une même classe. Il s’agit en quelque sorte de données globales partagées par toutes les instances d’une même classe. On parle alors de champs de classe ou de champs statiques. De même, on peut définir des méthodes de classe (ou statiques) qui peuvent être appelées indépendamment de tout objet de la classe (c’est le cas de la méthode main ).
    44. 44. KACIMI Lamine / 201444 JAVA, Attributs et méthodes de classeJAVA,Attributsetméthodesde classe Les méthodes statiques ne sont donc liées à aucun objet, leur implémentation ne peut pas faire référence à this. Exercice: Dans la classe Point, définissez une méthode de classe qui renvoie le point origine (0,0)
    45. 45. KACIMI Lamine / 201445 JAVA, Surdéfinition de méthodesJAVA,Surdéfinitionde méthodes 1. a+b (a et b entiers) vs s+t (s et t String) 2. Une classe peut définir la même méthode plusieurs fois mais avec des signatures différentes.
    46. 46. KACIMI Lamine / 201446 JAVA, Passage de paramètres JAVA,Passagedeparamètres En Java, la transmission d’un argument à une méthode et celle de son résultat ont toujours lieu par valeur. Comme pour l’affectation, les conséquences en seront totalement différentes, selon que l’on a affaire à une valeur d’un type primitif ou d’un type classe.
    47. 47. KACIMI Lamine / 201447 JAVA, La récursivité JAVA,Larécursivité Java autorise la récursivité des appels de méthodes. Celle-ci peut être : • directe : une méthode comporte, dans sa définition, au moins un appel à elle-même ; • croisée : l’appel d’une méthode entraîne l’appel d’une autre méthode qui, à son tour, appelle la méthode initiale (le cycle pouvant d’ailleurs faire intervenir plus de deux méthodes). Exercice: Ajouter une méthode, qui calcule la factorielle récursivement, à la classe Util précédente. Essayer ensuite de l’implémenter en utilisant les itérations classiques.
    48. 48. KACIMI Lamine / 201448 JAVA, Les objets membres JAVA,Lesobjetsmembres Comme nous l’avons souligné à plusieurs reprises, les champs d’une classe sont soit d’un type primitif, soit des références à des objets. Dans le second cas, on parle souvent d’objet membre pour caractériser cette situation. Les méthodes de la classe Cercle peuvent évoquer les méthodes de la classe Point en utilisant l’objet membre c. Compléter l’implémentation
    49. 49. KACIMI Lamine / 201449 JAVA, Les classes internes JAVA,Lesclassesinternes Une classe est dite interne lorsque sa définition est située à l’intérieur de la définition d’une autre classe. Malgré certaines ressemblances avec la notion d’objet membre étudiée ci-dessus, elle ne doit surtout pas être confondue avec elle, même s’il est possible de l’utiliser dans ce contexte.
    50. 50. KACIMI Lamine / 201450 JAVA, Les classes internes, intérêtsJAVA,Lesclassesinternes, intérêts On peut se demander en quoi les situations précédentes diffèrent d’une définition de I qui serait externe à celle de E. 3 propriétés particulières: 1. Un objet d’une classe interne est toujours associé, au moment de son instanciation, à un objet d’un classe externe dont on dit qu’il lui a donné naissance. 2. Un objet d’une classe interne a toujours accès aux champs et méthodes (même privés) de l’objet externe lui ayant donné naissance (attention : ici, il s’agit bien d’un accès restreint à l’objet, et non à tous les objets de cette classe). 3. Un objet de classe externe a toujours accès aux champs et méthodes (même privés) d’un objet d’une classe interne auquel il a donné naissance. Exercice: recréer la classe Cercle en utilisant une classe interne Centre qui représentera son centre.
    51. 51. KACIMI Lamine / 201451 JAVA, Les classes internes JAVA,Lesclassesinternes 1. Il est possible de créer une instance de la classe interne depuis l’extérieur. 2. JAVA permet la définition d’une classe interne à l’intérieur d’une méthode, seule cette méthode est dans la mesure de l’instancier. 3. Il est possible de déclarer la classe interne comme statique; auquel cas, elle n’aura accès qu’aux membres statiques de la classe externe.
    52. 52. KACIMI Lamine / 201452 JAVA, Les paquetages JAVA,Lespaquetages La notion de paquetage correspond à un regroupement logique sous un identificateur commun d’un ensemble de classes. Elle est proche de la notion de bibliothèque que l’on rencontre dans d’autres langages. Elle facilite le développement et la cohabitation de logiciels conséquents en permettant de répartir les classes correspondantes dans différents paquetages. Le risque de créer deux classes de même nom se trouve alors limité aux seules classes d’un même paquetage.
    53. 53. KACIMI Lamine / 201453 JAVA, Les paquetages JAVA,Lespaquetages L’attribution d’un nom de paquetage se fait au niveau du fichier source. Toutes les classes d’un même fichier source appartiendront donc toujours à un même paquetage. Pour ce faire, on place, en début de fichier, une instruction de la forme : Pour utiliser une classe définie dans un paquetage autre que le paquetage courant, on utilisera l’instruction import. On peut également qualifier la classe en spécifiant son paquetage. On peut également importer toutes les classes du paquetage en utilisant import nompaquetage.*
    54. 54. KACIMI Lamine / 201454 JAVA, Les tableaux JAVA,Lestableaux En programmation, on parle de tableau pour désigner un ensemble d’éléments de même type désignés par un nom unique, chaque élément étant repéré par un indice précisant sa position au sein de l’ensemble. 1. Déclarer un tableau 2. Créer un tableau 3. Utiliser un tableau 4. Passage de paramètre tableau 5. La notion d’ellipse
    55. 55. KACIMI Lamine / 201455 JAVA, Déclaration et création de tableaux JAVA,Déclarationetcréation detableaux Le tableau peut être initialisé dès sa déclaration en utilisant:
    56. 56. KACIMI Lamine / 201456 JAVA, Utilisation de tableaux JAVA,Utilisationdetableaux En Java, on peut utiliser un tableau de deux façons différentes : • en accédant individuellement à chacun de ses éléments, avec un indice • en accédant globalement à l’ensemble du tableau. Pour changer la référence du tableau et le faire pointer vers un autre On peut toujours récupérer la taille d’un tableau en utilisant l’attribut length de celui-ci. NB: On peut également déclarer un tableau d’objets, essayer avec un tableau d’objets de la classe Cercle Il existe également une variante de la boucle for souhaitable pour parcourir les éléments d’un tableau.
    57. 57. KACIMI Lamine / 201457 JAVA, Tableaux en argument et en retourJAVA,Tableauxenargumentet enretour Les tableaux java étant des objets, les remarques faites concernant le passage d’objets en argument et leur récupération s’appliquent également pour les tableaux.
    58. 58. KACIMI Lamine / 201458 JAVA, Tableaux à plusieurs indicesJAVA,Tableauxàplusieurs indices De nombreux langages disposent de la notion de tableau à plusieurs indices. Par exemple, un tableau à deux indices permet de représenter une matrice mathématique. Java ne dispose pas d’une telle notion. Néanmoins, il permet de la "simuler" en créant des tableaux de tableaux
    59. 59. KACIMI Lamine / 201459 JAVA, Arguments variables JAVA,Argumentsvariables Depuis le JDK 5.0, on peut définir une méthode dont le nombre d’arguments est variable. Par exemple, si l’on définit une méthode somme avec l’en-tête suivant : On pourra l’appeler avec 0, 1 ou plusieurs paramètres La notation … se nomme ellipse
    60. 60. KACIMI Lamine / 201460 JAVA, L’héritage JAVA,L’héritage L’héritage est à l’origine des possibilités de réutilisation des composants logiciels que sont les classes. 1. Notion d’héritage 2. Droits d’accès 3. Construction et initialisation des objets des classes dérivées 4. Redéfinition de méthodes vs Surdéfinition 5. Notion de polymorphisme
    61. 61. KACIMI Lamine / 201461 JAVA, Notion d’héritage JAVA,Notiond’héritage Imaginons que nous ayons besoin d’une classe PointColore, destinée à manipuler des points colorés d’un plan Il est clair que un point coloré est en fait un point à la base, Il est donc légitime de penser à dériver la classe Point pour créer PointColore D’une manière générale, un objet d’une classe dérivée accède aux membres publics de sa classe de base, exactement comme s’ils étaient définis dans la classe dérivée elle-même.
    62. 62. KACIMI Lamine / 201462 JAVA, Héritage et droits d’accèsJAVA,Héritageetdroits d’accès Une méthode d’une classe dérivée n’a pas accès aux membres privés de sa classe de base. Une méthode d’une classe dérivée a accès aux membres publics de sa classe de base. Une méthode d’une classe dérivée a accès aux membres protégés de sa classe de base. protected (classes dérivées et classes appartenant au même paquetage)
    63. 63. KACIMI Lamine / 201463 JAVA, Construction des objets dérivésJAVA,Héritage,Construction desobjetsdérivés En Java, le constructeur de la classe dérivée doit prendre en charge l’intégralité de la construction de l’objet. Si un constructeur d’une classe dérivée appelle un constructeur d’une classe de base, il doit obligatoirement s’agir de la première instruction du constructeur et ce dernier est désigné par le mot-clé super.
    64. 64. KACIMI Lamine / 201464 JAVA, Initialisation des objets dérivésJAVA,Héritage,Initialisation desobjetsdérivés OBJET SIMPLE OBJET DÉRIVÉ 1. Allocation mémoire, 2. Initialisation par défaut des champs, 3. Initialisation explicite des champs, 4. Exécution des instructions du constructeur. 1. Allocation mémoire pour un objet de type B; 2. Initialisation par défaut de tous les champs de B(aussi bien ceux hérités de A, que ceux propres à B) aux valeurs "nulles" habituelles. 3. Initialisation explicite, s’il y a lieu, des champs hérités de A. 4. Exécution du corps du constructeur de A. 5. Initialisation explicite, s’il y a lieu, des champs propres à B. 6. Exécution du corps du constructeur de B.
    65. 65. KACIMI Lamine / 201465 JAVA, Redéfinition de méthodesJAVA,Redéfinitionde méthodes Java permet à une classe dérivée de redéfinir des méthodes définies dans la classe de base. 03 Conditions: 1. Le type de retour doit être le même et/ou covariant. 2. le droit d’accès de la méthode de la classe dérivée ne doit pas être moins élevé que celui de la classe ascendante. 3. la clause throws de la méthode de la classe dérivée ne doit pas mentionner des exceptions non mentionnées dans la clause throws de la méthode de la classe ascendante
    66. 66. KACIMI Lamine / 201466 JAVA, Redéfinition de méthodesJAVA,Redéfinitionde méthodes • classe A: méthode f de A • classe B: méthode f de A • classe C: méthode f de C • classe D: méthode f de D • classe E: méthode f de A • classe F: méthode f de C.
    67. 67. KACIMI Lamine / 201467 JAVA, Polymorphisme JAVA,Polymorphisme Le polymorphisme permet de manipuler des objets sans en connaître (tout à fait) le type. Exercice: Ecrire un programme qui crée un tableau hétérogène d’objets Point et envoie le message afficher() à chacun d’eux.
    68. 68. KACIMI Lamine / 201468 JAVA, Limites du polymorphismeJAVA,Limitesdu polymorphisme
    69. 69. KACIMI Lamine / 201469 JAVA, La super-classe Objet JAVA,Lasuper-classeObjet En réalité, dans JAVA, il existe une classe nommée Object dont dérive implicitement toute classe simple. Méthodes de la classe Object: Méthode Explication toString Fournit une chaîne contenant : • le nom de la classe concernée, • l’adresse de l’objet en hexadécimal (précédée de @). equals Se contente de comparer les adresses des deux objets concernés
    70. 70. KACIMI Lamine / 201470 JAVA, Les classes et les méthodes finalesJAVA,Lesclassesetles méthodesfinales Une méthode déclarée final ne peut pas être redéfinie dans une classe dérivée. Une classe déclarée final ne peut plus être dérivée. Par exemple, les classes wrappers (Integer, Double, …etc.) sont déclarées finales et ne peuvent donc pas être dérivées. Quand doit-on déclarer des classes finales?
    71. 71. KACIMI Lamine / 201471 JAVA, Les classes abstraites JAVA,Lesclassesabstraites Une classe abstraite est une classe qui ne permet pas d’instancier des objets. Elle ne peut servir que de classe de base pour une dérivation. Elle se déclare ainsi : Animal Son Abeille Bourdonne Hibou Hue, ulule Bœuf Beugle, meugle Cerf Brame Cheval Hennit Chien Aboie Cochon Grogne Corbeau Croasse Pigeon Caracoule
    72. 72. KACIMI Lamine / 201472 JAVA, Les interfaces JAVA,Lesinterfaces Si l’on considère une classe abstraite n’implantant aucune méthode et aucun champ (hormis des constantes), on aboutit à la notion d’interface. En effet, une interface définit les en-têtes d’un certain nombre de méthodes, ainsi que des constantes. Cependant, nous allons voir que cette dernière notion se révèle plus riche qu’un simple cas particulier de classe abstraite. En effet : • Une classe pourra implémenter plusieurs interfaces (alors qu’une classe ne pouvait dériver que d’une seule classe abstraite), à condition qu’elles soient compatibles • les interfaces pourront se dériver, • on pourra utiliser des variables de type interface.
    73. 73. KACIMI Lamine / 201473 JAVA, Les classes anonymes JAVA,Lesclassesanonymes
    74. 74. KACIMI Lamine / 201474 JAVA, Les chaînes de caractères et les types énumérés JAVA,Leschaînesde caractèresetlestypes énumérés 1. La classe String 2. La classe StringBuffer 3. La classe StringBuilder 4. Les types énumérés (depuis JDK 5.0)
    75. 75. KACIMI Lamine / 201475 JAVA, La classe String JAVA,LaclasseString Java dispose d’une classe standard nommée String, permettant de manipuler des chaînes de caractères, c’est-à-dire des suites de caractères. Les constantes chaînes telles que « bonjour » ne sont en fait que des objets de type String construits automatiquement par le compilateur. La classe String dispose de deux constructeurs, l’un sans argument créant une chaîne vide, l’autre avec un argument de type String qui en crée une copie. La classe String dispose d’autres constructeurs aussi, mais les deux ci-dessus mentionnés sont les plus utilisés.
    76. 76. KACIMI Lamine / 201476 JAVA, Méthodes de la classe StringJAVA,Méthodesdelaclasse String 1. Longueur d’une chaîne : length La méthode length permet d’obtenir la longueur d’une chaîne, c’est-à-dire le nombre de caractères qu’elle contient (pour être plus précis, il faudrait parler de la longueur de l’objet String dont on lui fournit la référence). 2. Accès aux caractères d’une chaîne : charAt La méthode charAt de la classe String permet d’accéder à un caractère de rang donné d’une chaîne (le premier caractère porte le rang 0) 3. Concaténation de chaînes: + L’opérateur + est défini lorsque ses deux opérandes sont des chaînes. Il fournit en résultat une nouvelle chaîne formée de la concaténation des deux autres. Si seule une opérande est de type String, l’autre se voit converti en String aussi (Formatage)
    77. 77. KACIMI Lamine / 201477 JAVA, Méthodes de la classe StringJAVA,Méthodesdelaclasse String 4. Recherche dans une chaîne: indexOf, lastIndexOf La méthode indexOf permet de rechercher, à partir du début d’une chaîne ou d’une position donnée : •la première occurrence d’un caractère donné, •la première occurrence d’une autre chaîne. Dans tous les cas, elle fournit : •la position du caractère (ou du début de la chaîne recherchée) si une correspondance a effectivement été trouvée, •la valeur -1 sinon. Il existe également une méthode lastIndexOf, qui effectue les mêmes recherches que indexOf, mais en examinant la chaîne depuis sa fin. 5. Comparaison de chaînes: ==,!=,equals, equalsIgnoreCase
    78. 78. KACIMI Lamine / 201478 JAVA, Méthodes de la classe StringJAVA,Méthodesdelaclasse String 6. Comparaison de chaînes: compareTo La méthode compareTo s’utilise ainsi : chaîne1.compareTo(chaîne2) Elle fournit : •un entier négatif si chaîne1 arrive avant chaîne2. •un entier nul si chaîne1 et chaîne2 sont égales. •un entier positif si chaîne1 arrive après chaîne2 .7. Majuscule et Minuscule: toLowerCase, toUpperCase: .8. Suppression des séparateurs de début et de fin: trim Exercice: Ecrire un programme Java qui permet de trier un tableau de chaînes normalisées. 9. Conversions: String.valueOf()
    79. 79. KACIMI Lamine / 201479 JAVA, La classe StringBuffer JAVA,LaclasseStringBuffer Les objets de type String ne sont pas modifiables mais nous avons vu qu’il était possible de les employer pour effectuer la plupart des manipulations de chaînes. Cependant, la moindre modification d’une chaîne ne peut se faire qu’en créant une nouvelle chaîne (c’est le cas d’une simple concaténation). C’est pourquoi Java dispose d’une classe StringBuffer destinée elle aussi à la manipulation de chaînes, mais dans laquelle les objets sont modifiables.
    80. 80. KACIMI Lamine / 201480 JAVA, Méthodes de la classe StringBufferJAVA,Méthodesdelaclasse StringBuffer Il existe des méthodes : • de modification d’un caractère de rang donné : setCharAt, • d’accès à un caractère de rang donné : charAt, • d’ajout d’une chaîne en fin : la méthode append accepte des arguments de tout type primitif et de type String, • d’insertion d’une chaîne en un emplacement donné : insert, • de remplacement d’une partie par une chaîne donnée : replace, • de conversion de StringBuffer en String : toString.
    81. 81. KACIMI Lamine / 201481 JAVA, Types énumérés JAVA,Typesénumérés 1. Définition 2. Déclaration d’une variable de type énuméré
    82. 82. KACIMI Lamine / 201482 JAVA, Types énumérés JAVA,Typesénumérés 3. Comparaison 4. Utilisation d’un type énuméré dans une instruction switch
    83. 83. KACIMI Lamine / 201483 JAVA, Types énumérés JAVA,Typesénumérés 5. Conversion entre types énumérés et chaînes 6. Itération sur les valeurs d’un type énuméré
    84. 84. KACIMI Lamine / 201484 JAVA, Types énumérés JAVA,Typesénumérés 7. Ajout de constructeur et de méthodes
    85. 85. KACIMI Lamine / 201485 JAVA, La gestion des exceptions JAVA,Gestiondesexceptions Même lorsqu’un programme est au point, certaines circonstances exceptionnelles peuvent compromettre la poursuite de son exécution. • Il peut s’agir par exemple de données incorrectes. • Problème d’accès à un fichier. • Attente de réponse d’un serveur hors service. • Problème matériel quelconque.
    86. 86. KACIMI Lamine / 201486 JAVA, La hiérarchie des exceptions JAVAJAVA,Lahiérarchiedes exceptionsJAVA
    87. 87. KACIMI Lamine / 201487 JAVA, La hiérarchie des exceptions JAVAJAVA,Lahiérarchiedes exceptionsJAVA
    88. 88. KACIMI Lamine / 201488 JAVA, Runtime Exceptions JAVA,RuntimeExceptions Exception Explications ArithmeticException Exception générée suite à une erreur d’arithmétique ArrayIndexOutOfBoundsException Exception générée suite à l’accès à un index en dehors des limites d’un tableau, d’une collection ArrayStoreException Exception générée lorsque un programme essaye de mettre dans un tableau d’objets un objet incompatible ClassCastException Exception générée en essayant de convertir explicitement un objet vers un type non compatible IllegalArgumentException Exception générée suite au passage d’un mauvais argument à une méthode IllegalMonitorStateException Appel de wait, notify, notifyAll depuis un thread qui ne détient pas le moniteur de l’objet IllegalStateException Opération demandée alors que l’état de la machine virtuelle est elle dans un état qui lui permet pas de traiter l’opération IllegalThreadStateException Exemple: demander la continuation d’un thread alors qu’il est dans l’état terminé. IndexOutOfBoundsException Super-classe de ArrayIndexOutOfBoundsExcception NegativeArraySizeException Création d’un tableau avec un nombre négatif d’éléments NullPointerException Accès à des méthodes d’un objet via la référence null NumberFormatException Echec de la conversion depuis String ver Number SecurityException Exécution d’une opération qui viole la politique de sécurité préservée par un objet SecurityManger StringIndexOutOfBoundsException Exception générée suite à l’accès à un index en dehors des limites d’un objet String, StringBuffer.
    89. 89. KACIMI Lamine / 201489 JAVA, Traitement des exceptions, Exceptions handling JAVA,Traitementdes exceptions Deux types d’exceptions: 1. Checked Exceptions (Exceptions explicites): (à traiter par le programmeur) 2. Unchecked Exceptions (Exceptions implicites): Traité par un mécanisme mis en place par la JVM.
    90. 90. KACIMI Lamine / 201490 JAVA, Traitement des exceptions unchecked JAVA,Traitementdes exceptions Default handler (stackTrace + arrêt du thread)
    91. 91. KACIMI Lamine / 201491 JAVA, Traitement des exceptions checked JAVA,Traitementdes exceptions Utilisation de blocs try, catch, ou en ajoutant throws à la méthode à l’origine de l’exception Si les exceptions checked ne sont pas traitées par le programmeur, elle seront traitées par la jvm au même titre que les exceptions unchecked. D’autre part, les exceptions unchecked peuvent également être traitées par le programmeur Il n y a aucune différence en terme de fonctionnalités entres les exceptions checked et unchecked. Les exceptions checked « obstruent » le code métier .
    92. 92. KACIMI Lamine / 201492 JAVA, Déclencher une exception, throwJAVA,Déclencherune exception
    93. 93. KACIMI Lamine / 201493 JAVA, Gestionnaire d’exception, le bloc try …..catch JAVA,Gestionnaired’exception
    94. 94. KACIMI Lamine / 201494 JAVA, Gestion de plusieurs exceptionsJAVA,Gestiondeplusieurs exceptions
    95. 95. KACIMI Lamine / 201495 JAVA, Gestion de plusieurs exceptionsJAVA,Gestiondeplusieurs exceptions Depuis Java7, il est possible d’écrire un seul block catch pour traiter plusieurs exceptions
    96. 96. KACIMI Lamine / 201496 JAVA, La clause throws JAVA,Laclausethrows Toute méthode susceptible de déclencher une exception explicite qu’elle ne traite pas localement doit mentionner son type dans une clause throws figurant dans son en-tête. Bien entendu, cette règle concerne les exceptions que la méthode peut déclencher directement par l’instruction throw, mais aussi toutes celles que peuvent déclencher (sans les traiter) toutes les méthodes qu’elle appelle
    97. 97. KACIMI Lamine / 201497 JAVA, Redéclenchement d’une exception JAVA,Redéclenchementd’une exception Dans un gestionnaire d’exception, il est possible de demander que, malgré son traitement, l’exception soit retransmise à un niveau englobant, comme si elle n’avait pas été traitée. Il suffit pour cela de la relancer en appelant à nouveau l’instruction throw.
    98. 98. KACIMI Lamine / 201498 JAVA, Le bloc finally JAVA,Leblocfinally Nous avons vu que le déclenchement d’une exception provoque un branchement inconditionnel au gestionnaire, à quelque niveau qu’il se trouve. L’exécution se poursuit avec les instructions suivant ce gestionnaire. Java permet d’introduire, à la suite d’un bloc try, un bloc particulier d’instructions qui seront toujours exécutées : • soit après la fin "naturelle" du bloc try, si aucune exception n’a été déclenchée, • soit après le gestionnaire d’exception (à condition, bien sûr, que ce dernier n’ait pas provoqué d’arrêt de l’exécution).
    99. 99. KACIMI Lamine / 201499 JAVA, Les structures de données (les collections) JAVA,Lesstructuresde données(lescollections) List: Stocker des objets sans conditions particulières Set: Pas deux fois ou plus le même objet Map: Système clé-valeur
    100. 100. KACIMI Lamine / 2014100 JAVA, Les structures de données (les collections) JAVA,Lesstructuresde données(lescollections)
    101. 101. KACIMI Lamine / 2014101 JAVA, Les structures de données (les collections) JAVA,Lesstructuresde données(lescollections)
    102. 102. KACIMI Lamine / 2014102 JAVA, Les classes implémentant l’interface List JAVA,Lesclassesimplémentant l’interfaceList LinkedList, Vector, ArrayList
    103. 103. KACIMI Lamine / 2014103 JAVA, Quelques méthodes de l’interface List JAVA,Lesclassesimplémentant l’interfaceList •add() permet d'ajouter un élément ; •get(int index) retourne l'élément à l'indice demandé ; •remove(int index) efface l'entrée à l'indice demandé ; •isEmpty() renvoie « vrai » si l'objet est vide ; •removeAll() efface tout le contenu de l'objet ; •contains(Object element) retourne « vrai » si l'élément passé en paramètre est dans l'ArrayList. Si vous effectuez beaucoup de lectures sans vous soucier de l'ordre des éléments, optez pour une ArrayList ; en revanche, si vous insérez beaucoup de données au milieu de la liste, optez pour une Linkedlist.
    104. 104. KACIMI Lamine / 2014104 JAVA, les classes implémentant l’interface Map JAVA,Lesclassesimplémentant l’interfaceList HashTable, HashMap
    105. 105. KACIMI Lamine / 2014105 JAVA, Méthodes de l’interface MapJAVA,Méthodesdel’interface Map HashTable, HashMapLa classe HashTable nous offre tout un panel de méthodes utiles : •isEmpty() retourne « vrai » si l'objet est vide ; •contains(Object value) retourne « vrai » si la valeur est présente. Identique àcontainsValue(Object value) ; •containsKey(Object key) retourne « vrai » si la clé passée en paramètre est présente dans laHashtable ; •put(Object key, Object value) ajoute le couple key - value dans l'objet ; •elements() retourne une énumération des éléments de l'objet ; •keys() retourne la liste des clés sous forme d'énumération. HashMap accepte null et n’est pas thread safe (plus rapide donc)
    106. 106. KACIMI Lamine / 2014106 JAVA, Classes implémentant l’interface Set JAVA,Classesimplémentant l’interfaceSet HashSet, TreeSet, LinkedHashSet Exercice: Trier un tableau d’ entiers en utilisant an objet TreeSet
    107. 107. KACIMI Lamine / 2014107 JAVA, Méthodes de l’interface SetJAVA,Méthodesdel’interface Map HashTable, HashMap La classe HashTable nous offre tout un panel de méthodes utiles : •add() •contains(Object value) •isEmpty() •iterator() •remove() •toArray()
    108. 108. KACIMI Lamine / 2014108 JAVA, Récapitulatif sur les collectionsJAVA,Récapitulatifsurles collections •Une collection permet de stocker un nombre variable d'objets. •Il y a principalement trois types de collection : les List, les Set et les Map. •Chaque type a ses avantages et ses inconvénients. •Les Collection stockent des objets alors que les Map stockent un couple clé - valeur. •Si vous insérez fréquemment des données en milieu de liste, utilisez une LinkedList. •Si vous voulez rechercher ou accéder à une valeur via une clé de recherche, optez pour une collection de type Map. •Si vous avez une grande quantité de données à traiter, tournez- vous vers une liste de type Set.
    109. 109. KACIMI Lamine / 2014 FIN INITIATION JAVA 109 FININITIATIONJAVA
    110. 110. KACIMI Lamine / 2014 Gestion des entrées/sorties 110 Lesentrées/sorties
    111. 111. KACIMI Lamine / 2014111 Gestion des fichiers Lesentrées/sorties • La gestion de fichiers se fait par l'intermédiaire de la classe java.io.File. • Cette classe possède des méthodes qui permettent d'interroger ou d'agir sur le système de fichiers du système d'exploitation. • Un objet de la classe java.io.File peut représenter un fichier ou un répertoire.
    112. 112. KACIMI Lamine / 2014112 Gestion des fichiers Lesentrées/sorties
    113. 113. KACIMI Lamine / 2014113 Méthode de la classe File Lesentrées/sorties File (String name) File (String path, String name) File (File dir, String name) boolean isFile () boolean isDirectory () boolean mkdir () boolean exists () boolean delete () boolean canWrite () boolean canRead () File getParentFile () long lastModified () String [] list ()
    114. 114. KACIMI Lamine / 2014114 Gestion des flux Lesentrées/sorties • Un flux (stream) est un chemin de communication entre la source d'une information et sa destination. • Difficulté d'un langage d'avoir un bon système d'entrées/sorties. • Beaucoup de sources d'E/S de natures différentes (console, fichier, socket,...). • Beaucoup d'accès différents (accès séquentiel, accès aléatoire, mise en mémoire tampon, binaire, caractère, par ligne, par mot, etc.). • Problème de codage (UNICODE, ASCII, ISO……)
    115. 115. KACIMI Lamine / 2014115 Gestion des flux…suite Lesentrées/sorties • Java propose les flux suivants. • Flux d'entrée/sortie de bytes. • Flux d'entrée/sortie de caractères depuis la version 1.1 de java. • Toutes les classes d'entrée/sortie sont dans le package java.io • Toutes les méthodes peuvent générer une java. io.IOException
    116. 116. KACIMI Lamine / 2014116 InputStream, classes dérivées Lesentrées/sorties InputStream FilterInputStream DataInputStream BufferedInputStream PushBackInputStream PipeInputStream FileInputStream
    117. 117. KACIMI Lamine / 2014117 OutputStream, classes dérivées Lesentrées/sorties OutputStream FilterOutputStream DataOutputStream BufferedOutputStream PrintStream ObjectOutputStream ByteArrayOutputStrea m
    118. 118. KACIMI Lamine / 2014118 FileOutputStream et FileInputStream Lesentrées/sorties
    119. 119. KACIMI Lamine / 2014119 La classe InputStream Lesentrées/sorties  Méthodes de lecture • public int read () ; • public int read (byte b[ ]) ; • public int read (byte b[], int off, int len) ;  Sauter des octets : public long skip (long n) ;  Combien d'octets dans le flux : public int available () ;  Le flux supporte-t'il le marquage ? public boolean markSupported () ;  Marquage d'un flux : public void mark (int readlimit) ;  Revenir sur la marque: public void reset () ;  Fermer un flux : public void close () ;
    120. 120. KACIMI Lamine / 2014120 La classe OutputStream Lesentrées/sorties  Méthodes d’écriture • public void write (int b) ; • public void write (byte b []) ; • public void write (byte b [], int off, int len)  Nettoyage d'un flux, forçant l'écriture des données bufférisées: public void flush () ;  Fermeture d'un flux public void close () ;
    121. 121. KACIMI Lamine / 2014121 FilterInputStream et FilterOutputStream Lesentrées/sorties Ces deux classes servent de classes de base à des classes de gestion d'entrées/sorties plus évoluées: • BufferedInputStream et BufferedOutputStream permettent de lire et écrire des données à travers un tampon de lecture/écriture pour améliorer les performances. • DataInputStream et DataOutputStream permettent de lire/écrire des données formatées (byte, int, char, float, double, etc.)
    122. 122. KACIMI Lamine / 2014122 Classes de flux de caractères Lesentrées/sorties
    123. 123. KACIMI Lamine / 2014123 Exemple avec BufferedReader Lesentrées/sorties
    124. 124. KACIMI Lamine / 2014124 La sérialisation Lesentrées/sorties La sérialisation d'un objet est le processus de stockage d'un objet complet (par exemple sur un disque). • Le processus inverse est la désérialisation. • Un objet sérialisé est dit persistant Une classe est sérialisable si elle implémente l'interface java.io.Serializable. Des objets de type java.io.ReadObjectStream et java.io.WriteObjectStream vont permettre de sérialiser/désérialiser. Les données membres que l'on ne souhaite pas sauvegarder doivent être déclarées transient.
    125. 125. KACIMI Lamine / 2014125 La sérialisation….suite Lesentrées/sorties Des méthodes de lecture/écriture peuvent être redéfinies le cas échéant: private void writeObject (java.io.ObjectOutputStream out) throws IOException ; private void readObject (java.io.ObjectInputStream in) throws IOException, ClassNotFoundException ;
    126. 126. KACIMI Lamine / 2014126 Le package java.nio Lesentrées/sorties • Nouveau package de gestion des entrées/sorties introduit dans la version 1.4. • NIO permet d'utiliser des entrées/sorties plus rapides en gérant des blocs plutôt que des bytes ou caractères. • Les objets de base pour ce type d'entrée sortie sont: Buffer et Channel • Un "Buffer' contient les données à lire ou écrire, un "Channel" désigne la source ou la destination de l'information. Une entrée/sortie sur un objet "Channel" transite obligatoirement par un objet "Buffer"
    127. 127. KACIMI Lamine / 2014127 Le package java.nio… exemple Lesentrées/sorties
    128. 128. KACIMI Lamine / 2014128 Nouveautés dans Java7 Lesentrées/sorties • La gestion des entrées/sorties a été améliorée dans Java7. à vous de découvrir les nouvelles classes, non?
    129. 129. KACIMI Lamine / 2014 Programmation réseau, les sockets 129 Programmationréseau
    130. 130. KACIMI Lamine / 2014130 Introduction Programmationréseau • Même si la plupart des applications développées en java reposent sur des bibliothèques de haut-niveau, il est parfois utile d'utiliser les sockets à bas niveau. • Depuis la sortie de java, une API permettant de gérer le réseau est disponible dans le JDK, elle permet de gérer les adresses, les sockets clients, les sockets serveurs, les URL... Dans ce cours, nous verrons comment utiliser cette API en faisant parfois un lien avec la gestion du réseau bas-niveau. (le package java.net) • Il est utile d'avoir des connaissances en réseau même si je tenterai au maximum de réexpliquer les notions utiles.
    131. 131. KACIMI Lamine / 2014131 Le modèle ISO (norme ISO 7498-1) Programmationréseau
    132. 132. KACIMI Lamine / 2014132 Adressage Programmationréseau •Avant d'entamer la partie communication proprement dite, nous allons apprendre à utiliser les adresses IP en java. •Afin que deux applications communiquent (en utilisant le protocole IP), il est nécessaire de connaître l'adresse IP de l'autre machine. L'API standard permet de les manipuler en utilisant la classe InetAddress. Cette classe permet de manipuler aussi bien les adresses IPv4 que les adresses IPv6. Ceci correspond à deux normes différentes, la plupart des IP rencontrées sont en IPv4 et ont une notation sous la forme 127.0.0.1.
    133. 133. KACIMI Lamine / 2014133 La classe InetAddress Programmationréseau static InetAddress getByAddress(byte[] addr) obtenir un InetAddress à partir d'un champ de bytes (4 pour l'IPv4) static InetAddress getByName(String host) permet d'obtenir l'adresse à partir du nom d'hôte static InetAddress getLocalHost() permet d'obtenir l'adresse de l'hôte local byte[] getAddress() retourne un champ de byte correspond à l'adresse String getHostAddress() retourne l'adresse sous forme pointée String getHostName() retourne le nom d'hôte
    134. 134. KACIMI Lamine / 2014134 Adressage, Exemple Programmationréseau
    135. 135. KACIMI Lamine / 2014135 Le protocole TCP Programmationréseau Afin de communiquer entre plusieurs machines de manière simple, les informaticiens ont défini deux protocoles réseaux couramment utilisés de nos jours : le protocole TCP et le protocole UDP. De manière assez sommaire, le protocole TCP a été créé pour permettre d'envoyer des données de manière fiable par le réseau, notamment en : • s'assurant que les données arrivent au destinataire, en cas d'échec de transmission, l'ordinateur émetteur doit être mis au courant • s'assurant que les données arrivent dans le bon ordre • définissant une connexion entre les machines
    136. 136. KACIMI Lamine / 2014136 Le protocole UDP Programmationréseau UDP est peu fiable, il n'est pas certain que les données arrivent et il n'est pas certains que les données arrivent dans le bon ordre. TCP effectue un nombre important d'allers et retours, ce qui a l'inconvénient de faire diminuer la vitesse de connexion. De nos jours, TCP est quasiment tout le temps utilisé, sauf pour les échanges dont la perte de paquets n'est pas important (typiquement vidéocast, VoIP...). Java propose plusieurs classes pour manipuler ces protocoles de manière absolument transparente. •La classe Socket repose sur le protocole TCP et permet donc de transmettre des données de manière fiable. •La classe DatagramSocket quant à elle, repose sur UDP.
    137. 137. KACIMI Lamine / 2014137 Le mode connecté Programmationréseau Serveur Client 1.Création d'un objet ServerSocket pour l'ouverture du service 2.Attente d'une demande de connexion (méthode accept () qui retourne une socket de service) 3.Echange d'informations avec le client 4.Fermeture socket (méthode close()). 1. Création d'un objet Socket. 2. Connexion sur le serveur. 3. Echange d'informations avec le serveur 4. Fermeture socket (méthode close ()).
    138. 138. KACIMI Lamine / 2014138 Le mode connecté, le client Programmationréseau
    139. 139. KACIMI Lamine / 2014139 Le mode connecté, le serveur Programmationréseau
    140. 140. KACIMI Lamine / 2014140 Le mode non connecté, DatagramSocket Programmationréseau • Les constructeurs: • public DatagramSocket () ; • public DatagramSocket (int port) ; • public DatagramSocket (int port, InetAddr laddr) ; • Quelques méthodes: • public void receive (DatagramPacket p) ; • public void send (DatagramPacket p) ; La classe java.net.DatagramPacket contient les données reçues ou à envoyer (tableau de bytes) et l'adresse (java.net.InetAddress) de l'expéditeur ou du destinataire.
    141. 141. KACIMI Lamine / 2014141 Le mode non connecté, le client Programmationréseau
    142. 142. KACIMI Lamine / 2014142 Le mode non connecté, le serveur Programmationréseau
    143. 143. KACIMI Lamine / 2014143 Le multicast, la classe MulticastSocket Programmationréseau Cette classe permet d’utiliser le multicasting IP pour envoyer des datagrammes UDP à un ensemble de machines repéré grâce à une adresse multicast (classe D dans IP version 4 : de 224.0.0.1 à 239.255.255.255) Pour pouvoir recevoir des datagrammes UDP envoyés grâce au multicasting IP il faut s’abonner à une adresse multicast De même lorsqu’on ne souhaite plus recevoir des datagrammes UDP envoyés à une adresse multicast on doit indiquer la résiliation de l’abonnement. public void joinGroup(InetAddress adresseMulticast) throws IOException et void leaveGroup(InetAddress adresseMulticast);
    144. 144. KACIMI Lamine / 2014 Programmation concurrente, les threads 144 Programmationconcurrente
    145. 145. KACIMI Lamine / 2014145 Threads, Introduction Programmationconcurrente Un thread est une unité d'exécution au sein d'un même processus (ce n'est pas un autre processus). Tous les threads d'un même processus partagent la même zone mémoire. La programmation multithreads donne l'illusion de la simultanéité. La gestion des threads est dépendante de la JVM (problème pour la portabilité). Les threads peuvent être préemptifs ou coopératifs.
    146. 146. KACIMI Lamine / 2014146 Threads, Introduction Programmationconcurrente Un thread possède un nom et une priorité. Un thread s'exécute jusqu'au moment où: • Un thread de plus grande priorité devient exécutable. • Une méthode wait (), yield () ou sleep () est lancée. • Son quota de temps a expiré dans un système préemptif.
    147. 147. KACIMI Lamine / 2014147 Création de threads Programmationconcurrente Une classe est un thread si elle remplit une des deux conditions: •Elle étend la classe java.lang.Thread •Elle implémente l'interface java.lang.Runnable Le corps du thread est contenu dans une méthode: public void run () Un thread est lancé par appel d'une méthode start ()
    148. 148. KACIMI Lamine / 2014148 Threads, premier exemple Programmationconcurrente
    149. 149. KACIMI Lamine / 2014149 Threads, deuxième exemple Programmationconcurrente
    150. 150. KACIMI Lamine / 2014150 La classe java.lang.thread Programmationconcurrente start () Rend un thread exécutable en lançant la méthode run (). sleep (i) Endort le thread pour i millisecondes. wait()* Suspend le thread. notify ()* Place le thread dans un état exécutable. notifyAll ()* Réveille tous les threads en attente. yield () Place le thread de l'état « en cours d'exécution » à l'état « exécutable ». setPriority (i) Modifie la priorité d'un thread (i est compris entre MIN_PRIORITY et MAX_PRIORITY). join () join (long) Pour qu'un deuxième thread attende la fin d'exécution d'un premier thread, il suffit d'appeler la méthode join sur le premier thread. Un paramètre de temps (en millisecondes) peut être spécifié.
    151. 151. KACIMI Lamine / 2014151 Cycle de vie d’un thread Programmationconcurrente
    152. 152. KACIMI Lamine / 2014152 Les threads, la synchronisation Programmationconcurrente Plusieurs threads accédant à une même donnée doivent être synchronisés La synchronisation peut se faire sur un objet (pas de synchronisation possible pour une variable d'un type de base) Mot clé: synchronized Si un thread invoque une méthode synchronized d’un objet, l’objet se verra verouillé pour toutes ses méthodes synchronized.
    153. 153. KACIMI Lamine / 2014153 Synchronisation, 1er exemple Programmationconcurrente
    154. 154. KACIMI Lamine / 2014154 Synchronisation, 2ème exemple Programmationconcurrente
    155. 155. KACIMI Lamine / 2014155 Atelier pratique Programmationconcurrente Implémentation d’un serveur multithread qui offre les services suivants *. Envoi la date courante *. Envoi le double de la valeur émanant du client *. Vos idées?
    156. 156. KACIMI Lamine / 2014 Les interfaces graphiques (SWING) 156 Lesinterfacesgraphiques
    157. 157. KACIMI Lamine / 2014157 Introduction Lesinterfacesgraphiques • Dans tous les exemples et exercices traités jusque la, nous avons utilisé la console pour interagir avec le programme Java • Pour améliorer l’expérience utilisateur, Java nous offre la possibilité de développer des interfaces graphiques (les interactions seront donc assurées avec le clavier et la souris. • Pour développer des interfaces graphiques, Java dispose de 2 API, à savoir AWT et SWING (Il y a d’autres API mais elles ne sont pas intégrées à l’API Java – SWT de IBM)
    158. 158. KACIMI Lamine / 2014158 AWT vs SWING Lesinterfacesgraphiques • Les deux API font parti de JFC (Java Foundation Classes), en plus de Java2D, Accessibility, DragAndDrop • AWT joue le rôle d’un wrapper au composants du Système d’Exploitation et le rendu est donc OS dépendant –On dit alors que AWT est heavyweighted • SWING est une bibliothèque purement JAVA et on peut donc contrôler le rendu plus facilement. • AWT existe encore à cause des applets. Mais les applets ne sont plus d’actualité non plus, (HTML5) • AWT= Abstract Windowing Toolkit
    159. 159. KACIMI Lamine / 2014159 AWT vs SWING Suite…. Lesinterfacesgraphiques • SWING étend AWT en terme de fonctionnalités – Il y a toujours un composant SWING équivalent pour un composant AWT • SWING offre un set de composants beaucoup plus riche • AWT était préféré parce que le code généré est plus rapide– mais grâce à des améliorations au niveau de SWING et au niveau des machines virtuelles, on peut achever les mêmes performances avec SWING et c’est donc la bibliothèque la plus utilisée de nos jours. • Utiliser donc SWING et non pas AWT • Faut surtout pas mélanger les deux!
    160. 160. KACIMI Lamine / 2014160 SWING Lesinterfacesgraphiques • SWING est une API permettant de créer des interfaces graphiques en JAVA . (GUI toolkit) | GUI=Graphic User Interface. • SWING est développée par SUN microsystems . • SWING fait partie de JFC • SWING est: • Plateforme indépendante • Personnalisable • Extensible • Lightweight (100% en Java) • SWING: c’est 18 packages…. • SWING offre plusieurs composants (lables, boutons, barres de déroulement, mais également des tables, des arborescences.
    161. 161. KACIMI Lamine / 2014161 SWING, un premier exemple Lesinterfacesgraphiques
    162. 162. KACIMI Lamine / 2014162 SWING, Ajouter un bouton à la fenêtre, un bouton avec un ActionListenerLesinterfacesgraphiques 1. Créer un JPanel 2. Mettre le JPanel dans le Jframe 3. Créer un JButton e l’ajouter au Jpanel. 4. Noter l’actionListener, ici ajouté avec une classe anonyme
    163. 163. KACIMI Lamine / 2014163 SWING, Les menus et les barres d’outils Lesinterfacesgraphiques 1. Pour implémenter les menus et les barres d’outils en Java, on utilise les classes suivantes: • JMenuBar • JMenu • JMenuItem
    164. 164. KACIMI Lamine / 2014164 SWING, Les menus et les barres d’outils Lesinterfacesgraphiques 1. Il est possible de créer des sous menus. Un sous menu est exactement identique au menu et est donc crée de façon similaire 2. La seule différence est que le menu sera rattaché au JFrame alors que le sous-menu lui, sera rattaché à un menu existant. 3. Ajouter donc un sous menu dans votre application. 4. Dans le but d’améliorer l’interface, vous pouvez appliquer une icône à chaque sous menu en utilisant votre propre icône ou en utilisant des icônes de SWING: Icon icon = UIManager.getIcon("OptionPane.informationIcon"); 5. Vous pouvez également ajouter des séparateurs à votre menu en utilisant addSeparator();
    165. 165. KACIMI Lamine / 2014165 SWING, Les icônes built-in Lesinterfacesgraphiques
    166. 166. KACIMI Lamine / 2014166 SWING, CheckBoxMenuItem Lesinterfacesgraphiques 1. Vous pouvez ajouter à vos menus des liens de menu (Menu Item) checkbox JCheckBoxMenuItem sbar = new JCheckBoxMenuItem("Show StatuBar"); 2. Afin de positionner un des menu à droite de la fenêtre, on appelle menubar.add(Box.createHorizontalGlue()); Afin de consommer tout l’espace restant.
    167. 167. KACIMI Lamine / 2014167 SWING, Les menus contextuels (JPopupMenu) et les barres d’outils (JToolBar) Lesinterfacesgraphiques 1. Ces menus sont dits contextuels car ce qu’ils affichent dépend de l’objet sélectionné. 2. Exemple: Word: le menu contextuel qui s’affiche lorsqu’on travaille avec un tableau vs celui qui s’affiche lorsqu’on travaille avec une image. 3. Un exemple sera traité durant le cours. 4. Une Barre d’outils permet de rendre les fonctions récurrentes plus accessibles. 5. Une JToolBar contiendra des boutons qui lancent plusieurs fonctions de l’application en réponse au clic.
    168. 168. KACIMI Lamine / 2014168 SWING, JLayoutManager Lesinterfacesgraphiques 1. FlowLayout manager: • Chaque composant fils utilise sa taille par défaut • Les composants sont placés par ligne, passage à la ligne suivante s’il n y a plus d’espace. • Les composants sont centrés et il y a un espace de 5px entre chaque deux composants. • Ce mamanger dispose de constructeurs permettant de modifier ce comportement (Alignement des composants et l’espace laissé entre deux composants successifs) • Ce manager est celui utilisé par défaut sauf pour JFrame dont le manager par défaut est de type BorderLayout
    169. 169. KACIMI Lamine / 2014169 SWING, JGridLayout, JBorderLayout Lesinterfacesgraphiques 1. GridLayout manager: • Le conteneur sera divisé en plusieurs emplacements rectangulaires (une grille) • new GridLayout(lignes, colonnes, Espace H, Espace V) 2. BorderLayout manager : • Divise l’espace en 05 régions (NORTH,WEST,EAST,SOUTH,CENTER) • Chaque région contiendra un seul composant
    170. 170. KACIMI Lamine / 2014 RMI (Remote Mothod Invocation) 170 RemoteMethodeInvocation
    171. 171. KACIMI Lamine / 2014171 Introduction RemoteMethodeInvocation • Les approches traditionnelles pour développer des applications réseaux à base de sockets sont lourdes. (on vient de le voir) • Les RMI vont permettre de distribuer une application sur plusieurs machines. • Une application fera appel à des méthodes sur des objets localisés sur des machines distantes. • RMI se charge de faire transiter les paramètres et la valeur de retour. Les communications pourront être sécurisées grâce à un objet RMISecurityManager.
    172. 172. KACIMI Lamine / 2014172 Architecture RMI RemoteMethodeInvocation
    173. 173. KACIMI Lamine / 2014173 Architecture RMI…suite RemoteMethodeInvocation
    174. 174. KACIMI Lamine / 2014174 RMI, Stub et Skeleton RemoteMethodeInvocation Stub Skeleton 1. Classe spéciale générée par la commande rmic. 2. Transforme un appel de méthode en une suite d'octets à envoyer sur le réseau (marshaling). 3. Reconstruit le résultat reçu sous le même format (unmarshaling) Format d'un appel de méthode: • Identificateur de l'objet distant • Identificateur de la méthode • Paramètres sérialisés 1. Classe spéciale générée par la commande rmic (cette classe n'est plus générée depuis la version 1.2 du protocole). 2. Reçoit la demande d'invocation distante. Reconstruit les paramètres. Trouve l'objet distant et appelle la méthode. Retourne le résultat.
    175. 175. KACIMI Lamine / 2014175 RMI en pratique, l’interface Remote RemoteMethodeInvocation
    176. 176. KACIMI Lamine / 2014176 RMI en pratique, la classe distante RemoteMethodeInvocation
    177. 177. KACIMI Lamine / 2014177 RMI en pratique, création d’une instance de la classe distanteRemoteMethodeInvocation
    178. 178. KACIMI Lamine / 2014178 RMI en pratique, le client RemoteMethodInvocation
    179. 179. KACIMI Lamine / 2014 ANT 179 ANT
    180. 180. KACIMI Lamine / 2014180 Introduction ANT • Projet du groupe Apache-Jakarta pour permettre la construction d'applications (compilation, déploiement, ...). • Site officiel: http://jakarta.apache.org/ant • Exécution de ant: ant [-buildfile fichier.xml] [cible] • Variables d'environnement nécessaires à l'exécution de ant: ANT_HOME JAVA_HOME PATH
    181. 181. KACIMI Lamine / 2014181 Ant, fichier de configuration ANT •Le fichier de configuration propose un ensemble de cibles. •Une cible contient une ou plusieurs tâches à exécuter. •Les cibles peuvent être dépendantes entre elles.
    182. 182. KACIMI Lamine / 2014182 Ant, fichier de configuration…suite ANT 1. Le fichier de configuration commence par le préfixe: <?xml version="1.0"> 2. La balise racine est le projet: <project> 3. A l'intérieur du projet on trouve: • Les cibles <target> • Les propriétés • Les tâches
    183. 183. KACIMI Lamine / 2014183 Build.xml, la balise project ANT La balise <project> contient des attributs: • name: nom du projet • default: détermine la cible par défaut •basedir: indique le répertoire racine pour tous les répertoires utilisés par leur nom relatif • Exemple: <project name="nomprojet" default="compile" basedir=". ">
    184. 184. KACIMI Lamine / 2014184 Build.xml, les commentaires ANT • Les commentaires sont inclus dans les balises <!-- et --> • Exemple: <!– ceci est un commentaire-->
    185. 185. KACIMI Lamine / 2014185 Build.xml, les propriétés ANT Les propriétés permettent de définir des variables qui pourront être utilisées dans le projet Les propriétés peuvent être définies sur la ligne de commande (option -D) ou par la balise <property> • Exemple: <property name="repertoire" value="travail"/>
    186. 186. KACIMI Lamine / 2014186 Build.xml, les propriétés prédéfinies ANT basedir chemin absolu du répertoire de travail (défini dans la balise <project>) ant.file chemin absolu du fichier de configuration ant.java.version numéro de version de la JVM exécutant ant ant.project.name nom du projet en cours d'exécution
    187. 187. KACIMI Lamine / 2014187 Build.xml, les cibles ANT La balise <target> permet de définir une cible constituée par un certain nombre de tâches. • La balise <target> possède plusieurs attributs: • name : obligatoire. nom de la cible • description : optionnel. description de la cible • if : optionnel. conditionne l'exécution à l'existence d'une propriété
    188. 188. KACIMI Lamine / 2014188 Build.xml, les tâches ANT Une tâche est une unité de traitement à exécuter. Une tâche est une classe Java implémentant l'interface org. apache. ant. Task De nombreuses tâches sont définies dans ant (pour en connaître la liste il faut se référer à la documentation fournie avec ant ou à l'adresse http://ant.apache. org/manual/index. html Les tâches prédéfinies permettent le développement java, la manipulation du système de fichiers, des archives, etc.
    189. 189. KACIMI Lamine / 2014189 Build.xml, Exemple complet ANT <?xml version="1.0"?> <project name="project" default="runchatclient"> <description> test ant </description> <property name="src" value="src" /> <property name="dst" value="classes" /> <target name="chatclient" description="Client chat RMI"> <javac srcdir="${src}/rmichat" destdir="${dst}" /> <rmic classname="rmichat.ClientRMI" base="${dst}" /> </target> <target name="runchatclient"> <java classname="rmichat.ChatClient" classpath="${dst}" fork="true" > <arg value="localhost" /> <sysproperty key="java.security.policy" value="java.policy" /> </java> </target> <target name="archive" > <jar destfile="chat.jar" basedir="${dst}" /> </target> </project>

    ×