La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

IFT-10541 Structures de données Abder Alikacem Département dinformatique et de génie logiciel.

Présentations similaires


Présentation au sujet: "IFT-10541 Structures de données Abder Alikacem Département dinformatique et de génie logiciel."— Transcription de la présentation:

1 IFT Structures de données Abder Alikacem Département dinformatique et de génie logiciel

2 Semaine 15 Introduction à la POO en Java

3 Objectifs Introduction à la programmation dans un langage orienté objet Connaissances de base en Java Introduction Introduction à la POO, à Java Les grandes lignes de la syntaxe Java Processus de compilation et d'execution Environement Java, IDE

4 Les langages Objets Langages objets : 1969 (Alan Kay) et Simula (Ole Dahl et Kristen Nygaard) Smalltalk C Objective C, C++ Pascal : Pascal Objet, Delphi (Borland) Basic : VBA (Microsoft) Java C# (Microsoft) Python (script)

5 Java c'est quoi ? Java est un environnement de programmation développé par Sun, adapté à la distribution d'application sur Internet. 4 éléments : Java est un langage de programmation objet Une machine virtuelle Des bibliothèques de classes ou des packages : API Application Programming Interface (3278 classes dans Java 1.5) Ensemble d'outils : java, javac, jdb javadoc, jar,... execution compilation debugger documentation archivage

6 Origine de Java En 1993, le NCSA, est crée le premier navigateur internet (protocole http, langage html) Annonce officielle de la naissance de Java par Sun en 1995 (issu de Oak) Initiateur : James Gosling Programmation simple Utilisation pour Internet Portable Sur la plupart des plate-formes (Archi + OS) Gratuit (téléchargeable sur java.sun.com) Logo (tasse à café), Mascotte (Duke)

7 Java : principe fondateur de sa portabilité

8 Programmation Orientée Objet (POO) Trouver une solution logicielle passe par la description du problème à l'aide d'un langage donné (analyse, décomposition, modélisation,...) : Assembleur, Procédural (C ou Fortran), Objet, naturel. La progression de l'abstraction La POO permet de décrire le problème à l'aide de termes liés au problème et non à la machine. L'unité est l'objet. mov ax,500 ; mov bx,0x20 ; add ax,bx ; int x = 500; int y = 32; x+=y; licence.setNombreEtudiants(500); licence.ajoutEtudiant(32);

9 Un exemple simple : la montre Objectif : une fenêtre s'ouvre pour donner l'heure et la date scénario (use case) :

10 Qu'est-ce qu'un objet ? Un objet modélise toute entité identifiable manipulée par l'application logicielle qu'elle soit tangible ou conceptuelle (ville, étudiant, fenêtre vs date, emploi du temps), générique ou spécifique (pile LIFO vs catalogue de disquaire). Il réagit aux messages qui lui sont envoyés en fonction de son état. Un objet possède : une identité unique un état interne définit par ses attributs un comportement définit par ses méthodes.

11 Qu'est-ce qu'un objet ? Un objet = structure de données (attributs) + algorithmes (méthodes) Principe d'encapsulation L'accès aux données (privées) ou l'état d'un objet ne peut se faire que par l'intermédiaire de son interface (méthodes publiques) Les modifications des structures de données n'affectent pas les programmes utilisant l'objet l'interface d'un objet définit les messages qui lui sont envoyables. maMontre

12 La classe : la matrice / le moule Un objet a un type : il est l'instance d'une classe (class) la classe d'un objet = le schéma, le moule, la matrice, le type. Une classe décrit, définit, implémente : la partie publique (public) : l'interface avec les noms et paramètres des méthodes, partie privée (private) : structure de données internes (les attributs) + les méthodes ou algorithmes internes. Une classe définit un type d'objet, ce n'est pas un objet. Un programme objet = la création d'un ensemble d'objets et la mise en scène de leur interaction.

13 La classe Montre, un peu de syntaxe public class Montre { /*Définissons les attributs*/ private int heure, minute ; /* Définissons les méthodes*/ public int getHeure() { return heure; } public int getMinute() { return minute; } public void setMinute(int m) { minute = m; } public void setHeure(int h) { heure = h; } class indique la définition d'une classe nommée Montre. La syntaxe générale est : class UnNomdeClasse { /* le corps */} Un nom de classe commence par une majuscule Le mot-clé public indique que la classe est utilisable de «l'extérieur». Les attributs sont typés ( int ). La syntaxe générale pour définir une méthode : nomMethode ( ) Les noms de méthodes et attributs commencent par une minuscule, la frontière des mot est marquée par une majuscule. /* commentaire pouvant aller sur plusieurs lignes */ Tout ce qui est entre /* et */ est un commentaire // commentaire jusqu'à la fin de la ligne (comme en C etC++)

14 Syntaxe de Java Reprend celle du C Le ; marque la fin d'instruction Un bloc d'instructions est délimité par {} Les identificateurs sont comme en C (if, while, switch, etc.) et utilisé tel quel Les caractères sont codés en UNICODE 16 bits au lieu de 8 : accents dans le code! Les commentaires en mauvais anglais sont préférables à un français impeccable. Les commentaires pertinents sont obligatoires.

15 Types de programmes Java Application Programme autonome (stand-alone) L'application doit posséder une classe principale ayant une méthode signature : public static void main(String[]args) C'est la méthode interprétée lors de l'exécution, le point d'entrée. Elle est static : ne nécessite pas de création d'objet pour être invoquable (les méthodes statiques sont également nommées méthodes de classe, méthodes d'objet). Applet Programme exécutées dans l'environnement d'un navigateur. Le byte code est sur un serveur http, il est chargé via une page html. Pas de méthode main(), mais les méthodes obligatoires : init(),start(),stop(),paint(),destroy

16 Exemple de la montre : conception Création d'un programme Java : Identifier les objets nécessaires et leurs relations Spécifier leurs types / leurs classes (données, comportement) Chercher dans l'API Java si des classes peuvent répondrent aux besoins (tout ou en partie) Création des classes nécessaires (en s'appuyant sur l'API) Programmer en Java, c'est aussi savoir chercher dans l'API Java.

17 Exemple de la montre : scénario

18 Manipulation des objets En Java, les objets sont manipulés exclusivement avec des références. Une référence est un pointeur. Il est à l'objet ce que la télécommande est à la TV. Création d'une référence sur un objet de type Integer : Integer s; La création d'une référence, n'implique pas la création d'un objet. Les objets doivent être créer : s = new Integer(); Ainsi est créé un objet de type Integer. On y accède via la référence s. Integer() est une méthode particulière de la classe Integer : le constructeur. Cette méthode peut avoir des arguments indiquants comment construire l'objet : Integer s = new Integer(5); Plusieures références peuvent pointer sur le même objet : Integer s2 = s; Il y a toujours qu'un seul objet, mais on a deux références.

19 Le fichier source d'une application import java.util.Date; import javax.swing.*; /** Le premier programme Java * Application donnant heure et date John Doe 0 */ public class ExempleMontre{ /* Ici sont définis les attributs et * méthodes, en finissant par le main. */ public static void main(String[] args) { /* corps de la méthode main */ } Lorsqu'on utilise une classe pré-défini, il faut indiquer au compilateur où est le code correspondant : import. On peut importer une classe (Date) ou toutes les classes d'une collection. Lors de la création d'une application, une des classes public doit porter le même nom que le fichier et comporter une méthode main. Les commentaires commençant par /** sont destinés à javadoc. Les commandes javadoc commence par ». Il est possible d'utiliser également du html. Tout programme, Toutes les classes, les attributs et méthodes sont à commenter afin de générer une documentation via javadoc. Fichier ExempleMontre.java

20 Le source complet import java.util.*; import javax.swing.*; /* Descriptif de la classe. */ public class ExempleMontre{ public static void main(String[] args) { /* Création de la date */ Date date = new Date(2004, 9, 23, 5, 30); /* zones de texte : création et écriture des textes */ JTextArea textHeure = new JTextArea(); JTextArea textDate = new JTextArea(); textHeure.setText(date.getHours()+"h"+ date.getMinutes()+" "); textDate.setText("le "+date.getDate() +"/"+date.getMonth()+"/" + date.getYear()); /* Creation de la zone d'affichage et remplissage */ JPanel monPanel = new JPanel(); monPanel.add(textHeure); monPanel.add(textDate); /* Creation de la fenetre, reglage et remplissage */ JFrame fenetre = new JFrame("ma fenetre"); /* reglage dimension et inclusion de la zone d'affichage */ fenetre.setBounds(100, 100, 160, 60); fenetre.getContentPane().add(monPanel); /* afficher */ fenetre.setVisible(true); } Les « import » sont les premières lignes non commentées. Les commentaires sont indispensables pour comprendre le code ainsi que sa structure. Cet application ne fait que créer des objets et leurs envoyer des messages.

21 Conventions de Codage Les développeurs écrivent du code que dautres lisent Java est apprécié pour sa lisibilité Sun PROPOSE une façon décrire le code Conventions de codage: java.sun.com/docs/codeconv/ Aide au déboguage de Java ( communauté open source ) Re-formateur de code sinon… (JavaStyle, Jalopy, etc.) class Sample extends Object { int ivar1; int ivar2; Sample(int i, int j) { ivar1 = i; ivar2 = j; } int emptyMethod() {}... } Attention aux petits détails Nom de classe avec majuscule Nom de méthode avec minuscule Indentation

22 Compilation, execution,... La compilation va créer un fichier.class, le pseudo-code : javac ExempleMontre.java La compilation crée un fichier.class de bytecode : ExempleMontre.class Essayer l'option -verbose L'execution se fait à en appellant la machine virtuelle (JVM) : java ExempleMontre Création de la page html de documentation ExempleMontre.html javadoc ExempleMontre.java

23 Hello World public class Bonjour { public static void main (String[] arguments) { System.out.println("Hello World"); } La fonction main est une méthode static indépendante de l'instance commune à toute les instances, main peut être appelée sans quaucune instance soit créée : Bonjour.main(); System est une classe avec des attributs static (toujours pas besoin dinstance) out est une instance static de quelque chose (PrintStream) qui se trouve être une donnée de lobjet System (voir doc. de System). System.out référe donc un objet auquel on peut envoyer des messages. println est une méthode public de l'objet out.

24 Hello World - 2 public class Bonjour2 { public static void main (String[] arguments) { System.out.println("bonjour, voici vos arguments : "); for (int i=0; i javac Bonjour2.java Exécution : > java Bonjour2 1 deux 3.14 bonjour, voici vos arguments : 0 : 1 1 : deux 2 : 3.14 Pas besoin dune variable (argc) pour connaître la taille dun tableau Boucle for = comme en C Construction de la chaîne de caractère avec le signe +

25 Exécution 1/2 Qui exécute le programme que vous avez tapé et compilé ? Le processeur directement ? instruction par instruction ? A quoi servirait le système dexploitation alors ? A quoi servirait la machine virtuelle alors ? Le système dexploitation alloue un processus à la machine virtuelle : qui partage le CPU avec les autres processeurs, qui utilise un espace de mémoire virtuelle.

26 Exécution 2/2 La machine virtuelle JAVA alloue des Threads (fils dexécution) aux programmes JAVA 1 pour linitialisation 1 pour appeler les méthodes « callback » de linterface (si votre programme est abonné !) 1 par Thread que vous créez vous-même Les Threads sont gérés par lOS. La machine virtuelle termine lorsque le dernier thread du dernier programme se termine. Tout lespace mémoire est alors libéré (y compris la JVM) Ou bien appel direct à System.exit(0);

27 Espaces mémoires Registres La pile (stack), RAM mais stack pointer Le « tas » (heap), en RAM Stockage static Stockage constant Stockage hors de la RAM Capacité Rapidité

28 Documentation Format : Les commentaires dans le fichier.java doivent commencer par /**, finir par */ et chaque ligne doit commencer par une *.Il existe des étiquettes de champs telles que le nom d'auteur qui sont utilisées pour générer une API. Exemple : import java.util.* ; //Import ici, avant le commentaire javadoc /** * Une classe énumérant ses arguments. * Par exemple: * * java Bonjour2 un * bonjour * 0 : un * Marc Martin %I%, %G% */ public class Bonjour2... Génération : Pour générer la page Bonjour2.html, faire : > javadoc Bonjour2.java

29 Exemple de documentation HTML DETAIL: FIELD | CONSTR | METHODSUMMARY: INNER | FIELD | CONSTR | METHOD FRAMESFRAMES NO FRAMESNO FRAMES PREV CLASS NEXT CLASS Class Bonjour2 java.lang.Object | +-- Bonjour2 public class Bonjour2 extends java.lang.Object Une classe énumérant ses arguments. Par exemple: java Bonjour2 un bonjour 0 : un Bonjour2Bonjour2() Constructor Summary Help Index Deprecated Tree Class

30 … mainmain(java.lang.String[] arguments) static void Method Summary clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait Methods inherited from class java.lang.Object Constructor Detail Bonjour2 public Bonjour2() Method Detail main public static void main(java.lang.String[] arguments) DETAIL: FIELD | CONSTR | METHODSUMMARY: INNER | FIELD | CONSTR | METHOD FRAMESFRAMES NO FRAMESNO FRAMES PREV CLASS NEXT CLASS Help Index Deprecated Tree Class

31 Inconvénients de Java ? Interprété : inefficacité du code. La lenteur. Nécessite une JVM pour fonctionner. La gestion de la mémoire est inefficace dans la plupart des cas. Difficulté face aux applications gourmandes en mémoire. Moins de mécanismes objet que C++ pourtant plus ancien (héritage multiple et templates)

32 Avantages de Java ? Ecrire une fois, exécuter partout ! Sécurité. Exécution dans un navigateur Web (Applet). Gestion automatique de la mémoire. Programmation modulaire et dynamique. Lisibilité du code. Code compact (beaucoup est dans la JVM). L'API. Réseaux, interfaces, son, pont avec les bases de données en natif.

33 API Java Plus qu'un langage de programmation, l'environnement Java propose une API (Application Programmer's Interface) L'API est structurée en package Package : regroupement de classes ayant un lien logique entre elles pour les utiliser dans d'autres classes pour les « spécialiser » Pour programmer efficacement, une bonne connaissance de ces packages est indispensable. Ne pas refaire ce qui a déjà était fait (d'ailleur surement en mieux)

34 API Java : classes standard java.lang : classes essentielles objet, types de base, processus java.util : structures de données (collections) listes, ensembles, hashtables, arbres, itérateurs java.awt : interface graphique (Abstract Window Toolkit) fenêtres, boutons, événements... java.io : entrées / sorties flot de données provenant de fichier, buffer, ou pipe java.net : réseau URL, sockets java.rmi : objets distribués (Remote Method Invocation) java.sql : JDBC (Java Data Base Connectivity) connexion à une base de données relationnelle envoi de requêtes SQL, récupération des résultats java.beans : composants logiciels Pièces logicielles autonomes pouvant être contrôlées dynamiquement et assemblées pour former des applications javax.swings : interface graphique composants d'interface de plus haut niveau que ceux de awt look and feel indépendant de l'OS exploitation du modèle MVC (Model View Controler)

35 Versions Java (1996) : le JDK : Java Development Kit, 212 classes, 8 paquetages version minimale des browsers web. Java (1997) : 504 classes, 23 paquetages amélioration interface utilisateur (AWT), gestion des erreurs, cohérence du langage Java 1.2 (Java 2 en 1998) : 1520 classes, 59 paquetages Swing, Drag and drop, amélioration audio Java 1.3 (2001) J2SDK (nouveau nom) pour J2EE (Entreprise, serveur), J2ME (PDA) amélioration de la gestion mémoire, rapidité Java 1.4 (2002) : 2757 classes, 135 paquetages J2SDK J2SE (nouveau nom), XML, expressions régulières, nouvelles E/S, accès à la mémoire vidéo (VolatileImage) pour laccélération Java 1.5 (2005) : 3278 classes, 165 paquetages

36 Outils du JDK Téléchargeable sur le site java.sun.com Outils java : JVM, interpréteur pour les programmes java javac : Compilateur Java appletviewer : JVM pour l'exécution des applets jar : Création et manipulation d 'archive java javadoc : Générateur de documentation Java au format HTML javap : désassembleur de classes Java compilées jdb : débogueur Java en ligne de commande javah : génère le header C ou C++ pour créer un pont compatible entre java et C/C++ Documentation en ligne : Téléchargeable pour installation en local

37 IDE (Integrated Development Environment) Jedit Eclipse Emacs (avec JDEE)

38 Références Bien sur le site officiel de Sun avec JDK, Tutorials, Documentations, spécifications,... Le magazine électronique Les sites dédiés et En français : des FAQ, des ressources Le formidable « Thinking in Java » de Bruce Eckel en version livre (édition Prentice-Hall) ou éléctronique et gratuite (www.BruceEckel.com ou

39 Structure de données et méthodes

40 Types de données 2 grands types de données : types primitifs les variables contiennent des valeurs stockés sur la pile indépendant de l'architecture objets (instances de classes) les variables contiennent des références stockés sur le tas Les types primitifs existent en version objet ou « class », avec des méthodes associées : même nom de type avec la première lettre en majuscule. boolean Boolean

41 Types primitifs true or false A boolean value ( true or false ) boolean 16-bit Unicode character A single character char (autres types) 64-bit IEEE 754 Double-precision floating point double 32-bit IEEE 754Single-precision floating point float (nombres réels) 64-bit two's complementLong integer long 32-bit two's complementInteger int 16-bit two's complementShort integer short 8-bit two's complementByte-length integer byte (entiers) Taille et FormatDescriptionMot clé

42 Types et variables Déclaration de variable : NomType nomVariable (=valeur); Il est préférable d'initialiser les variables lors de leurs déclarations La portée de la variable est celle du bloc. Pour un objet la déclaration crée une référence et non un objet. la création nécessite la construction d'un objet (instanciation) : new. public class ProgVar { public static void main (String[] args) { // Integer intObjet; dans ce cas ce n'est qu'une référence Integer intObjet = new Integer(5); int varGlob = 0; { int varLoc = 0; varLoc = varLoc +1; } intObjet++; //erreur! varGlob = varLoc+1;//erreur! } Attention à la syntaxe JAVA Un bloc nest pas obligatoirement un if, un for ou un while VarLoc++; marche aussi linitialisation des variables nest pas obligatoire mais préférable

43 Affectation Comme en C, l'opérateur = désigne l'affectation le test d'égalité est == Une variable ne peut pas être utilisée avant d'être initialisée Float Temperature = null ; Interdit de poser une affectation comme condition if (maVar = getVar()) { … } L'affectation de deux variables objets est une coréférence o1 = o2; // o1 et o2 désigne le même objet Certaines valeurs spéciales sont des constantes float largestFloat = Float.MAX_VALUE;

44 Conversions La conversion numérique est faite automatiquement vers le type le plus riche dans une opération arithmétique La conversion peut être faite explicitement vers un type plus pauvre double natMoy = 2.1; int petiteFamilleType; petiteFamilleType = (int)natMoy ; // vaut 2 Int Alloc = petiteFamilleType * 1500; Hiérarchie des types : byte < short < int < long < float < double Attention à la syntaxe JAVA petiteFamilleType est initialisée après sa déclaration mais avant dêtre utilisée 2.7 est un double, 2.7f est un float

45 Constantes Déclarées avec le mot-clé final. final int HEURES_DANS_JOUR = 24; int jours; int heuresDansJours; jours = 7; heuresDansJours = jours * HEURES_DANS_JOUR; Attention à la syntaxe JAVA Les constantes sont en majuscules avec des _ entre les mots Les Variables commencent par une minuscule et utilisent uns majuscule à chaque nouveau début de mot

46 Conversions des types primitifs Y = YES N = No C = Cast (besoin de conversion explicite)

47 Ecritures dentiers et de réels 255 == 0xff == == 1024L == 0x400L 0.01 ==.01 == 1e-2d == 1e-2f double inf = 1/0; double neginf = -1/0; double neg0 = -1/inf; double NaN = 0/0; (Nan = not a number)

48 Opérateurs arithmétiques Opérateurs numériques : + - * / et += -= *= /= Division entière : % Exposant y = Math.pow( x, a ); Incrément et décrément : i++; x = y + --j; Méthodes de la classe java.lang.Math public static final double E; public static final double PI; public static double abs(double); public static float abs(float); public static int abs(int); public static long abs(long); public static native double acos(double); public static native double asin(double); public static native double atan(double); public static native double atan2(double, double); public static native double ceil(double); public static native double cos(double); public static native double exp(double); public static native double floor(double); public static native double log(double); public static double max(double, double); public static float max(float, float);

49 Méthodes de java.lang.Math public static int max(int, int); public static long max(long, long); public static double min(double, double); public static float min(float, float); public static int min(int, int); public static long min(long, long); public static native double pow(double, double); public static synchronized double random(); public static native double rint(double); public static long round(double); public static int round(float); public static native double sin(double); public static native double sqrt(double); public static native double tan(double); public static double toDegrees(double); public static double toRadians(double);

50 Opérateurs relationnels et booléens Opérateurs relationnels Égalité/inégalité de deux opérandes : ==, !=, >=, >= Opérateurs logique Opérateurs logiques : &&(and) ||(or) !(not) Opérateurs binaires : &(bitwise and) |(bitwise or) ^(xor) ~(not) Préséance des opérateurs entre eux : [ ] (). (params) expr++ expr-- ~ ! ++expr --expr * / % + - > = instanceof == != & ^ | && || ? : = += -= *= /= %= &= |= ^=

51 Tableaux 1/2 Principes et déclarations Les tableaux sont des collections de taille fixe d'objets de même type. double[] x = new double[10]; Allocation et initialisation simultanées L'appel de new est alors inutile. double[] y = { 0.0, 0.25, 0.5, 0.75, 1.0};

52 Tableaux 2/2 Affectation de tableaux Copie de valeur y[ 3 ] = 0.3; for (int i=0; i

53 Flot de contrôle Instruction conditionnelle : if (condition) {bloc 1} if (condition) {bloc 1} else {bloc 2} if (condition 1) {bloc 1} else if (condition 2){bloc 2} else {bloc N} if (x > y) { int tmp = x; x = y; y = tmp; } else { x = 0;... if ((x > s1)&& (x < s2)) y=3*x+1; else y=0;

54 Flot de contrôle - 2 Boucle tant que faire / répéter tant que while (condition) {bloc} do {bloc} while (condition) int i = 0; while (tab[i] != 0) i++; System.out.println(Le premier élément nul est en + i);... int somme=1; int i=borneSuperieure; do{ somme+=i i-- } while (i>0)

55 Flot de contrôle - 3 Boucle pour – for : for (expr1; expr2; expr3) {bloc} fonctionnement : expr1 if (expr2==true){ bloc expr3 } float moyenne= 0; // Initialisation d'un tableau d'entier int[] tab = { 2, 5, -1, 4, 3 }; for (int i =0; i < tab.length; i++) // conversion! moyenne+=tab[i]; moyenne /= tab.length; System.out.println("La moyenne est "+moyenne); // Si moyenne etait un int, la division // serait entière

56 Flot de contrôle - 4 switch nomVariable { case valeur1 : {... break; }... case valeurn : {... break; } default : {... break; } } ; Attention en JAVA : nomVariable : QUE de type intégral : boolean, char, int, long et short break; OBLIGATOIRE !

57 Contrôle 1/2 Interruption de boucle Interruption non étiquetée : sortie de la boucle la plus haute. while( i <= 100 ) { i += 10; if( i >= 2 * n + 1 ) { break; } Interruption étiquetée : sortie d'une boucle imbriquée. boucle_a_interrompre: while( i <= 100 ) { i += 10; while( i < j ) { i++; if( i >= 2 * n + 1 ) { break boucle_a_interrompre; }

58 Contrôle 2/2 Continuation de boucle = court-circuit de la fin dune itération var x = 0; while (x >= 10) { x++; if (x == 5) { continue; } document.write(i + '\n'); } Produira >

59 Mots réservés whilestaticinstanceofdo volatileshortimportdefault voidreturnimplementscontinue trypublicifconst * transientprotectedgoto * class throwsprivateforchar throwpackagefloatcatch thisnewfinallycase synchronizednativefinalbyte switchlongextendsbreak superinterfaceelseboolean strictfp ** intdoubleabstract

60 Caractères d'échappement Java anti-slash \\u005c\\ Caractère unicode\u \u00ff\uXXXX Caractère Latin-1 en base 8\000 - \377\XXX guillemet simple '\u0027\' guillemet double "\u0022\" retour chariot CR (carriage return)\u000d\r saut de page FF (form feed)\u000c\f fin de ligne LF (line feed)\u000a\n tabulation horizontale HT (horizontal tab)\u0009\t effacement en arrière BS (backspace)\u0008\b DescriptionValeur UnicodeCaractère

61 Chaîne de caractère Initialisation, affectation et concaténation : String intro = "Ce programme peut écrire "; String affiche; // redéfinition de = affiche = intro + "une chaîne de " + (50 + 2) + "caractères."; System.out.println( affiche ); Sous-chaînes String motConstruit = "Sous-chaîne"; String racine = motConstruit.substring( 5, motConstruit.length() - 5 ); char tiret = motConstruit.charAt( 4 ); Voir la doc de la classe

62 Chaîne de caractère - 2 Égalité entre chaînes : Égalité de valeurs : méthode equals() if( racine.equals( "chaîne" ) ) { System.out.println( "Égalité de valeurs" ); } Attention : String s1 = new String(bonjour); String s2 = new String(bonjour); if (s1 == s2) System.out.println(C'est egal); else System.out.println(Différent); Différent !

63 Chaîne de caractère - 3 Mutabilité Les String ne sont pas mutables. Le contenu ne peut pas être modifié. Toute opération créé une nouvelle chaîne. String text = "Le vilain petit canard"; text += " devient un beau cygne !"; // provoque la suppression de "Le vilain petit canard« StringBuffer Sont mutables (utilisés pour les +) StringBuffer ch = new StringBuffer("Jean fait comme "); ch = ch.append("il peut pour travailler\n"); ch = ch.replace(ch.indexOf(" peut ") + " ".length(), ch.indexOf("pour"), "veut "); System.out.println (ch);

64 Chaînes : Entrée Lecture d'une chaîne au clavier InputStreamReader is = new InputStreamReader( System.in ); BufferedReader bf = new BufferedReader( is ); String chaineAAnalyser = ""; System.out.print( "Entrez une chaîne : " ); try{ chaineAAnalyser = bf.readLine(); } catch(IOException IOException_Arg) { System.out.println(IOException_Arg.getMessage()) ; }

65 Chaînes : Affichage Sortie non formatée Affichage sans limite sur le nombre de décimales double x = 1.0 / 3.0; System.out.println( x ); Formattage des entiers Création d'un format d'affichage numérique DecimalFormat df = new DecimalFormat( "0.###" ); System.out.println( df.Format( x ) ); Formats : affichage d'un pourcentage % préfixe des nombres négatifs - séparateur du format nombres positifs et du format nombres négatifs ; séparateur de groupements, symbole décimal. chiffre non visible si 0 de complément # chiffre 0

66 Méthode Les Méthodes sont l'équivalent des fonctions ou procédures. Elles permettent de : factoriser du code, structurer le code, servir de « sous programmes utilitaires » aux autres méthodes de la classe. En java, plusieurs types de méthodes : opérations sur les objets (envoi d'un message), opérations statiques (méthodes de classe) exemples Math.random(); LectureClavier.lireEntier(); Un principe issu du « procédurale » reste d'actualité : une bonne méthode (ou fonction) est courte, sinon, elle est mauvaise et doit être repensée et/ou decomposée.

67 Méthodes statiques : déclaration « Une déclaration de méthode définit du code exécutable qui peut être invoqué, en passant éventuellement un nombre fixé de valeurs comme arguments » The Java Langage Specification J. Gosling, B Joy, G. Steel, G. Bracha Pour une méthode statique : static nomMethode( ) { } static void printFloat(String s, float f) { prt(s + " = " + f); } static int max (int tab[]) { int maxi = tab[0]; for (int i=1 ; i maxi) maxi=tab[i] } return maxi; } void = la méthode ne renvoie « rien » Si le type de retour n'est pas void,le retour est obligatoirement effectué par au moins un return. return implique un retour au programme appellant. maxi est une variable « locale ». return est utilisable Même si typeRetour==void.

68 Méthodes statiques : Passage des paramètres Le passage des paramètres se fait par valeur. Les 2 méthodes echange n'ont pas la même signature : surcharge Dans les 2 cas, vu de l'appellant (ici le main), les valeurs des paramêtres a et b ne sont pas modifiées. public static void echange(int a, int b) { int tmp = a ; a = b; b = tmp; } public static void echange(Integer a, Integer b) { Integer tmp = a; a = b; b = tmp; System.out.println("dedans :" + a + " " + b); } public static void main(String[] args) { Integer a = new Integer(3); Integer b = new Integer(4); int x = 3; int y = 4; echange(x,y); System.out.println("Après :" + x + " " + y); echange(a,b); System.out.println("Après :" + a + " " + b); } Après :3 4

69 Méthodes statiques : invocation En usage « interne » l'appel est : nomMethode (liste des params effectifs); Pour appeller la méthode echange à partir d'une autre classe : Test.echange(a,b); En spécifiant le nom de la classe en préfixe : à qui le message est envoyé ! (il n'y a pas d'objet) Tout Comme : System.out.println(...); public static void echange(int a, int b) { int tmp = a ; a = b; b = tmp; } public static void echange(Integer a, Integer b) { Integer tmp = a; a = b; b = tmp; System.out.println("dedans :" + a + " " + b); } public static void main(String[] args) { Integer a = new Integer(3); Integer b = new Integer(4); int x = 3; int y = 4; echange(x,y); System.out.println("Après :" + x + " " + y); echange(a,b); System.out.println("Après :" + a + " " + b); } Après :3 4

70 Méthode d'objet Par opposition aux méthodes de classe (static) La signature s'écrit de la même manière au sein de la classe, sans le mot clé static : nomDeMethode(liste des params formels) Nécessite l'existence d'un objet pour être invoquée : monObjet.laMethode(liste des params effectifs); Le constructeur est une méthode particulière. public static void main(String[] args) { Integer a = new Integer(3); Integer b = new Integer(4); int x = 3; // x+=a; est incorrect x+=a.intValue(); System.out.println("x = " + x); } x = 6;

71 Programmation Objet en JAVA

72 Plan Objets et Classes Encapsulation, POO, Classe et Instances, references, conseils de conception Héritage Concepts, Hiérarchie, Constructeurs, Transtypage, Polymorphisme Héritage 2 Polymorphisme (Fin), Modificateurs, super, Polymorphisme contraint, Exception et Entrées-sorties Rattrapage, Jet, Signature et Héritage, Chaine d'entrées-sorties, Sérialisation SWING, Dessin et Evénements Hiérarchie de composants, placement, machine à dessin, événements Thread et Réseau Timer, Cycle de vie, Synchronisation Verrou, Socket, Client-Serveur

73 Programmation Objet en JAVA Classes et Objets Encapsulation, POO, Classe et instances, conception OO

74 Introduction Programmation fonctionnelle Des fonctions et leurs résultats Programmation impérative ou procédurale Des ordres (éventuellement avec des fonctions) Programmation Orientée Objet (POO) Un programme est divisé en plusieurs modules (objet)indépendants. Les modules sont chargés en mémoire à lexécution. Le concepteur fait évoluer ses modules en parallèle. Les modules sont typés comme des int et des float Le type de module est aussi important que le module lui-même, Le type d'un objet est sa classe

75 Les objectifs de la POO Permettre la description d'un problème à l'aide de termes liés au problème et non à la machine : par l'identification et la définition des concepts et des objets, mise en oeuvre de leurs interactions Tout est objet. Il contient ses données (attributs), et possède une interface (méthodes publiques) permettant de lui adresser des requêtes (ou des messages) Un programme est un ensemble d'objet qui communiquent entre eux (envoi de message). Chaque objet est construit à partir d'autre objets et possède sa mémoire propre. Un objet a un type. Il est l'instance d'une classe. Les objets d'un même type peuvent recevoir les mêmes messages. La distinction la plus importante entre objets de classes différentes est « quels messages peut-on lui envoyer ? »

76 Qu'est-ce qu'un objet ? Un objet modélise toute entité identifiable manipulée par l'application logicielle qu'elle soit tangible ou conceptuelle (ville, étudiant, fenêtre vs date, emploi du temps), générique ou spécifique (pile LIFO vs catalogue de disquaire). Il réagit aux messages qui lui sont envoyés en fonction de son état. Un objet possède : une identité unique un état interne définit par ses attributs un comportement définit par ses méthodes.

77 Exemple 1 public class etudiant { String nom; int promo; String traiterExam(String enonce) {…} } public class prof { String nom; String faireSujetExam() {…} int corrigerExam(String copie) {…} } Attributs Méthodes

78 Principe d'encapsulation - 1 Un objet = des données (attributs) + algorithmes (méthodes) Principe d'encapsulation : L'accès aux données (privées) ne peut se faire que par l'intermédiaire de l'interface (méthodes publiques). Les modifications des structures de données n'affectent pas les programmes qui utilisent l'objet. Réutilisation.

79 Principe d'encapsulation - 2 Se placer dans la situation : « developpeur de la classe » / « utilisateur de la classe » Combinaison de données et de méthodes dans un emballage unique (un objet). L'implémentation n'est pas accessible aux utilisateurs L'altération ou l'accès à l'état d'un objet se fait essentiellement par ses méthodes Encapsulation = regroupement et organisation de linformation. Une bonne encapsulation crée un code sûr, maintenable et réutilisable !

80 Concepts Objet : terminologie Classe Un patron Une description de la boîte noire Un type Instance Un modèle réalisé avec le patron Une boîte noire dynamique Un objet Référence Un pointeur vers une instance Une adresse dune boite noire dynamique Un fournisseur de service Homme Bill Clinton Georges W. Bush Hillary Clinton Président des USA Conjoint du Président des USA

81 Concepts Objet : en mémoire La classe est chargée une seule fois Les instances sont chargées dynamiquement autant de fois quil y a dinstances dans le programme Un compteur est créé pour chaque instance A chaque fois quune nouvelle variable fait référence à linstance compteur++ A chaque fois quune référence est perdue (sortie de boucle) compteur- - Quand (compteur==0), la JVM libére la mémoire Quand la JVM libère la mémoire dun objet, compteur- - pour les attributs de linstance détruite ! Si dernière référence => destruction en chaîne Si co-référence : problème (Simple OK pour java)

82 Concepts Objet : en pratique Méthode = une fonctionnalité interne / externe privée / public Variable d'instance : Variable typé (primitif ou objet) Appartient à un objet Variable de classe Partagé par toutes les instances de la classe (mot clé static) Objet = données + méthodes Programmation Objet = Définir, implémenter si besoin les types d'objet : les classes nécessaire Création d'un ensemble dobjets Interaction Attention à la terminologie Classe / Instance cest clair Objet = moins clair, pourtant cest le terme le plus utilisé

83 Le fichier source d'une classe import java.util.Date; import javax.swing.*; /** Le premier programme Java * Application donnant heure et date John Doe 0 */ public class ExempleMontre{ /* Ici sont définis les attributs et * méthodes, en finissant par le main. */ public static void main(String[] args) { /* corps de la méthode main */ } Lorsqu'on utilise une classe pré-défini, il faut indiquer au compilateur où est le code correspondant : import. On peut importer une classe (Date) ou toutes les classes d'une collection. Lors de la création d'une application, une des classes public doit porter le même nom que le fichier et comporter une méthode main. Les commentaires commençant par /** sont destinés à javadoc. Les commandes javadoc commence par ». Il est possible d'utiliser également du html. Tout programme, toutes les classes, les attributs et méthodes sont à commenter afin de générer une documentation via javadoc. Fichier ExempleMontre.java

84 Exemple de classe type public class Etudiant { // les attributs sont privés private String nom; private int promo; // Les constructeurs Etudiant(){ nom = « Toto »; promo = 0; } Etudiant(String n, int p){ nom = n; promo = p; } // L'interface : ici les // assesseurs setter & // getter public String getNom(){ return nom; } public int getPromo(){ return promo; } // et les algo nécessaires. public String traiterExam(String enonce){…} }

85 Définition des accès Dans un objet l'accès et l'utilisation d'un attribut ou d'une méthode est contrôlé : public : tout le monde peut y acceder, entre autre un utilisateur le « client programmeur ». Définit l'interface de la classe. private : accès interne à l'objet Selon le principe d'encapsulation, les attributs doivent être « private » le « friendly package acces » : public pour les classes du même package protected : public pour les classes qui héritent (nous y reviendrons plus tard)

86 Notions de Programmation OO Responsabilités Chaque objet est responsable de l'accomplissement des tâches qui lui sont associées. Les objets clients envoient des messages aux objets serveurs. Eléments Les éléments de base sont des objets qui sont des instances d'une classe. les propriétés génériques d'un objet sont au niveau de la classe, l'état d'un objet est décrit au niveau de linstance, les classes sont organisées hiérarchiquement et bénéficient d'un mécanisme d'héritage automatique.

87 Définition de classe Les variables d'instance définissent l'état d'une instance. public class etudiant { String nom; int promo; } Méthodes de construction Constructeur : Exécuté à la création d'une nouvelle instance tout de suite après le chargement en mémoire. Méthodes d'altération initialisent, modifient ou annulent la valeur des variables d'instance. Méthodes d'accès lisent les valeurs des variables d'instance.

88 Portée des attributs Les variables sont visibles à l'intérieur du bloc de définition mais... public class Point { private int x; private int y; public int getX() { return x; } public static void main(String[] args){ // Attention ici x (int) l'attribut // n'est pas accessible } Cannot make a static reference to the non-static field x

89 Exemple : Classe Point public class Point // une classe { int x; // variable d'instance int y; // variable d'instance public int getX() { // accès return x; } public void setX(int abscisse) { // altération x = abscisse; } public int getY() { return y; } public void setY(int ordonnee) { y = ordonnee; } Attention aux conventions Java setXXX() et getXXX() sont plus ou moins officiels et aident beaucoup à la lisibilité Regroupement du set et du get correspondant plutôt que tous les get (resp. set) ensemble

90 Constructeurs – 1 Des méthodes permettant de construire et préparer l'objet à utiliser : Construction et initialisation selon les souhaits du programmeur Si aucun constructueur est définit alors, il existera un constructeur par défaut qui initialise les variables à leurs valeurs par défaut : NomClasse() Si une classe a un constructeur, il n'y a plus de constructeur par défaut Il peut y avoir plus d'un constructeur par classe avec des signatures différentes public class MaClass { /* Les attributs */ /* Les constructeurs */ public MaClass(String nom){...} public MaClass(String nom,int nb) {...} /* L'interface */ /* Les méthodes privées */ public static void main(String[] args){ /* MaClass mc=new MaClass(); * c'est interdit ! */ String n = un nom ; int i = 5; // par contre MaClass mc1=new MaClass(n); MaClass mc2=new MaClass(n,i); }

91 Constructeurs – 2 Construction et initialisation selon les souhaits du programmeur Indispensable avec le principe d'encapsulation ! L'opérateur new permet de Charger les méthodes de la classe en mémoire si cest la première fois quun objet de ce type est invoqué Créer linstance en mémoire (Réserve exactement la taille de mémoire pour les données et les initialisent avec leur valeurs par défaut) Lancer le constructeur (Correspondant aux arguments donnés) Le constructeur peut appeler dautres méthodes de linstance (y compris dautres constructeurs) ou de la classe.

92 Exemple dinstance : unPoint import Point; // on a besoin de la classe Point public class TestPoint { public static void main(String[] arg) { Point unPoint new Point();// une variable objet unPoint.setX(10); unPoint.setY(100); System.out.println("point\n\t d'abscisse " + unPoint.getX() + "\n"+"\t et d'ordonnée "+ unPoint.getY()); } }// Fin class TestPoint

93 Exemple : Homme/President public class USA { protected Homme president = null; private Population[] etats = new Population[NB_ETATS]; public final int NB_ETATS = 50; public static void main(String[] arg) { Homme billClinton = new Homme("Bill", "Clinton",...); Femme hillaryClinton = new Femme("Hillary", "Clinton",...); billClinton.setConjoint(hillaryClinton); hillaryClinton.setConjoint(billClinton); } // ne doit etre appelle que par election() private setPresident(Homme newPresident) { president = newPresident; } // ne doit etre appelle que par lobjet AssembleeNationale public election(Homme candidat1, Homme candidat2) { for (int i=0; i

94 Questions president nest pas une instance (référence) Comment être sûr quune référence pointe vers une instance ? Et si le président est une femme ? Et s'il y a plus de deux candidats ? Qui créé AssembleeNationale ? Si on a une classe Assemblee et plusieurs instances (France, GB, USA, …) comment être sur que lassemblée américaine est la seule à convoquer une élection aux USA ? Qui est au dessus de qui ?

95 Notion de surcharge Plusieurs méthodes de même nom mais de signatures différentes (liste d'arguments+type de retour). public void setEtudiant(String unNom, int unePromo) { nom = unNom; promo = unePromo; } public void setEtudiant(String unNom) { nom = unNom; promo = 0; } La surcharge permet une initialisation explicite des variables d'instance. Un constructeur par défaut est un constructeur sans argument. public Etudiant() { nom = "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"; promo = 0; }

96 Auto-Référence (this) Dans une méthode, le mot-clé this fait référence à l'objet sur lequel opère la méthode. System.out.println( this ); On peut imprimer toute instance en JAVA. L'impression fait appel à la méthode toString() (héritée de Object). Dans un constructeur, le mot-clé this en début d'un constructeur désigne un autre constructeur de la même classe. public Etudiant() { this( "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX" ); } À consommer avec modération !

97 Le package Un package = regroupement cohérent de classes. import java.util.*;// invoque toutes les classes du package import java.util.ArrayList; //uniquement 1 classe Pour constituer un package : L'utilisation se fait soit via import soit comme ceci : Mettre toutes les classes d'un même package dans un même repertoire Attention aux noms utilisés. package dir1.dir2.mypackage; Indique le chemin pour trouver les fichiers.class à partir du CLASSPATH package mypackage; public class MyClass{...} mypackage.MyClass m = new mypackage.MyClass();

98 Conseils de conception 1/3 Les règles fondementales : Privatiser les données, principe d'encapsulation. Soigner l'interface. Initialiser les données : éviter de faire appel aux initialisations par défaut qui sont source d'erreur. Soigner les constructeurs. Limiter les variables d'instances : les regrouper dans une classe si appropriée si nécessaire. Utiliser un format standard pour la définition des classes : (1) constructeurs, (2) éléments publics, (3) éléments accessibles au paquetage, (4) éléments privés Utiliser un outil (IDE) qui tienne compte de lorganisation Package/Classe/Fonction Utiliser un navigateur pour laide et pour google !

99 Conseils de conception 2/3 Nommer explicitement : classes et variables doivent avoir des noms clairs (donc longs) et explicitant leur type (verbes pour méthodes et noms pour classes). Diviser pour mieux régner : les classes trop lourdes doivent être disperser en plusieurs classes. Commencer par une analyse du problème. Imaginer une solution composée de travailleurs humains. Traduire en objets en tenant compte des spécificités des ordinateurs par rapport aux humain Temps de calcul, place en mémoire Cohérence et nombre des méthodes Intuitivité de votre organisation du travail par rapport aux autres

100 Conseils de conception 3/3 Faire des schémas Représentant les classes Pour comprendre les interactions entre les classes (qui a besoin dune référence sur qui) Pour savoir ou placer une fonction Représentant les appels de fonction Pour savoir quels objets sont traversés Pour savoir où récupérer les données à mettre en argument Les fonctions qui ne font rien dautre quappeler une autre fonction sont fréquentes Dans les langages à objet compilés on les « inline » pour ne pas perdre de temps à lexécution

101 Reprenons : la classe Une classe décrit, définit, implémente un type d'objet : ses attributs et ses méthodes son interface (public) et sa partie private. Elle doit être utilisable, réutilisable, évolutive : principe d'encapsulation interface bien pensée Une classe est un modèle de définition pour des objets ayant même structure (même ensemble d'attributs), même comportement (mêmes opérations, méthodes), une sémantique commune. Une classe n'est pas un objet. Un objet est l'instanciation d'une classe (et une seule), une représentation dynamique, « vivante ».

102 Reprenons : l'objet Un objet est l'instanciation d'une seule classe. conforme par construction au « modèle » : constructeur. Chaque objet est unique : son espace mémoire, ses attributs propres et donc son état sa référence Un objet se manipule via sa référence. Référence perdue, objet perdu. Un objet n'est pas une classe.

103 Reprenons : POO en Java Bien comprendre les concepts, les méthodes objets (indépendemdent de Java). Connaître Java et ses spécificités. Bien connaître et savoir utiliser l'API Java. Savoir construire des classes réutilisable (par vous déjà). Pratiquer !

104 Exercice : la classe disque Créer la classe Disque Diamètre Epaisseur Matière (bois, fer ou verre) Peint ou brut Méthodes de Calcul du volume (π x R 2 ), de la masse (vol*masse vol fer=7,8 kg/l bois=0.8, verre=2.5) Créer la classe Pile de Disque Son ensemble déléments Des fonctions pour se faire manipuler de lextérieur empiler() depiler() sommet() enlever() = depiler()+sommet() Créer la classe InterfaceUtilisateurTexte Trois Piles (A, B, C),

105 Programmation Objet en JAVA Réutilisation, Héritage 1 Agrégation, composition, héritage, Hiérarchie, Constructeurs, Transtypage, Polymorphisme

106 Rappel : classe et objet public class Point { double x; double y; public Point(double i, double j) {...} public void déplacer (double dx, double dy) {...} public double distanceOrigine (){ return Math.sqrt(x*x+y*y); } } Nom de la classe : explicite commençant par une majuscule Attributs Constructeur(s) Méthodes

107 Rappel : classe et objet public class Point { private double x; private double y; public Point(double i, double j) {...} public void déplacer (double dx, double dy) {...} public double distanceOrigine (){ return Math.sqrt(x*x+y*y); } } Principe d'encapsulation les attributs sont totalement protégés Ils ne sont plus accessibles de l'extérieur : c'est l'objet qui contrôle. Mais accessibles en interne. Point p new Point(1,2); p.x = 3; // Interdit p.y = 5; // Privés ! Point p2 new Point(1,2); p2.x = p1.y + p2.y; // Interdit Conséquences de l'encapsulation Contrôler l'accès aux attributs via la création de getter&setter. Ajouter : public double getX(){...}....

108 Rappel : Jedit

109 Réutilisation ? Comment utiliser une classe comme matériau pour concevoir une autre classe répondant à de nouveaux besoins ? Quels sont les attentes de cette nouvelle classe ? besoin des «services» d'une classe existante (les données structurée, les méthodes, les 2). faire évoluer une classe existante (spécialiser, ajouter des fonctionalités,... ) Dans une conception objet, des relations sont définis, des règles d'association. Un objet fait appel un autre objet. Un objet est crée à partir d'un autre : il hérite.

110 La relation client/serveur - Agrégation Un objet o1 de la classe C1 utilise un objet o2 de la classe C2 via son interface (attributs, méthodes). o1 délègue une partie de son activité à o2. Faire une référence dans C1 vers un objet de C2; Attention o2 est autonome, indépendant de o1. Il peut être partagé. C'est une agrégation. public class C1 { private C2 o2;... } public class C2 {... } Le clientLe serveur

111 La relation client/serveur - Composition Mais si o2 évolue, est-ce grave? Comment faire pour que o1 possède son o2 à lui. La solution se trouve dans le constructeur de C1 : doter o1 d'un objet o2 qui lui appartienne. C'est une composition. public class C1 { private C2 o2;... C1(...){ o2 = new C2(...); }... } public class C2 {... } Le clientLe serveur

112 L'exemple du cercle Le cercle c1 a un centre. C'est le point p1. Utilisation d'un objet de type Point, car la classe existe déja. Si agrégation, tout changement effectué sur p1 a des conséquences sur c1. Mais plusieurs cercle peuvent partager le même centre... Impossible si composition. ça se discute ! Question : A-t-on besoin du code source de la classe Point pour coder la classe Cercle ?

113 Nouveau problème Si le serveur est insuffisant, incomplet, inadapté ? un objet Point répond à un besoin «mathématique». Si on veut en faire un objet graphique, avec une couleur et qu'il soit capable de se dessiner ? Mais en gardant les propriétés et les fonctionalités d'un Point. La solution en POO : l'héritage. Définir une nouvelle classe à partir de la définition d'une classe existante. Spécialiser, augmenter.

114 Héritage public class LaClasseFille extends LaClasseMere{...} class PointAvecUneCouleur extends Point En java, on n'hérite que d'une seule classe.

115 Exemple en Javadoc 1/2 javax.swing Class AbstractButton java.lang.Object | +--java.awt.Componentjava.awt.Component | +--java.awt.Containerjava.awt.Container | +--javax.swing.JComponentjavax.swing.JComponent | +--javax.swing.AbstractButton All Implemented Interfaces: ImageObserverImageObserver, ItemSelectable, MenuContainer, Serializable, SwingConstantsItemSelectableMenuContainerSerializableSwingConstants Direct Known Subclasses: JButtonJButton, JMenuItem, JToggleButtonJMenuItemJToggleButton implements ItemSelectable, SwingConstantsItemSelectableSwingConstants Defines common behaviors for buttons and menu items. For further information see How to Use Buttons, Check Boxes, and Radio Buttons, a section in The Java ….. How to Use Buttons, Check Boxes, and Radio Buttons

116 Exemple en Javadoc 2/2 Class java.lang.Object … class java.awt.Component (implements java.awt.image.ImageObserver, …ComponentImageObserver class java.awt.ContainerContainer class javax.swing.CellRendererPane (implements javax.accessibility.Accessible)CellRendererPaneAccessible class javax.swing.JComponent (implements java.io.Serializable)JComponentSerializable class javax.swing.AbstractButton (implements java.awt.ItemSelectable, …AbstractButtonItemSelectable class javax.swing.JButton (implements javax.accessibility.Accessible)JButtonAccessible class javax.swing.JMenuItem (implements javax.accessibility.Accessible, …JMenuItemAccessible class javax.swing.JCheckBoxMenuItem (implements …JCheckBoxMenuItem class javax.swing.JMenu (implements javax.accessibility.Accessible, …JMenuAccessible class javax.swing.JRadioButtonMenuItem (implements …JRadioButtonMenuItem class javax.swing.JToggleButton (implements javax.accessibility.Accessible)JToggleButtonAccessible class javax.swing.JCheckBox (implements javax.accessibility.Accessible)JCheckBoxAccessible class javax.swing.JRadioButton (implements javax.accessibility.Accessible)JRadioButtonAccessible class javax.swing.Box (implements javax.accessibility.Accessible)BoxAccessible class javax.swing.Box.Filler (implements javax.accessibility.Accessible)Box.FillerAccessible class javax.swing.JColorChooser (implements javax.accessibility.Accessible)JColorChooserAccessible class javax.swing.JComboBox (implements javax.accessibility.Accessible, …JComboBoxAccessible …

117 Concept dhéritage Concept fondemental des langages objet. Dériver une nouvelle classe à partir d'une classe existante en récupérant ses propriétés. Avantage Réutilisation : factorisation, enrichissement de champs et méthodes de classes existantes. Spécialisation dune classe existante sans la modifier. Pas de limitation en profondeur. Contrainte Héritage simple : une classe ne peut hériter que d'une seule classe. Toutes les méthodes et champs ne sont plus regroupées dans le même fichier

118 Hiérarchie en Héritage L'héritage est une notion transitive Hiérarchie d'héritage : l'ensemble des classes dérivées d'un parent commun. Attention ce n'est pas bijectif : un Point3D est un Point. Le contraire est faux. is-like relation Chaîne d'héritage : le chemin menant d'une classe vers ses ancêtres.

119 Exemple d'héritage import Point; public class PointAvecUneCouleur extends Point { int couleur; // x et y sont hérités public PointAvecUneCouleur(int x, int y, int couleur) // un constructeur { super(); // appel au constructeur de la classe mère setX(x); setY(y); setCouleur(couleur); } public PointAvecUneCouleur(int couleur) // un constructeur { super(); // appel au constructeur de la classe mère setCouleur(couleur); } public void setCouleur(int couleur) { this.couleur=couleur; // désigne l'objet encours }

120 Exemple d'utilisation des constructeurs PointAvecUneCouleur p1,p2,p3; x=10, y=100, couleur=1000 p1=new PointAvecUneCouleur(10,100,1000); x=y=0 (valeur par défaut), couleur=5 p2=new PointAvecUneCouleur(5); Mais ce qui est impossible : p3=new PointAvecUneCouleur(); p4=new Point (10,100,1000);

121 Retour sur protected Dans la classe Point pourt setX on a 3 possibilité : public : un objet PointAvecUneCouleur peut fixer l'abscisse,... également tout le monde. private : plus personne ne peut, y compris un objet PointAvecUneCouleur. protected : la solution ici, les objets d'une classe héritière ont accès aux membres protected (+friendly). public void setX (double nouveauX){...} private void setX (double nouveauX){...} protected void setX (double nouveauX){...}

122 Transtypage et héritage 1/2 Le transtypage consiste à convertir un objet d'une classe en objet d'une autre classe Vers une «super-class» (upcast), c'est toujours possible : on peut toujours transtyper vers une super-classe, plus pauvre en informations. Point3D unPoint3D = new Point3D( x, y, z ); Point unPoint = (Point) unPoint3D; // une projection sur xOy La mention du transtypage est facultative, mais recommandée pour la lisibilité. Attention : unPoint3D est de type Point3D mais aussi Point. « un Point3D est un Point mais pas le contraire. » Un message envoyable à un objet, l'est aussi pour tous les objets d'une classe héritière : PointAvecUneCouleur p = new PointAvecUneCouleur(); p.translater(1,3); // Méthode définit au niveau de Point

123 Transtypage et héritage 2/2 Le comportement d'un objet «hérité» est augmenté par rapport à un objet d'une classe mère. Vers sous-classes (downcast) Impossible sauf si appartenance : pour transtyper vers une sous- classe, utiliser le mot-clé réservé instanceof. if( unPoint instanceof Point3D) { unPoint3D = (Point3D) unPoint; unPoint3D.projection3D(...); } La mention du transtypage est obligatoire, dans ce cas. Quand le compilateur retourne une erreur " bad class... ", ne pas transtyper mais : Réfléchir a lerreur… Ne devrait-on pas demander en argument un type plus précis ? Dois-je tester le type avant de transtyper ?

124 Surcharge et redéfinition (overload vs override) public class BaseClasse {... public void maMethode(int i){...} } public class filleClasse2 {... public void maMethode(int i){...} } public class filleClasse1 {... public void maMethode(double i){...} } Redéfinition Surcharge Pour un objet filleClasse1 : 2 méthodes maMethode Pour un objet filleClasse2 : une seule maMethode

125 Exemple animalier Animal ChevalOursTortue manger dormir marcher courir (2 x marcher) espèce galopercourirhiberner Cheval de courseCheval de traie galoper

126 La classe "Object" Toutes les classes Java sont des descendants de la classe Object. Object est parent par défaut des classes qui ne précisent pas leur ancêtres Object offre quelques services génériques dont la pluspart sont à refaire,... à redéfinir : public final Class getClass(); Renvoie un objet de type Class qui permet de connaître le nom d'une classe public boolean equals(Object o); Compare les champs un par un (pas les pointeurs mémoire comme ==) protected Object clone(); Allocation de mémoire pour une nouvelle instance d'un objet et recopie de son contenu public String toString(); Renvoie une chaîne décrivant la valeur de l'objet

127 La classe "Class" C'est la classe qui identifie les types à l'exécution Permet la sélection des méthodes en fonction de la classe lors des appels public String getName(); Renvoie le nom d'une classe public static Class forName(String s); La fonction réciproque de getName public Object newInstance(); Crée une nouvelle instance de même type public String toString(); Renvoie une chaîne décrivant la valeur de l'objet

128 La fonction equals() Egalité entre objet et non entre référence Très utile pour les String – If (myString == "Hello") {…} Toujours Faux !!! – If (myString.equals("Hello") ) {…} OK Si les 2 objets o1 et o2 ont des références r1 et r2 comme champs, il faut que r1==r2 pour que o1.equals(o2) et non pas que r1.equals(r2) Réflexive, symétrique, transitive et consistent null.equals(null) mais aucune autre instance oi telle que oi.equals(null) Point p1 = new Point(2,1); Point p2 = new Point(2,1); if (p1==p2){...} // Ici c'est faux if (p1.equals(p2)){...}// OK si equals est bien redéfinit p1 = p2 // Co-référence if (p1==p2){...} // Vrai désormais

129 Les fonctions hashCode() et toString() hashCode() renvois un chiffre différent pour toute instance différente Si o1.equals(o2) alors o1.hashCode()==o2.hashCode() Le contraire nest pas assuré mais préférable toString() conversion en String d'un objet : String s = '' mon objet visible '' + monObjet; String s = '' mon objet visible '' + monObjet.toString(); Nom unique utile pour tracer la vie dune instance

130 Classes enveloppes 1/3 Les classes enveloppes fournissent une contrepartie sous forme de classes aux types primitifs Les classes enveloppes sont final, donc non surchargeables Nombres entiers Nombres entiers longs Nombres décimaux Nombres décimaux en double précision Booléens Octets Caractères (Unicode) Type vide int long float double boolean byte char void Integer Long Float Double Boolean Byte Character Void

131 Classes enveloppes 2/3 Quelques méthodes de la classe Integer par exemple : public int intValue(); Renvoie la valeur entière de l'objet (type int). public static int parseInt(String s); Renvoie la valeur entière de l'objet si l'objet spécifié représente la chaîne d'un nombre entier en base 10. public static Integer valueOf(String s) Renvoie un objet Integer si la chaîne s représente un nombre entier en base 10. Exemple : Integer unInteger = new Integer(100); int d = unInteger.intValue();

132 Classes enveloppes 3/3 Pas de modificateur Pas de Float f1 = new Float(); car pas possible de le changer ultérieurement Fonction equals() pour comparer Beaucoup de fonctions statiques (pas besoin de faire de new pour les utiliser) Float, Byte, Integer peuvent tous retourner une valeur int, float, etc. car héritage de Number Comparable Fonction compareTo()

133 La classe Vector Une liste indexée Comme un tableau de Object mais de taille variable Gère sa capacité daccueil en fonction dune stratégie doptimisation de la mémoire addElement(…), removeElement(..), removeAllElement(), elementAt(int i), size(), toArray() Accepte des instances de nimporte quel type Retourne des Objects a vous de transtyper (downcast)! elements() permet retourner une Enumeration

134 Enumeration Permet dénumérer des éléments et de faire des boucles avec une notation simple Sun dit … for (Enumeration e = v.elements() ; e.hasMoreElements() ;) { System.out.println(e.nextElement()); } Fred préférerait … for (Enumeration enumeration1 = vector1.elements() ; enumeration1.hasMoreElements(); ) { MaClasse monInstance = (MaClasse)enumeration1.nextElement(); monInstance.maFonction(...); }

135 Exemple présidentiel 1/2 public class USA { protected Homme president = null; private Vector etats = new Vector(); public final int NB_ETATS = 50; public static void main(String[] arg) { USA TheUSA = new USA(); } public USA(){ etats.add(new Population("Alabama", )); etats.add(new Population("Alaska", )); etats.add(new Population("Arizona", )); etats.add(new Population("Arkansas", )); etats.add(new Population("California", )); }

136 Exemple présidentiel 2/2 // ne doit etre appelle que par lobjet AssembleeNationale public elirePres(Homme cand1Arg, Homme cand2Arg) { int resultat1,resultat2 = 0; for (Enumeration enum = etats.elements(); enum.hasMoreElements();) { Population population1 = (Population)enum.nextElement()); int choix1= population1.choose(cand1Arg,cand2Arg); resultat1+=choix1; resultat2+=(population1.getVotants() - choix1); } if (resultat1>=resultat2) setPresident(cand1Arg); else setPresident(cand2Arg); } }// Fin class USA

137 Constructeurs et héritage L'héritage permet la réutilisation de code. Le constructeur est concerné. Possibilité d'invoquer ue méthode héritée : la référence super. Invocation d'un constructeur de la super-classe : super( ) L'utilisation de super ressemble à celle de this L'appel à un constructeur de la super classe doit toujours être la première instruction dans le corps du constructeur. Si ce n'est pas fait, il y appel implicite : super(). Lors de la création d'un objet, les constructeurs sont invoqués en remontant de classe en classe la hiérarchie, jusqu'à la classe Object. Attention, l'execution se fait alors en redescendant dans la hiérarchie. Un constructeur d'une classe est toujours appelé lorsqu'une instance de l'une de ses sous classes est créée.

138 Héritage et constructeurs - suite public class Point extends Object { public Point(double i, double j) {...} } public class PointAvecUneCouleur extends Point { public PointAvecUneCouleur(int i, int j, int c){ super(i,j); couleur=c; } public class Object { public Object() {...} }

139 Constructeur et père-fils "Qui créer qui" est un problème indépendant de qui est fils de qui Il est plus facile de garder une référence sur sa création que sur son créateur Mais on peut passer un pointeur de soi-même au constructeur de sa création Public class DonneurDOrdre { Travailleur Travailleur1 = null; public void faireBoulot () {... Travailleur1 = new Travailleur(this); }

140 Conseils pour toucher votre héritage Placer les informations communes dans la superclasse : principe d'économie et de non redondance de l'information N'utiliser l'héritage que lorsque c'est pertinent : c'est-à-dire lorsque toutes les informations de la surclasse sont bien utilisées par une sous-classe Utiliser le polymorphisme plutôt que des tests sur le type : éviter un code tel que : if( x instanceof Classe1 ) { x.methode1(); } else if( x instanceof Classe2 ) { x.methode2(); }

141 Blocage de l'héritage Mot-clé final Le mot-clé final devant une classe indique qu'elle ne peut avoir de descendance. final class Point3D {... } Avantage Efficacité : implémentation statique possible. Sécurité : pas de redéfinition possible des méthodes pour une descendance. Inconvénients Impossibilité de sous-classer pour créer une classe de test indépendante

142 Conseils de conception Faire des schémas Représentant les classes et leur hierarchie Pour comprendre les interactions entre les classes (qui a besoin dune référence sur qui) Pour savoir ou placer une fonction Pour bien penser les droits d'accès Représentant les appels de fonction Pour savoir quels objets sont traversés Pour savoir où récupérer les données à mettre en argument Attention l'héritage n'est pas une réponse à tout, la délégation est aussi utile. l'héritage est une relation is-like.

143 Programmation Objet en JAVA Héritage, polymorphisme Surclassement, Polymorphisme, classe abstraite, Interface

144 Rappel : réutilisation de code - 1 Comment réutiliser une classe (sans le code source) ? Besoin des services de la classe, une relation client/serveur. Agrégation : Juste une référence, l'objet serveur est autonome Composition : Le serveur est un objet appartenant à l'objet client public class Disque { private Point centre;... Disque(...){ centre = new Point(...); }... } public class Point {... } Le clientLe serveur Composition

145 Rappel : réutilisation de code - 2 Comment réutiliser une classe (sans le code source) ? Spécialiser, augmenter une classe existante : l'héritage Dériver une nouvelle classe à partir d'une classe existante en récupérant (toutes) ses propriétés. Définit une is-like relation. public class Point3D extends Point Un Point3D est un Point, mais pas le contraire. Animal ChevalOursTortue galoper manger courir hiberner manger dormir espèce

146 Rappel : conseils de conception Faire des schémas : Représentant les classes et leur hierarchie Pour comprendre les interactions entre les classes (qui a besoin dune référence sur qui, qui hérite de qui) Pour savoir ou placer une méthode et penser les droits d'accès Représentant les appels de fonction Pour savoir quels objets sont traversés, où récupérer les données à mettre en argument Attention l'héritage n'est pas une réponse à tout, la délégation est aussi utile. l'héritage est une relation is-like. Placer les informations communes dans la superclasse : principe d'économie et de non redondance de l'information N'utiliser l'héritage que lorsque c'est pertinent : c'est-à-dire lorsque toutes les informations de la surclasse sont bien utilisées par une sous- classe

147 Rappel : héritage et constructeur public class ClasseA { double x; public ClasseA(double i){ this.x = i } public class ClasseB extends ClasseA { double y = 0; // Pas de constructeur } > javac ClasseA.java ClasseB.java ERROR in ClasseB.java (at line 1) public class ClasseB extends ClasseA { ^^^^^^^ Implicit super constructor ClasseA() is undefined for default constructor. Must define an explicit constructor

148 Retour sur les packages (1/2) Pour regrouper des classes " proches " Prédéfinis : java (rangement des classes essentielles à JAVA) javax (rangement des classes étendues de JAVA) sun (rangement des classes propriétaires de SUN)... Classes Fondamentales : java.lang Classes des I/O (entrées-sorties) : java.io Sous-paquetages possibles java.util.zip paquetages industriels com.nom_de_domaine_internet.nom_de_projet … En minuscule

149 Retour sur les packages (2/2) Définition d'un paquetage au début du fichier.java avant les import et le commentaire de classe package NomPackage.NomSousPackage; //fichier Toto.java package mesPackages.excours.bidon; public class Toto{... }; Compilation (sous windows / devient \ ): Toto.java est dans MesPackages/ExCours/Bidon/ javac MesPackages/ExCours/Bidon/Toto.java Exécution : java MesPackages.ExCours.Bidon.Toto Attention au répertoire ! Pour lancer la commande se trouver dans le répertoire au dessus de mespackages/excours/bidon/ Créez des scripts (Unix ou dos) au bon endroit Utiliser un IDE

150 Utilisation : classes et paquetages Une classe appartient à UN et un seul paquetage Par défaut : le répertoire courant Une classe a le droit d'accéder aux classes du même paquetage (faire des news, invocation des méthodes de classes) Une classe a toujours 2 noms : nom court : NomDeLaClasse nom long : NomPackage.NomDeLaClasse (à utiliser en cas dambiguïté) import permet de spécifier le chemin des classes utilisées par rapport aux paquetages import java.io.File; import java.io.*;

151 Exemple : Classe Point package fr.u-psud; public class Point // une classe { int x; // variable d'instance int y; // variable d'instance public int getX() { // accès return x; } public void setX(int abscisse) { // altération x = abscisse; } public int getY() { return y; } public void setY(int ordonnee) { y = ordonnee; }

152 Exemple dinstance : unPoint import java.awt.*; // on a besoin de la classe Point public class TestPoints { public static void main(String[] arg) { Point unPointAWT = new Point(10, 15); fr.u-psud.Point unPoint=new fr.u-psud.Point(); unPoint.setX(10); unPoint.setY(100); System.out.println("point\n\t d'abscisse " + unPoint.getX() + "\n"+"\t et d'ordonnée "+ unPoint.getY()); } }// Fin class TestPoints

153 Packages : conseils Il ny a pas dinclusions récursives Nhésitez pas à importer des paquetages entiers import java.awt.* nimporte pas java.awt.event.* 2 fois le même import ne gène pas Rangez dans des paquetages : Tout (gros projets) et Rien (petit projet). Si vous avez besoin de gérer dynamiquement vos paquetages Package package1 = Class1.getPackage(); Class1.getName()...

154 Retour sur l'héritage et le surclassement Une classe B qui hérite de la classe A peut être considéré comme un sous type (ou un sous ensemble) du type (ensemble) définit par la classe A. Tout instance de la classe B peut aussi être considérer comme une instance de la classe A. Upcasting ou surclassement. A une référence d'un type donné, il est possible d'affecter un objet de tout type définit par une sous-classe. Lorsqu'un objet est surclassé, il est conidéré comme un objet du type celui de la référence utilisée. Etudiant e; e = new EtudiantSportif(); Etudiant EtudiantSportif String nom, prenom; int age; String sport;

155 Surclassement (suite) import Note // La classe note est déjà définit class Instrument { public void play(Note n) { System.out.println("Instrument.play()"); } class Wind extends Instrument {// Un objet Wind est un Instrument public void play(Note n) { System.out.println("Wind.play()"); } public class Music { public static void tune(Instrument i) { //... la classe Note contient des constantes static i.play(Note.MIDDLE_C); } public static void main(String[] args) { Wind flute = new Wind(); tune(flute); // Upcasting ! } > java Music Wind.play();

156 Surclassement : question ? flute est surclassé en Instrument alors pourquoi obtient-on Wind.play() et non Instrument.play() ? Conclusion : Lorsque qu'une méthode d'un objet est appellée via une référence « surclassée », c'est la méthode définie dans la classe effective qui est invoquée ! // Dans Etudiant.java public void affiche(){ System.out.println( «Nom :»+ nom+« Prenom :» +prenom+ « age :»+age); } // Dans EtudiantSportif.java public void affiche(){ super.affiche(); System.out.println( «Sport :»+sport); } final int NB = 120; Etudiant[] promo = new Etudiant[NB]; int i = 0; //... //exemple d'upcasting : promo[i] = new EtudiantSportif(...); promo[i+1] = new Etudiant(...); for (i=0; i < promo.length; i++) promo[i].affiche(); ?

157 Résolution des messages Pour que cela soit possible, les messages sont résolus à l'execution (run-time) et non à la compilation (compilation-time). Faire la connection entre un appel de méthode et le code à executer s'appel faire un lien (binding) : early binding (à la compilation comme en C). late, dynamic ou run-time binding (lors de l'execution comme en Java et C++). La résolution des messages se fait en fait en deux temps : vérification statique à la compilation : la classe déclarée doit posséder une méthode avec la signature correspondante. Garantie de la résolution des messages lien dynamique à l'execution.

158 exemple de vérification statique public class B extends A { public void m1(){ System.out(«m1 de B»); } public void m2(){ System.out(«m2 de B»); } public class A { public void m1(){ System.out(«m1 de A»); } A a = new A(); a.m1(); // OK b.m2(); // ne peut être résolu ! Erreur de compilation : la méthode m2 n'existe pas pour un objet de type A !

159 exemple de lien dynamique (encore un) public class A { public void m1(){ System.out(«m1 de A»); } A obj; for (int i=0; i<10;i++){ double hasard = Math.random(); if (hasard>0.5) obj = new A(); else obj = new B(); //Upcasting obj.m1(); // lien dynamique // obj.m2() ne peut pas toujours // être résolu. } public class B extends A { public void m1(){ System.out(«m1 de B»); } public void m2(){ System.out(«m2 de B»); } A la compilation, il n'est pas toujours possible de determiner le type exact d'un objet. Cas typique l'IHM : le choix du type d'objet est fait par l'utilisateur lors de l'execution.

160 B toto() Lien dynamique : algorithme Algorithme de recherche pour une classe C : Soit myRef une référence à une instance construite B myRef = new C(...); si C a été déclarée avec une méthode de même nom et de même signature alors appeler cette méthode sinon si C est une sous classe de B alors appliquer l'algorithme de recherche pour la classe B sinon " Erreur, méthode non trouvée C toto() toto() ? C toto()

161 Polymorphisme définition Upcasting + lien dynamique = polymorphisme Le terme polymorphisme est la caractéristique d'un élément pouvant prendre plusieurs formes : l'eau peut se trouver à l'état solide, liquide ou gazeux. En programmation Objet, polymorphisme est le fait qu'un objet d une classe puisse être manipulé comme s'il appartenait à une autre classe. Le fait que la même opération puisse se comporter différemment sur différentes classes de la hiérarchie. "Le polymorphisme constitue la troisième caractéristique essentielle d'un langage orienté objet après l'abstraction des données (encapsulation) et l'héritage" Bruce Eckel "Thinking in JAVA"

162 Conséquences – 1 La signature d'une méthode correspond au nombre et au type de ses paramètres plus le type retourné par la méthode Des classes différentes peuvent avoir des méthodes différentes de même nom et de même signature Le polymorphisme consiste pour une instance à retrouver quelle méthode il doit appeler Point3D unPoint3D = new Point3D( x, y, z ); Point unPoint = (Point) unPoint3D; unPoint.projete(); // Point3D.projete() !

163 Conséquences – 2 Si on définit dans une classe C (sous-classe de B) une méthode m et avec la même signature que la méthode m de la classe B alors cette méthode m de la classe B est masquée pour toutes les instances de C. On ne peut pas appeler directement la méthode m de B à partir d'une référence de C. Exemple : Public class C extends B {...} C unC = new C(); B unB = unC; // Transtypage unB.m(); //c'est la méthode m() de C si elle existe sinon de B

164 Exemple Je connais Robert, un agriculteur Je demande à Robert de préparer son Champ et jattend en retour le temps que ça prend (temps = largueur du tracteur *vitesse /surface, etc.) Or en fait ce que je ne sais pas cest que Robert est Viticulteur (un genre un peu spécial dagriculteur) Pour lui préparer = tailler Que dois me répondre Robert ? Robert sait-il que je ne sais pas quil est viticulteur ? Dois-je faire une différence entre les viticulteurs et les autres ?

165 Polymorphisme : méthode de classe Les méthodes de classe (static) ne peuvent pas être masquées. Exemple : C unC=new C(); A unA=unC; unA.methodeDeClasse(); // c'est la méthode de classe A qui est appelée Remarque : il est très fortement conseillé de toujours appeler les méthodes de classe par le nom de la classe plutôt que par une instance de la classe A.methodeDeClasse();

166 Polymorphisme : super On peut appeler dans la méthode m (que redéfinit la classe C) la méthode m de même signature immédiatement supérieure en la préfixant par le mot clef super Exemple : dans un constructeur : super(); dans la méthode m redéfinie (ou ailleurs) : super.m(); private void faitBoulot(int mesure_Arg) { if (mesure_Arg>0) super.faitBoulot(mesure_Arg); } private float faitDecoupe(int mesure_Arg) { if (mesure_Arg>0) return super.faitDecoupe(mesure_Arg); else return super.prepareDecoupe(); } La notation super.super.m() n'est pas permise

167 Surcharge et polymorphisme public class ClasseC{... public static void methodeX(ClasseA a){... System.out.println(param type A); } public static void methodeX(ClasseB b){... System.out.println(param type B); } ClasseA ClasseB ClasseA refA = new ClasseA(); ClasseC.methodeX(refA); ClasseB refB = new ClasseB(); ClasseC.methodeX(refB); refA = refB; //upcasting ClasseC.methodeX(refA); Verification statique : le choix de la méthode est effectué à la compilation !

168 Un dernier exemple liste peut contenir tout type d'étudiant Si un nouveau type d'étudiant apparaît, la classe GroupeTD reste inchangée. Le polymorphisme permet la manipulation uniforme d'objets de plusieurs classes via une classe de base commune. Plus besoin de distinguer différents cas en fonction de la classe des objets. Possible de définir de nouvelles fonctionnalités en héritant de nouveaux types de données à partir d'une classe de base commune sans avoir besoin de modifier le code qui manipule l'interface de la classe de base. public class GroupeTD{ Etudiant[] liste = new Etudiant[30]; int nbEtudiants = 0;... public void ajouter(Etudiant e) { if (nbEtudiants < liste.lenght) liste[nbEtudiants++] = e; } public void afficherListe() { for (int i=0;i

169 Conclusion sur le polymorphisme « Once you know that all method binding in Java happens polymorphically via late binding, you can always write your code to talk to the base class, and know that all the derived-class cases will work correctly using the same code. Or put it another way, you send a message to an object and let the object figure out the right thing to do » Bruce Eckel, Thinking in Java

170 abstract : définition, introduction Une classe abstraite est une classe non-instanciable. Dans l'exemple des instruments, la classe Instrument ne représente pas une entité concrète. Un Instrument n'existe pas, une flute oui. Pareil pour Animal, c'est un concept. Animal ChevalOursTortue Instrument BrassWoodWind BrassFrench Horn Flute

171 Classe abstraite 1/2 Mot clé : abstract public abstract class Instrument {...} Une classe peut être déclarer abstraite mais contenir des méthodes implémentées. Une classe est également abstraite si elle n'est pas entièrement implémentée : si une classe a (au moins) une méthode abstract alors cette classe est abstraite ses sous-classes doivent terminer son implémentation. Une classe abstraite peut avoir des données, mais généralement pas de constructeur. Si une sous classe d'une classe abstraite n'implémente pas toutes les méthodes " abstract " de sa classe mère, c'est aussi une classe abstraite. Une classe abstraite ne peut pas être instanciée (new). Mais une référence d'un type abstrait peut exister (upcasting).

172 Exemple de classe abstraite abstract class Instrument { int i; public abstract void play(); public abstract void adjust(); } class Wind extends Instrument { public void play() { System.out.println(" Wind.play()"); } public void adjust() {...} } class Brass extends Instrument { public void play() { System.out.println ("Brass.play()"); public void adjust() {...} }... public class Music { static void tune(Instrument i) { //... i.play(); } static void tuneAll( Instrument[] e) { for(int i=0;i

173 Classe abstraite 2/2 Méthode abstraite : méthode n'admettant pas d'implémentation. au niveau de la classe dans laquelle elle est déclarée abstraite, on ne sait pas la réaliser. Les méthodes dites " static ", " private " et " final " ne peuvent pas être abstraites Static : méthode de classe Private : méthode interne à cette classe, non héritable, donc on ne peut pas la redéfinir. Final : aucune surcharge de la méthode possible. Une classe déclarée final ne peut être abstraite Une classe déclarée abstraite est abstraite même si aucune méthode abstraite n'y figure. Il faut en hériter pour l'instancier ! Une classe déclarée abstraite qui ne déclare aucune méthode ni aucune donnée sert de classe de marquage. On peut ainsi déclarer des pointeurs compatibles avec toutes ses sous classes.

174 Utilité des classes abstraites Définir des concepts incomplets qui devront être implémentés dans les sous classes plus spécifique. Factoriser le code : Regrouper et implémenter tout ce qui est générique dans la classe abstraite Déclarer abstract, ce qui sera spécifique mais déjà prévu comme indispensable. Les opérations abstraites sont particulièrement utiles pour mettre en oeuvre le polymorphisme : l'utilisation du nom d'une classe abstraite comme type pour une (des) référence(s) est toujours possible (et souvent souhaitable !) La classe abstraite peut contenir l'interface indispensable à toutes classe qui héritera. Un code générique peut s'adresser ainsi à tout type d'objet qui hérite de cette classe.

175 Exemple classique : les formes géométriques Réaliser une application manipulant des formes géométriques (triangles, rectangles,...). Chaque forme est définie par sa position dans le plan Chaque forme peut être déplacée (modification de sa position), calculer son périmètre, sa surface. public abstract class Forme { // Des attributs protected double x,y; // Implementons ce qui est implementable public void deplacer(double dx, double dy) { x += dx; y += dy; } // Les fonctionalités spécifiques sont pour plus tard public abstract double périmètre() ; public abstract double surface(); }

176 Nouveau problème La classe ActionCharacter est utilisée par le moteur du jeu. Comment faire pour créer des classes de personnages du jeu qui soit des animaux ? Créer une classe abstraite Hero dont hériterait les personnages. Comment réutiliser les différentes classes existantes ? Sans se passer du polymorphisme ? Héritage multiple : impossible ! Comment créer des animaux (hériter) dont « l'interface » soit compatible avec le jeu ? Animal ChevalOurs manger dormir marcher courir espèce galoperhiberner ActionCharacter nager voler combattreAlEpee pointDeVie force Hero ? ?

177 Interface : déclaration Une interface est une collection d'opérations (de méthodes) utilisée pour spécifier un service offert par une classe. Une interface est une classe totalement abstraite. public interface ActionCharacter { public void nager(); public void voler(); public void combattreAlEpee();... } Une interface est vouée à être implémentée par d'autres classes. Ces dernières s'engagent à implémenter le service spécifier par l'interface. L'implémentation est libre, seul compte le respect de la signature.

178 Interface : réalisation une classe hérite ou étend sa super-class, elle implémente une ou plusieurs interface(s). public class HeroChien extends Chien implements ActionCharacter {...} Si une classe implemente plusieurs interfaces, les séparer par des virgules : public class A extends B implements C, D, E {...} Si la classe est « concrète », elle doit fournir une implémentation à toutes les méthodes spécifier par l'interface. Ces méthodes sont bien évidement déclarées public. Une interface peut être utiliser comme un type ! A une référence typée par une interface, il est possible d'affecter des instances de toutes classes qui implémentent cette interface (upcasting). ActionCharacter ac ; // Attention pas de new ! HeroChien hc = new HeroChien(); ac = hc; // en route pour le polymorphisme

179 Interface : reprenons Une interface déclare les signatures de méthodes " public " sans en donner une implémentation. Une interface se déclare comme une classe mais avec le mot clef interface. (public) interface InterfaceExemple {...} Une interface n'a pas de variable. Une interface correspond à une liste de services. La signature d'une méthode est suivie d'aucun code. (public) TypeRetour nomMethode(type arg) ; Une interface peut spécialiser une autre interface en lui ajoutant des services. On peut ainsi faire des hiérarchies d'interface. interface Interf1 extends Interf0; Une interface peut hériter de plusieurs interfaces.

180 Interface : conclusion « By incorporating interfaces into your next project, you will notice benefits throughout the lifecycle of your development effort. The technique of coding to interfaces rather than objects will improve the efficiency of the development team by: Allowing the development team to quickly establish the interactions among the necessary objects, without forcing the early definition of the supporting objects Enabling developers to concentrate on their development tasks with the knowledge that integration has already been taken into account Providing flexibility so that new implementations of the interfaces can be added into the existing system without major code modification Enforcing the contracts agreed upon by members of the development team to ensure that all objects are interacting as designed » Michael Cymerman, javaworld aout 99.

181 Mécanismes objets Pour réutiliser une classe existante : agrégation, composition, héritage. En Java, la verification du code est statique (résolution des messages), les liens sont fait dynamiquement : polymorphisme. Le polymorphisme : ecrire du code qui s'adresse à l'interface de la super-class, les spécialisations (héritages) peuvent s'ajouter sans de nouvelles modifications. Classe abstraite : regroupe certaines caractéristiques communes (implémentées ou non) qui définissent un comportement minimal commun. Créer une interface permet enfin un développement parallèle efficace, une évolution du code facilitée, la garantie d'une integration. Pensez à tout cela lors du projet !

182 Rappel & Outils.

183 POO Rappel 1. Rappel important 2. Instances 3. Références 4. Rappel important 5. Héritage 6. Javadoc 7. Interface 8. Références 9. Classe Abstraites

184 Rappel important Ne pas confondre classe et instance On décrit les classe dans le langage JAVA On créé et on tue les instances pendant le déroulement du programme Le déroulement du programme est décrit dans les fonctions des classes (en commençant par main() de votre objet principal) Fonctions statiques = appelées depuis nimporte où, sans contexte spécifique Fonction dinstance = appelée comme un service demandé à une instance

185 Rappel important Instance Comme un autre programme indépendant Capable de gérer son état personnel (données) Capable de rendre un service contextuel sans que lappelant se soucie de létat de linstance Classe Stocke des données et des fonctions uniques Fournit un service général Sert de modèle a la création dinstance

186 Instance Décrite au travers de la classe qui lui servira de modèle Créée nimporte où grâce au mot-clé "new" Depuis une méthode statique de classe Depuis la méthode dune instance Nest accessible quau travers de références que les autres (classes et instances) du programme ont de cette instance Le "new" renvoie cette référence Cette référence se manipule comme un int ou un float (affectation, paramètre dune méthode)

187 Référence Les références sont la seule façon de collaborer avec dautres instance (sauf soi-même si on est une instance) Lorsque une instance na plus de références sur elle-même, elle est détruite car inutile Une référence est typée par La classe … … qui a servit a créé linstance … sur laquelle on stocke une référence Mais ne pas confondre référence et classe !!!

188 Rappel important Une classe hérite une partie de sa description dune description existante (une autre classe) Pour éviter les redites Pour que les services dune instances soient organisés en couches (des services spécifiques aux plus génériques) Pour ne pas faire dhypothèses trop strictes sur la classe exacte de linstance avec laquelle on travail Mélanger des instances de classes différentes dans une structure de donnée Une liste dobjets à dessiner (Ronds, Rectangles, etc.) Une hiérarchie de Fichier/Répertoire

189 Héritage class LaClasseFille extends LaClasseMere class PointAvecUneCouleur extends Point java n'autorise que l'héritage simple (s pluriel) public class EtudiantOrsay extends Etudiant,Francilien { }

190 Exemple en Javadoc 1/2 javax.swing Class AbstractButton java.lang.Object | +--java.awt.Componentjava.awt.Component | +--java.awt.Containerjava.awt.Container | +--javax.swing.JComponentjavax.swing.JComponent | +--javax.swing.AbstractButton All Implemented Interfaces: ImageObserverImageObserver, ItemSelectable, MenuContainer, Serializable, SwingConstantsItemSelectableMenuContainerSerializableSwingConstants Direct Known Subclasses: JButtonJButton, JMenuItem, JToggleButtonJMenuItemJToggleButton public abstract class AbstractButton extends JComponentJComponent implements ItemSelectable, SwingConstantsItemSelectableSwingConstants Defines common behaviors for buttons and menu items. For further information see How to Use Buttons, Check Boxes, and Radio Buttons, a section in The Java ….. How to Use Buttons, Check Boxes, and Radio Buttons

191 Exemple en Javadoc 2/2 Class java.lang.Object … class java.awt.Component (implements java.awt.image.ImageObserver, …ComponentImageObserver class java.awt.ContainerContainer class javax.swing.CellRendererPane (implements javax.accessibility.Accessible)CellRendererPaneAccessible class javax.swing.JComponent (implements java.io.Serializable)JComponentSerializable class javax.swing.AbstractButton (implements java.awt.ItemSelectable, …AbstractButtonItemSelectable class javax.swing.JButton (implements javax.accessibility.Accessible)JButtonAccessible class javax.swing.JMenuItem (implements javax.accessibility.Accessible, …JMenuItemAccessible class javax.swing.JCheckBoxMenuItem (implements …JCheckBoxMenuItem class javax.swing.JMenu (implements javax.accessibility.Accessible, …JMenuAccessible class javax.swing.JRadioButtonMenuItem (implements …JRadioButtonMenuItem class javax.swing.JToggleButton (implements javax.accessibility.Accessible)JToggleButtonAccessible class javax.swing.JCheckBox (implements javax.accessibility.Accessible)JCheckBoxAccessible class javax.swing.JRadioButton (implements javax.accessibility.Accessible)JRadioButtonAccessible class javax.swing.Box (implements javax.accessibility.Accessible)BoxAccessible class javax.swing.Box.Filler (implements javax.accessibility.Accessible)Box.FillerAccessible class javax.swing.JColorChooser (implements javax.accessibility.Accessible)JColorChooserAccessible class javax.swing.JComboBox (implements javax.accessibility.Accessible, …JComboBoxAccessible …

192 Interface Public class Fils extends Pere implements Metier On a envie que les étrangers puissent se servir dun même service dans plusieurs classes On décrit les fonctions qui correspondent à ce service dans un fichier à part On dit explicitement quune classe remplit les exigence de linterface

193 Référence Une référence à une instance peut être Du type exact de la classe qui a servit à la créée Du type de la classe du père (plus générique) On ne peut pas appeler les membres spécifiques On peut transtyper pour avoir une ref. spécifique Du type dune des interfaces que remplit la classe On peut appeler une fonction de linterface sans savoir du tout de quelle classe il sagit On peut toujours transtyper Quand au déroulement dune fonction On ne sait pas qui nous appelle (sauf si argument) On ne sait pas ce que lappelant sait de nous

194 Classe abstraite Mélange de père et dinterface Le fils hérite des fonctions non abstraites Le fils doit implémenter les fonctions abstraites On ne peut pas instancier de classes abstraites ou dinterfaces car ce sont pas des descriptions concrètes On peut avoir des références du type Classe abstraite ou Interface dont on sait pertinemment que le type final est plus spécifique !

195 Outils de programmation 1. Membres et modificateurs 2. Compteurs dinstances 3. Droit d'accès 4. Tableau daccessibilité 5. Jar et manifest 6. Jar suite et fin 7. IDE 8. JEdit 9. NetBeans Eclipse 11. Ant 12. Exemple fichier Ant 13. Démo NetBeans

196 Membres et modificateurs Les variables (attributs/champs) et les méthodes = membres d'une classe Le modificateur se met avant le type du membre Ne rien mettre : il faut une instance de la classe pour pouvoir l'utiliser Utilisation de new AVANT static : Variable : variable de classe partagée par toutes les instances de la classe (ex : compteur) Méthode : une instance n'est pas nécessaire pour l'utiliser ex:main(String[] args) final : classe : interdit la définition de sous-classes variable et méthode : interdit les redéfinitions dans les sous-classes static final : combine les deux variable : création d'une constante static final boolean EN_MAJUSCULE = true;

197 Compteur dinstances public class Moutons { static int compteur = 0; int numero = -1; public Mouton { compteur++; numero = compteur; } 2 déclarations 2 lignes de code

198 Droit d'accès Il faut toujours préciser les droits d'accès aux: variables d'instance variables de classe méthodes classes public : tout le monde utilise (faire des nez, app fcts) protected : les membres d'une même famille (héritage, paquetage) ont le droit d'utilisation private : c'est personnel. PAS TOUCHE ! (package) Ne rien mettre : les classes du même paquetage peuvent l'utiliser L'accès à un paquetage dépend des protections du système

199 Tableau daccessibilité * * Si et seulement si la sous-classe est dans le même package !

200 Jar 1/3 Un fichier JAR est un conteneur de fichiers (comme tar ou zip) pour stocker et regrouper les fichier.class contient en plus un fichier nommé META-INF/MANIFEST.MF peut être compressé ou non Syntaxe de «tar» plus le m pour le fichier manifest.mf création : jar cmf toto.jar mymanifest.mf *.class mise à jour : jar uf toto.jar *.java listing du contenu : jar tf toto.jar v=verbose, 0=pas de compression Chemins des fichiers relatifs pas de c:\blah ou /usr/var/blah Un fichier jar est comme un autre disque dur avec sa propre racine

201 Jar 2/3 Manifest Le fichier manifest.mf est un fichier texte qui peut contenir des meta- informations Author: prenom nom Class-Path : MonAutreLibrairie.jar version: 1.0 Main-Class: classname Winzip lit les jars (mais ne rajoute pas des fichiers avec un chemin relatif facilement) Exécution = double click ou Tag applet : Main-Class Un jar peut être signé pour authentifier lorigine de son contenu (voir doc. SUN)

202 Jar 3/3 Un jar peut contenir les sources (java), les autres ressources (gif, jpg, html, etc.) Les fichiers à lintérieur du jar sont accessibles depuis le code java par java.net.url URL1 = getClass().getResource("/Images/PleaseWait.jpg"); A partir de cette URL on peut par exemple récupérer une image if (URL1!=null) ImagePleaseWait = (new ImageIcon(URL1)).getImage();

203 IDE Integrated Development Environment Pour toutes les tâches ingrates … Trouver le nom dune fonction Trouver le type dun paramètre Vérifier les ; avant de lancer une compilation Changer le nom dune classe partout Rajouter les set/get Colorier le code Gérer les 37 fichiers de mon projet Chercher une chaîne dans tous mes sources Etc.

204 Jedit

205 NetBeans 5.0b (Sun) Complétion Documentation Détection Erreurs Projets Méthodes Gestion ANT Compilateur à la volée Outils de refactoring Tests unitaires Gestion CVS

206 Editeur dinterface

207 Eclipse 3.1 (IBM) Idem mais - Plus répandu - Plus de modules - Moins par défaut - Présentation différente

208 Ant Scripting de tâches de compilation Comme make/MAKEFILE sous unix Codage XML (lisibilité) Compilation, build, debug, tests, documentations, etc. (projet apache) Gestion de Projet Utilisé par les IDE sus mentionnés Ftp, copies de fichiers, conditions, etc. Facilement distribuable (1 seul fichier) Nom "build.xml " + tâches standars (compile, build, run)

209 Exemple fichier Ant …

210 Exemple fichier Ant

211 Exemple fichier Ant ……

212 Démo NetBeans BiSlider ……. FiCell …… Conclusion Soyez fainéant,utilisez ce qui existe déjà ! Google moi ça ! "java setActive( JButton« Comme un jeu de construction Aucune limite (à part votre imagination) Développez vos expertises

213 Programmation Objet en JAVA.

214 Exception et Entrées-sorties 1. Introduction 2. Rattrapage dexception 3. Syntaxe try{… }catch(…){…} 4. Factorisation de catch(s) 5. Exemple 6. Exemple type de Fichier 7. Classe Exception 8. Affichage dexception 9. Jeter ses propres exceptions 10. Exemple CreateNewFile() 11. Signature et Héritage 12. Conseils de Christian 13. Conseils de Bruce 14. Entrées-Sorties 15. 0bjets dEntrées-Sorties 16. Chaine dEntrées-Sorties 17. Entrées-Sorties de char 18. Entrées-Sorties dobjets 19. Sérialisation 20. Utilisation 21. Objets divers dEntrées-Sorties 22. System.xxx 23. Exemple : écrire une Exception

215 Introduction Quelques axiomes de base en informatique : Un programme sans bugs, ça n'existe pas Un utilisateur qui ne fait aucune erreur, ça n'existe pas Un matériel qui marche toujours comme il devrait, ça n'existe pas Une erreur d'exécution peut arriver n'importe quand. Exemple : " plus de mémoire " Un logiciel doit pouvoir gérer "un minimum" ces quatre points. En Java, le mécanisme de tolérance aux fautes est réalisé à travers les exceptions

216 Rattrapage Un comportement anormal en cours d'exécution provoque une exception Une exception est un message. Il est retourné à la méthode qui a appelé le traitement erroné Une exception est créée soit par la JVM (erreur interne, erreur de conception) soit par l'instruction throw du programmeur Les instructions try/catch permettent de surveiller un bloc d'instructions Principe : La méthode qu reçoit une exception la transmet à la méthode qui la appelée et ainsi de suite mais on voudrait pas tout planter !

217 Syntaxe try { blocASurveiller; } catch (NomClasseException NomClasseException_Arg) { traitement; if () NomClasseException_Arg.printStackTrace(); } [finally {dansTousLesCas}] Les instructions dans la clause catch ou finally ne sont pas surveillées par le mécanisme Si on attrape une exception elle ne se propage plus au dessus (ouf !)

218 Factorisation de catch On peut traiter plusieurs exceptions dans un seul try/catch public class LectInt { public static void main(String[] args) { byte tab[]=new byte[10]; try {System.out.println( "\nSaisie d'un entier : "); System.in.read( tab ); String uneChaine=(new String(tab)).trim(); int unEntier=Integer.parseInt(uneChaine); System.out.println( "\nEntier saisi : " + unEntier); boolean unBooleen=tab[12]==tab[0]; System.out.println( "\nBooléen saisi : " + unBooleen); } catch( NumberFormatException NumberFormatException_Arg) { System.err.println( "Ce n'est pas un entier !"); } catch( Exception Exception_Arg ) { Exception_Arg.printStackTrace(); } finally { System.err.println( "Fin du try/catch"); }

219 Exemple Exception sur un accès incorrect à un tableau. > java LectInt Saisie d'un entier : 32 Entier saisi : 32 java.lang.ArrayIndexOutOfBoundsException... Fin du try/catch Fin d'exécution Exception sur une conversion incorrecte. > java LectInt Saisie d'un entier : 2er4 Ce n'est pas un entier! Fin du try/catch Fin d'exécution

220 Exemple type readFile { try { open the file; determine its size; allocate that much memory; read the file into memory; close the file; } catch (fileOpenFailed) { doSomething; } catch (sizeDeterminationFailed) { doSomething; } catch (memoryAllocationFailed) { doSomething; } catch (readFailed) { doSomething; } catch (fileCloseFailed) { doSomething; }

221 La classe Exception Les exceptions sont des classes java dont la classe mère est Throwable Error : erreur interne de la JVM => On ne doit rien faire RuntimeException : erreurs de conception => pas de catch (NullPointerException) mais allez debuguer ! Les autres : il faut un catch Le codeur pose des conditions sur lappel de sa fonction La fonction appelante DOIT traiter le cas dans lequel … On peut faire ses propres exceptions avec des sous-classes de Exception Catch (Exception) gère toutes exceptions

222 Affichage Par défaut si une exception nest pas attrapée elle plante le programme et saffiche comme suit : java.lang.StringIndexOutOfBoundsException: String index out of range: -46 at java.lang.String.substring(Unknown Source) at FTDebug.debug(FTDebug.java:475) at FTPresentation.mousePressed(FTPresentation.java:301) at java.awt.AWTEventMulticaster.mousePressed(Unknown Source) at java.awt.Component.processMouseEvent(Unknown Source) at java.awt.Component.processEvent(Unknown Source) at java.awt.Component.dispatchEvent(Unknown Source) … at FTProg.main(FTProg: 54) On peut forcer laffichage dans un catch() catch(MyException MyException_Arg) { MyException_Arg.printStackTrace(); }

223 Jeter ses propres exceptions Class MonException extends Exception { MonException(){} MonException(String s){super(s);} } Utilisation : throw new MonException(); Une méthode qui peut déclencher des exceptions (throw) DOIT indiquer dans sa signature la liste de ces exceptions (throws) void nomMethode(int arg) throws MonException, Exception2 { throw (new MonException(mon erreur sest produite)); Si vous ne pouvez pas gérer lexception relancez la au dessus ! catch(Exception exception_Arg) { System.err.println("An exception was thrown"); throw exception_Arg; }

224 Exemple : File.createNewFile() public boolean createNewFile() throws IOExceptionAtomically creates a new, empty file named by this abstract pathname if and only if a file with this name does not yet exist. The check for the existence of the file and the creation of the file if it does not exist are a single operation that is atomic with respect to all other filesystem activities that might affect the file. This method, in combination with the deleteOnExit() method, can therefore serve as the basis for a simple but reliable cooperative file-locking protocol. Returns: true if the named file does not exist and was successfully created; false if the named file already exists Throws: IOException - If an I/O error occurred SecurityException - If a security manager exists and its SecurityManager.checkWrite(java.lang.String) method denies write access to the file Since: 1.2

225 Exemple : createNewFile() Public File creerTemp() throws IOException { File File1 = new File ("temp.txt"); try { File1.createNewFile(); } catch (SecurityException SE_Arg) { File1 = new File ("/tmp/temp.txt"); File1.createNewFile(); } return File1; }

226 Signature et Héritage Si m() est une méthode de A, Si B est une sous-classe de A La surcharge d'une méthode m() dans B ne pourra pas émettre des exceptions qui n'ont pas été initialement prévues dans la méthode m() de A Si vous créez B pour remplacer A, B doit sutiliser de la même façon Les exceptions possibles font parties de la signature Java cherche lexception la plus proche du type quelle doit traiter Si rien ne correspond ou si pas de try on remonte Le premier truc qui correspond est utilisé et tout sarrête !

227 Conseils de Christian Quand faut-il gérer des exceptions ? Obligatoire si vous utilisez une méthode avec une signature contenant throws Exemple: la méthode read() Pour les I/O Pour gérer vos propres erreurs Pour les messages d'erreurs Quand ne faut-il pas le faire ? Quand l'erreur se produit très très rarement Quand un if est suffisant pour le faire Quand la méthode "au-dessus" sait le faire Quand vous ne savez pas quoi mettre dans le catch

228 Conseils de Bruce Gérer le problème au niveau adéquate. (éviter dattraper lexception quand on ne sait pas quoi en faire) Résoudre le problème et appeler la méthode qui a plantée à nouveau Mettre une rustine et continuer sans appeler la fonction incriminée Calculer un résultat alternatif (approximation) a la place de ce qui était censé être calculé Faire son possible pour pas tout planter puis relancer la même exception aux plus haut appelants en espérant quils puissent finir la réparation Pareil que point précèdent mais lancer une exception dun autre type pour indiquer e qui reste a faire Sortir proprement du programme (fermer les connexions réseau, etc.) Simplifier. Si vos exception rendent les choses plus compliquées elle seront douloureuses a utiliser Rendez vos librairies et vos application plus surs, cest un investissement a court terme pour le debugging et a long terme pour la robustesse

229 Entrées-Sorties Les mécanismes objets permettent dorganiser les liens à lintérieur du programme On a besoin de liens avec le monde extérieur (disque dur, réseau, utilisateur, etc.) Souvent sous forme de flux de données Clavier, fichiers, pipes… paquetage java.io centralise toutes les classes et interfaces Les erreurs d'entrées/sorties (très fréquentes) sont des exceptions sous IOException 4 classes abstraites: InputStream : flux d'octets en entrée OutputStream: flux d'octets en sortie Reader : flux de caractères en entrée Writer : flux de caractères en sortie 1 classe pour les fichiers : File

230 Objets dEntrées-Sorties Pour lire/écrire dans un fichier en utilisant seulement son nom, il faut associer un flux d'octets sur fichier FileInputStream pour la lecture FileOutputStream pour lécriture FileInputStream fluxFichLect = new FileInputStream(path+nom); Pour lire/écrire plus efficacement, on utilise les versions "bufferisées" (bloc par bloc plutôt que octet par octet) : BufferedInputStream pour les lectures BufferedOutputStream pour les écritures BufferedInputStream tampLect=new BufferedInputStream(fluxFichLect, 32); Pour lire/écrire des données de type simple (int, float, etc.): DataInputStream pour les lectures DataOutputStream pour les écritures DataInputStream tamponLectureTypeX=new DataInputStream (tampLect); int i=tamponLectureTypeX.readInt();

231 Chaîne dentrées-sorties Les entrées–sorties se connectent en chaîne FileOutputStream fluFichEcr = new FileOutputStream("SaveObj.bin"); BufferedOutputStream tampEcr = new BufferedOutputStream(fluFichEcr, 32); DataOutputStream tamponEcrType = new DataOutputStream (tampEcr); tamponEcrType.writeInt(1249); tamponEcrType.flush(); fluFichEcr.close(); FileInputStream fluFichLec = new FileInputStream("SaveObj.bin"); BufferedInputStream tampLect = new BufferedInputStream(fluFichLec, 32); DataInputStream tamponLectureTypeX = new DataInputStream (tampLect); int i=tamponLectureTypeX.readInt(); fluFichLec.close(); System.out.println(i); File FileInputStream BufferedInputStream DataInputStream File FileOutputStream BufferedOutputStream DataOutputStream Attention au try-catch La compilation impose IOException Attention au try-catch La compilation impose IOException

232 Entrées-Sorties de caractère Pour les écritures: Pour lire/écrire dans un fichier, il faut associer un flux (stream) à une instance de File. FileReader pour les entrées FileWriter pour les sorties FileReader fluxFichLecture= new FileReader(new File(path,nom)); Pour lire/écrire plus efficacement, on utilise des flux " bufferisés " associé à un flux: BufferedReader pour les lectures readline() BufferedWriter pour les écritures write();newLine() BufferedReader tampLect=new BufferedReader(fluxFichLecture); PrintWriter permet d'écrire facilement des fichiers textes. PrintWriter fichierTexte=new PrintWriter(tamponEcriture); fichierTexte.println(uneChaine);

233 Entrées-Sorties dObjets Pour lire/écrire des objets (instances) ObjectInputStream try { FileInputStream istream = new FileInputStream("t.tmp"); ObjectInputStream p = new ObjectInputStream(istream); int i = p.readInt(); String today = (String)p.readObject(); Date date = (Date)p.readObject(); istream.close(); } catch (FileNotFoundException FileNotFoundException_Arg){…} catch (IOException IOException_Arg) {…} catch (ClassNotFoundExceptionIOException_Arg) {…} ObjectOutputStream: writeLong(long val);writeObject(Object obj) Attention à lordre FileNotFound… est une IOException, pas ClassNotFound ! Attention à lordre FileNotFound… est une IOException, pas ClassNotFound !

234 Sérialisation Ce que nous venons de voir Est lié à la programmation orientée objet Sappelle la sérialisation ! Ne marche pas entre deux versions successives dun objet (même modif. mineure) Les classes des instances sérialisées / désérialisées doivent implémenter Serializable (rien à faire) Externalizable (2 petites fcts à implémenter)

235 Utilisation Fichier Sauvegarde (reprise sur panne, persistance) Fichier propriétaire, binaire Réseau Partage dinstances entre deux clients Création dinstances sur serveur et distribution Base de données Stockage dinstances dans une BD Recherche

236 Objets divers dEntrées-Sorties Les PipedOutputStream et PipedInputStream permettent de connecter des entrées avec des sorties RandomAccessFile : read, write et seek() StringReader (et writer) lit une String plutôt quun fichier texte PushbackInputStream permet de revenir en arrière (pour suivant) System.in, System.out, et System.err dont des flux : on va pouvoir jouer avec !

237 system.xxx System.in est un InputStream brut import java.io.*; public class Echo { public static void main(String[] args) throws IOException { BufferedReader in = new BufferedReader( new InputStreamReader(System.in)); String s; while((s = in.readLine())!=null && s.length()!=0) System.out.println(s); // An empty line or Ctrl-Z terminates the program } Attention aux throws pas besoin de try-catch Attention aux throws pas besoin de try-catch Attention à s = in.readLine())!=null stockage (dans s) et test en même temps Attention à s = in.readLine())!=null stockage (dans s) et test en même temps Attention : double chaînage en 1 ligne

238 Exemple : écrire une Exception // créer le fichier de sortie try { File1 = new File("traces.txt"); FileWriter1 = new FileWriter(File1, true); } catch (IOException IOException_Arg) {IOException_Arg.printStackTrace();} // jette une exception gratuite et la récupère try {throw(new Exception());} catch (Exception Exception_Arg) { StringWriter StringWriter = new StringWriter(); PrintWriter PrintWriter = new PrintWriter(StringWriter); Exception_Arg.printStackTrace(PrintWriter); StringBuffer Error = StringWriter.getBuffer(); StringTokenizer ST1 = new StringTokenizer(Error.toString(), "\n\t"); // les 2 premières lignes ne sont pas intéressantes ST1.nextElement(); while (ST1.hasMoreElements()) {FileWriter1.write(ST1.nextToken());} }


Télécharger ppt "IFT-10541 Structures de données Abder Alikacem Département dinformatique et de génie logiciel."

Présentations similaires


Annonces Google