IFT Structures de données

IFT-10541 Structures de données
Abder Alikacem Département d’informatique et de génie logiciel

Introduction à la POO en Java
Semaine 15 Introduction à la POO en Java

Objectifs 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

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)

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, ... Java est un langage de programmation Syntaxe, mots-clés, etc. ORIENTÉ OBJET Java est un environnement de programmation Outils de compilation, de paquetage, de tests, etc. Java est un standard Sun (premier), mais aussi IBM, Microsoft (C#) Père fondateur : James Gosling Java propose un ensemble de bibliothèque standard execution compilation debugger documentation archivage

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 (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)

Java : principe fondateur de sa portabilité

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);

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

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.

Qu'est-ce qu'un objet ? maMontre
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

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.

La classe Montre, un peu de syntaxe
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 : <Type retour> nomMethode (<listeparamètres>) 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++) 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;

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.

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

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.

Exemple de la montre : scénario

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.

Le fichier source d'une application
Fichier ExempleMontre.java 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. 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 */ }

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.

Conventions de Codage Attention aux petits détails
Les développeurs écrivent du code que d’autres 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

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

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 qu’aucune instance soit créée : Bonjour.main(); System est une classe avec des attributs static (toujours pas besoin d’instance) out est une instance static de quelque chose (PrintStream) qui se trouve être une donnée de l’objet 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.

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

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 d’exploitation alors ? A quoi servirait la machine virtuelle alors ? Le système d’exploitation alloue un processus à la machine virtuelle : qui partage le CPU avec les autres processeurs, qui utilise un espace de mémoire virtuelle.

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

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

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: * <pre> * java Bonjour2 un * bonjour * 0 : un * </pre> * Marc Martin %I%, %G% */ public class Bonjour2 ... Génération : Pour générer la page Bonjour2.html, faire : > javadoc Bonjour2.java

Exemple de documentation HTML
Help Index Deprecated Tree Class DETAIL: FIELD | CONSTR | METHOD SUMMARY: INNER | FIELD | CONSTR | METHOD FRAMES NO 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 Bonjour2() Constructor Summary

… Method Summary Constructor Detail Method Detail Bonjour2
main(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 | METHOD SUMMARY: INNER | FIELD | CONSTR | METHOD FRAMES NO FRAMES PREV CLASS NEXT CLASS Help Index Deprecated Tree Class

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)

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.

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)

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)

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 l’accélération Java 1.5 (2005) : classes, 165 paquetages

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

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

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 ( ou

Structure de données et méthodes

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

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 754 Single-precision floating point float (nombres réels) 64-bit two's complement Long integer long 32-bit two's complement Integer int 16-bit two's complement Short integer short 8-bit two's complement Byte-length integer byte (entiers) Taille et Format Description Mot clé

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 n’est pas obligatoirement un if, un for ou un while VarLoc++; marche aussi l’initialisation des variables n’est pas obligatoire mais préférable

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;

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

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

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

Ecritures d’entiers et de réels
255 == 0xff == 0377 1024 == 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)

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);

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);

Opérateurs relationnels et booléens
É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 == != & ^ | && || ? : = += -= *= /= %= &= |= ^=

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};

Tableaux 2/2 Affectation de tableaux Copie de valeur y[ 3 ] = 0.3;
for (int i=0; i<y.length; i++) {y[i]=0.5;} Copie de référence double[] z = y; Tableaux multi-dimensionnels Il s'agit d'un tableau de tableaux pour lequel chaque rangée est accessible individuellement. double[][] matrice_carree; matrice_carree = new double[3][3]; matrice_carree[2] = y;

Flot de contrôle Instruction conditionnelle : 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;

Flot de contrôle - 2 Boucle tant que faire / répéter tant que
while (condition) {bloc} do {bloc} 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)

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

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

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 < j ) { i++; break boucle_a_interrompre;

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

Mots réservés while static instanceof do volatile short import default
void return implements continue try public if const * transient protected goto * class throws private for char throw package float catch this new finally case synchronized native final byte switch long extends break super interface else boolean strictfp ** int double abstract

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 Description Valeur Unicode Caractère

→ Voir la doc de la classe
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

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 !

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);

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()) ;

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

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.

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 <typeRetour> nomMethode( <liste de paramètres> ) { <corps de la méthode> } 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. static void printFloat(String s, float f) { prt(s + " = " + f); } static int max (int tab[]) { int maxi = tab[0]; for (int i=1 ; i<tab.length ; i++){ if (tab[i ] > maxi) maxi=tab[i] return maxi;

Méthodes statiques : Passage des paramètres
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; 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); 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. Après :3 4

Méthodes statiques : invocation
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; 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); 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(...); Après :3 4

Méthode d'objet x = 6; 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 : <typeRetour> 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;

Programmation Objet en JAVA

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

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

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 à l’exé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

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 ? »

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.

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

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.

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 l’information. Une bonne encapsulation crée un code sûr, maintenable et réutilisable !

Concepts Objet : terminologie
Homme 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 d’une boite noire dynamique Un fournisseur de service Bill Clinton Georges W. Bush Hillary Clinton Président des USA Conjoint du Président des USA

Concepts Objet : en mémoire
La classe est chargée une seule fois Les instances sont chargées dynamiquement autant de fois qu’il y a d’instances dans le programme Un compteur est créé pour chaque instance A chaque fois qu’une nouvelle variable fait référence à l’instance compteur++ A chaque fois qu’une 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 d’un objet, compteur- - pour les attributs de l’instance détruite ! Si dernière référence => destruction en chaîne Si co-référence : problème (Simple OK pour java)

Concepts Objet : en pratique
Attention à la terminologie Classe / Instance c’est clair Objet = moins clair, pourtant c’est le terme le plus utilisé 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 d’objets Interaction

Le fichier source d'une classe
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 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 */ }

Exemple de classe type public class Etudiant {
// 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){…} 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;

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)

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 l‘instance, les classes sont organisées hiérarchiquement et bénéficient d'un mécanisme d'héritage automatique.

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.

Portée des attributs 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 Les variables sont visibles à l'intérieur du bloc de définition mais ... Cannot make a static reference to the non-static field x

Exemple : Classe Point Attention aux conventions Java
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

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 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); } public class MaClass { /* Les attributs */ /* Les constructeurs */ public MaClass(String nom){...} public MaClass(String nom,int nb) {...} /* L'interface */ /* Les méthodes privées */

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 c’est la première fois qu’un objet de ce type est invoqué Créer l‘instance 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 d’autres méthodes de l’instance (y compris d’autres constructeurs) ou de la classe.

Exemple d’instance : 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

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 l’objet AssembleeNationale public election(Homme candidat1, Homme candidat2) { for (int i=0; i<NB_ETATS; i++) { Homme choix = etats[i].choosePresident(candidat1, candidat2); ... setPresident(resultat); }// Fin class USA

Questions president n’est pas une instance (référence)
Comment être sûr qu’une 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 l’assemblée américaine est la seule à convoquer une élection aux USA ? Qui est au dessus de qui ?

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) { 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";

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 !

package dir1.dir2.mypackage;
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();

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 l’organisation Package/Classe/Fonction Utiliser un navigateur pour l’aide et pour “google” !

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

Faire des schémas Représentant les classes Pour comprendre les interactions entre les classes (qui a besoin d’une 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 d’autre qu’appeler une autre fonction sont fréquentes Dans les langages à objet compilés on les « inline » pour ne pas perdre de temps à l’exécution

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 ».

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.

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 !

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 R2 ), 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 l’extérieur empiler() depiler() sommet() enlever() = depiler()+sommet() Créer la classe InterfaceUtilisateurTexte Trois Piles (A, B, C),

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

Rappel : classe et objet
Nom de la classe : explicite commençant par une majuscule Attributs Constructeur(s) Méthodes 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); }

Rappel : classe et objet
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. 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); } 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(){...} ....

Rappel : Jedit

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.

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. Le client Le serveur public class C1 { private C2 o2; ... } public class C2 { ... }

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. Le client Le serveur public class C1 { private C2 o2; ... C1(...){ o2 = new C2(...); } public class C2 { ... }

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 ?

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.

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

Exemple en Javadoc 1/2 implements ItemSelectable, SwingConstants
javax.swing Class AbstractButton java.lang.Object | +--java.awt.Component +--java.awt.Container +--javax.swing.JComponent +--javax.swing.AbstractButton All Implemented Interfaces: ImageObserver, ItemSelectable, MenuContainer, Serializable, SwingConstants Direct Known Subclasses: JButton, JMenuItem, JToggleButton implements ItemSelectable, SwingConstants 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 …..

Exemple en Javadoc 2/2 Class java.lang.Object …
class java.awt.Component (implements java.awt.image.ImageObserver, … class java.awt.Container class javax.swing.CellRendererPane (implements javax.accessibility.Accessible) class javax.swing.JComponent (implements java.io.Serializable) class javax.swing.AbstractButton (implements java.awt.ItemSelectable, … class javax.swing.JButton (implements javax.accessibility.Accessible) class javax.swing.JMenuItem (implements javax.accessibility.Accessible, … class javax.swing.JCheckBoxMenuItem (implements … class javax.swing.JMenu (implements javax.accessibility.Accessible, … class javax.swing.JRadioButtonMenuItem (implements … class javax.swing.JToggleButton (implements javax.accessibility.Accessible) class javax.swing.JCheckBox (implements javax.accessibility.Accessible) class javax.swing.JRadioButton (implements javax.accessibility.Accessible) class javax.swing.Box (implements javax.accessibility.Accessible) class javax.swing.Box.Filler (implements javax.accessibility.Accessible) class javax.swing.JColorChooser (implements javax.accessibility.Accessible) class javax.swing.JComboBox (implements javax.accessibility.Accessible, …

Concept d’hé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 d’une 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

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.

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 public void setCouleur(int couleur) this.couleur=couleur; // désigne l'objet encours

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);

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){...}

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

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 l’erreur… Ne devrait-on pas demander en argument un type plus précis ? Dois-je tester le type avant de transtyper ?

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

Exemple animalier manger dormir marcher courir (2 x marcher) espèce
Tortue Cheval Ours courir galoper hiberner Cheval de traie Cheval de course galoper galoper

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

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

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

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 n’est 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 d’une instance

Classes enveloppes 1/3 Nombres entiers int Integer
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

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();

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()

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

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(...);

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" , ));

Exemple présidentiel 2/2
// ne doit etre appelle que par l’objet 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

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(<params du constructeur>) 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.

Héritage et constructeurs - suite
public class Object { public Object() {...} } 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; }

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); }

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();

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

Conseils de conception
Faire des schémas Représentant les classes et leur hierarchie Pour comprendre les interactions entre les classes (qui a besoin d’une 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.

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

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 Le client Le serveur public class Disque { private Point centre; ... Disque(...){ centre = new Point(...); } public class Point { ... } Composition

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. manger dormir espèce Animal hiberner manger manger courir galoper manger Tortue Cheval Ours

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 d’une 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

Rappel : héritage et constructeur
public class ClasseB extends ClasseA { double y = 0; // Pas de constructeur } public class ClasseA { double x; public ClasseA(double i){ this.x = i } > javac ClasseA.java ClasseB.java 1. 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

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

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

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 d’ambiguïté) import permet de spécifier le chemin des classes utilisées par rapport aux paquetages import java.io.File; import java.io.*;

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;

Exemple d’instance : 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

Packages : conseils Il n’y a pas d’inclusions récursives
N’hésitez pas à importer des paquetages entiers import java.awt.* n’importe 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()...

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. String nom, prenom; int age; Etudiant Etudiant e; e = new EtudiantSportif(); String sport; EtudiantSportif

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 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();

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 ! 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(); // 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); }

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.

exemple de vérification statique
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 ! public class B extends A { public void m1(){ System.out(«m1 de B»); } public void m2(){ System.out(«m2 de B»); Erreur de compilation : la méthode m2 n'existe pas pour un objet de type A !

exemple de lien dynamique (encore un)
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. 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»);

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 B toto() toto() ? toto() ? C toto() C toto() ? toto()

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"

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() !

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

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

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();

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) { return super.faitDecoupe(mesure_Arg); else return super.prepareDecoupe(); La notation super.super.m() n'est pas permise

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 Verification statique : le choix de la méthode est effectué à la compilation !

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<nbEtudiants; i++) liste[i].affiche(); }

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

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 Tortue Cheval Ours Instrument WoodWind Brass Flute Brass French Horn

public abstract class Instrument {...}
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).

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 { System.out.println ("Brass.play()"); ... public class Music { static void tune(Instrument i) { // ... i.play(); } static void tuneAll( Instrument[] e) { for(int i=0;i<e.length;i++) tune(e[i]); public static void main (String[] args) { Instrument[] orchestra = new Instrument[2]; int i = 0; orchestra[i++] = new Wind(); orchestra[i++] = new Brass(); tuneAll(orchestra);

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.

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.

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();

Nouveau problème ? ? manger dormir marcher courir espèce galoper
nager voler combattreAlEpee pointDeVie force ActionCharacter Animal ? ? Cheval Ours Hero galoper hiberner 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 ?

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.

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

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.

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.

Pensez à tout cela lors du projet !
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 !

Rappel & Outils.

POO Rappel Rappel important Instances Références Héritage Javadoc
Interface Classe Abstraites

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 n’importe où, sans contexte spécifique Fonction d’instance = appelée comme un service demandé à une instance

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 l’appelant se soucie de l’état de l’instance Classe Stocke des données et des fonctions uniques Fournit un service général Sert de modèle a la création d’instance

Instance Décrite au travers de la classe qui lui servira de modèle
Créée n’importe où grâce au mot-clé "new" Depuis une méthode statique de classe Depuis la méthode d’une instance N’est accessible qu’au 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 d’une méthode)

Référence Les références sont la seule façon de collaborer avec d’autres instance (sauf soi-même si on est une instance) Lorsque une instance n’a 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éé l’instance … sur laquelle on stocke une référence Mais ne pas confondre référence et classe !!!

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

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 { }

Exemple en Javadoc 1/2 public abstract class AbstractButton
javax.swing Class AbstractButton java.lang.Object | +--java.awt.Component +--java.awt.Container +--javax.swing.JComponent +--javax.swing.AbstractButton All Implemented Interfaces: ImageObserver, ItemSelectable, MenuContainer, Serializable, SwingConstants Direct Known Subclasses: JButton, JMenuItem, JToggleButton public abstract class AbstractButton extends JComponent implements ItemSelectable, SwingConstants 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 …..

Exemple en Javadoc 2/2 Class java.lang.Object …
class java.awt.Component (implements java.awt.image.ImageObserver, … class java.awt.Container class javax.swing.CellRendererPane (implements javax.accessibility.Accessible) class javax.swing.JComponent (implements java.io.Serializable) class javax.swing.AbstractButton (implements java.awt.ItemSelectable, … class javax.swing.JButton (implements javax.accessibility.Accessible) class javax.swing.JMenuItem (implements javax.accessibility.Accessible, … class javax.swing.JCheckBoxMenuItem (implements … class javax.swing.JMenu (implements javax.accessibility.Accessible, … class javax.swing.JRadioButtonMenuItem (implements … class javax.swing.JToggleButton (implements javax.accessibility.Accessible) class javax.swing.JCheckBox (implements javax.accessibility.Accessible) class javax.swing.JRadioButton (implements javax.accessibility.Accessible) class javax.swing.Box (implements javax.accessibility.Accessible) class javax.swing.Box.Filler (implements javax.accessibility.Accessible) class javax.swing.JColorChooser (implements javax.accessibility.Accessible) class javax.swing.JComboBox (implements javax.accessibility.Accessible, …

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

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 d’une des interfaces que remplit la classe On peut appeler une fonction de l’interface sans savoir du tout de quelle classe il s’agit On peut toujours transtyper Quand au déroulement d’une fonction On ne sait pas qui nous appelle (sauf si argument) On ne sait pas ce que l’appelant sait de nous

Classe abstraite Mélange de père et d’interface
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 d’interfaces 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 !

Outils de programmation
Membres et modificateurs Compteurs d’instances Droit d'accès Tableau d’accessibilité Jar et manifest Jar suite et fin IDE JEdit NetBeans 1 + 2 Eclipse Ant Exemple fichier Ant Démo NetBeans

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;

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

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

Tableau d’accessibilité
* * Si et seulement si la sous-classe est dans le même package !

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

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 l’origine de son contenu (voir doc. SUN)

Jar 3/3 Un jar peut contenir les sources (java), les autres ressources (gif, jpg, html, etc.) Les fichiers à l’inté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();

IDE Integrated Development Environment
Pour toutes les tâches ingrates … Trouver le nom d’une fonction Trouver le type d’un paramètre Vérifier les ; avant de lancer une compilation Changer le nom d’une 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.

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

Editeur d’interface

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

Ant Scripting de tâches de compilation Gestion de Projet
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)

Exemple fichier Ant <project name="BiSlider" basedir="../../.." default="build"> <property name="jar.name" value="BiSlider.jar"/> <property name="prop.dir" value="com/visutools/Properties"/> <property file="${prop.dir}/properties_${ant.project.name}"/> <property name="src.dir" value="com/visutools/nav/bislider"/> … <path id="project.class.path"> <pathelement location="${install.dir}/Resources.jar"/> <pathelement location="${install.dir}/Debug.jar"/> </path>

Exemple fichier Ant <target name="compile" description="compile BiSlider" depends="init"> <echo message="Compiling: ${ant.project.name}"/> <property name="pcp" refid="project.class.path"/> <echo message=" The classpath is: ${pcp}"/> <mkdir dir="${build.dir}"/> <javac source="1.5" target="1.5" sourcepath = "" srcdir="." destdir="${build.dir}" debug="off" optimize="on" deprecation="on" includeJavaRuntime="yes"> <include name="${src.dir}/*.java"/> <classpath refid="project.class.path"/> </javac> </target>

Exemple fichier Ant <target name="build" description="make the jar BiSlider.jar" depends="compile"> <mkdir dir="${install.dir}"/> <jar jarfile="${install.dir}/${jar.name}"> <manifest> <attribute name="Main-Class" value="com.visutools.nav.bislider.Test"/> <attribute name="Class-Path" value="Resources.jar"/> <section name="com.visutools.nav.bislider"> …… <attribute name="Implementation-Title" value="com.visutools.bislider" /> </section> </manifest> <fileset dir="${build.dir}"> <include name="${src.dir}/**/*.class"/> </fileset> <fileset dir="${src.dir}"> <include name="**/*.java"/> </jar> </target>

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

Programmation Objet en JAVA.

Exception et Entrées-sorties
Introduction Rattrapage d’exception Syntaxe try{… }catch(…){…} Factorisation de catch(s) Exemple Exemple type de Fichier Classe Exception Affichage d’exception Jeter ses propres exceptions Exemple CreateNewFile() Signature et Héritage Conseils de Christian Conseils de Bruce Entrées-Sorties 0bjets d’Entrées-Sorties Chaine d’Entrées-Sorties Entrées-Sorties de char Entrées-Sorties d’objets Sérialisation Utilisation Objets divers d’Entrées-Sorties System.xxx Exemple : écrire une Exception

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

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 l’a appelée et ainsi de suite mais on voudrait pas tout planter !

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 !)

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"); }

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. 2er4 Ce n'est pas un entier!

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) { } catch (memoryAllocationFailed) { } catch (readFailed) { } catch (fileCloseFailed) { }

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 l’appel 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

Affichage Par défaut si une exception n’est pas attrapée elle plante le programme et s’affiche 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 l’affichage dans un catch() catch(MyException MyException_Arg) { MyException_Arg.printStackTrace(); }

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 s’est produite”)); Si vous ne pouvez pas gérer l’exception relancez la au dessus ! catch(Exception exception_Arg) { System.err.println("An exception was thrown"); throw exception_Arg; }

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

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"); } return File1;

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 s’utiliser de la même façon Les exceptions possibles font parties de la signature Java cherche l’exception la plus proche du type qu’elle doit traiter Si rien ne correspond ou si pas de try on remonte Le premier truc qui correspond est utilisé et tout s’arrête !

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

Conseils de Bruce Gérer le problème au niveau adéquate. (éviter d’attraper l’exception 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 qu’ils puissent finir la réparation Pareil que point précèdent mais lancer une exception d’un 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, c’est un investissement a court terme pour le debugging et a long terme pour la robustesse

Entrées-Sorties 1 classe pour les fichiers : File
Les mécanismes objets permettent d’organiser les liens à l’inté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

Objets d’Entré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();

Chaîne d’entré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); Attention au try-catch La compilation impose IOException File FileInputStream BufferedInputStream DataInputStream File FileOutputStream BufferedOutputStream DataOutputStream

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);

Entrées-Sorties d’Objets
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 à l’ordre FileNotFound… est une IOException, pas ClassNotFound !

Sérialisation Ce que nous venons de voir
Est lié à la programmation orientée objet S’appelle la sérialisation ! Ne marche pas entre deux versions successives d’un 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)

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

Objets divers d’Entré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 qu’un 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 !

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 : double chaînage en 1 ligne Attention à s = in.readLine())!=null stockage (dans s) et test en même temps

Exemple : écrire une Exception
// créer le fichier de sortie try { File = new File("traces.txt"); FileWriter = 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());}

IFT Structures de données

Présentations similaires

Présentation au sujet: "IFT Structures de données"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back

Entrer

S'autoriser via un réseau social:

IFT Structures de données

Présentations similaires

Présentation au sujet: "IFT Structures de données"— Transcription de la présentation:

Présentations similaires

Notre projet

Feed-back