Cours intensif Java

1er cours: de C ` a Java

Janvier 2011

Enrica Duchi

LIAFA, Paris 7

Enrica.Duchi@liafa.jussieu.fr

Introduction Premiers pas en Java La notion dobjet et les classes Un peu de syntaxe de Java Une classe du JDK pour les entr ees sorties. La gestion des erreurs ` a laide des exceptions Variables de classes ou dinstance

Langages de programmations
Pour ex ecuter un algorithme sur un ordinateur, il faut le traduire dans un langage de programmation: d ecrire de mani` ere non ambigu e les etapes de calcul ` a eectuer par le processeur. Historiquement, sont apparus dabord des langages bas niveau: code ecrit directement en langage machine, avec les op erations du processeur. Programmes peu lisibles. Portabilit e tr` es limit ee (r e ecrire pour changer dordinateur) Seul avantage (?): le programmeur contr ole tout ce qui se passe

Langages de programmations
Pour ex ecuter un algorithme sur un ordinateur, il faut le traduire dans un langage de programmation: d ecrire de mani` ere non ambigu e les etapes de calcul ` a eectuer par le processeur. Historiquement, sont apparus dabord des langages bas niveau: code ecrit directement en langage machine, avec les op erations du processeur. Programmes peu lisibles. Portabilit e tr` es limit ee (r e ecrire pour changer dordinateur) Seul avantage (?): le programmeur contr ole tout ce qui se passe Aujourdhui on utilise plus couramment des langages haut niveau: le code tend ` a ressembler ` a la description de lalgorithme, il est compil e ou interpr et e par un programme pour etre ex ecut e par le processeur. Langages plus expressifs, automatisation de la gestion de la m emoire programmation plus ais ee, plus sure. Meilleure portabilit e Ecacit e en progr` es grace ` a lam elioration des interpr eteurs/compilateurs

Interpr etation vs compilation

Que faire avec un programme ecrit dans un langage haut niveau ? Interpr eter: traduction et ex ecution ` a la vol ee des instructions par exemple: un script interpr et e par un shell (interpr eteur) Compiler: en langage machine: production dun ex ecutable natif gcc par ex. programme C ex ecutable + ex ecution directe par le processeur dans un langage interm ediaire bas niveau: production de bytecode javac par ex. programme java bytecode + interpr etation par un interpr eteur bytecode java interpr et e par une JVM (machine virtuelle java) Inter et du mod` ele Java. Le bytecode est un langage de bas niveau interpr etation ecace Le bytecode est ind ependant de la machine portabilit e du code.

Styles de programmation haut niveau

Programmation imp erative (fortran, pascal, C) bas ee sur: lop eration daectation (remplacer une valeur par une autre en m emoire) la s equentialit e des op erations, formant un ot le contr ole du ot (branchements, it erations) lusage de fonctions pour limiter la duplication de code

Programmation fonctionnelle (Lisp, ML, CAML) bas ee sur: lop eration d evaluation (programme = expression ` a evaluer) les appels de fonctions et la r ecursivit e Programmation orient ee objet lobjet, unit e de base du programme, encapsule un ensemble de donn ees et dactions applicables ` a celles-ci. soit fonctionnelle (CLOS, OCAML) ou it erative (C++, Java) Java est un langage orient e objet imp eratif

Quelques caract eristiques de Java

Une syntaxe inspir ee de C mais pas de manipulation explicite de pointeurs les structures sont enrichies et deviennent des objets. la gestion de la m emoire est con ee au compilateur Un langage orient e objet g erant la m emoire automatiquement fourni avec une riche biblioth` eque de programmes r eutilisables: les packages du JDK (Java Development Kit) incluant la possibilit e de programmation concurrente (multithread): ex ecution de plusieurs ots dinstructions parall` eles au sein dun m eme programme (hors du champs de ce cours)

Java et internet
Applet: programmes ecrits en java et int egr es dans une page web utilis ees pour cr eer des applications interactives quon ne peut pas faire avec HTML (HTML fait uniquement de la mise en page) charg ees depuis une machine distante (serveur) mais ex ecut ee sur la machine locale (client) ex ecut ee sous le contr ole dune autre application (navigateur avec interpr eteur Java) Servlet: (hors du champs de ce cours) pour d evelopper des serveurs pour internet

Le langage Java
Bibliographie: Bruce Eckel, Comment penser en java ? http://penserenjava.free.fr Sites webs: http://www.oracle.com/technetwork/java/index.html produits, mais surtout docs en ligne et tutoriaux: ` a consulter !! Historique 1990: chez Sun, groupe de travail sur la portabilit e des programmes 1995: JDK 1.0 avec 200 classes disponibles ... Java 2 (JdK 1.2 ` a 1.5) avec > 3000 classes aujourdhui, rachet e et d evelopp e par Oracle: Java SE 6, bient ot 7 La compatibilit e ascendante permet de continuer ` a utiliser avec les nouvelles versions, les programmes ecrits pour les anciennes versions.

Conclusions: avantages de Java

Un langage simple, orient e objets et familier (syntaxe proche du C) Environnement de travail riche (biblioth` eque de programmes) Programmes ex ecutables partout, ind ependamment de larchitecture. Robustesse, s ecurit e Un langage prenant en compte depuis le d ebut les besoins de la programmation internet. Un langage orant la possibilit e de programmation concurrente.

Introduction Premiers pas en Java La notion dobjet et les classes Un peu de syntaxe de Java Une classe du JDK pour les entr ees sorties. La gestion des erreurs ` a laide des exceptions Variables de classes ou dinstance

Un premier programme Java

// fichier Bonjour.java class Bonjour{ public static void main ( String [] args ) { System.out.println("Hello"); } } Si on ne garde que le texte en noir, on a un quasiment programme C, on expliquera petit ` a petit le sens du reste du programme.

Un premier programme Java

// fichier Bonjour.java class Bonjour{ public static void main ( String [] args ) { System.out.println("Hello"); } } Si on ne garde que le texte en noir, on a un quasiment programme C, on expliquera petit ` a petit le sens du reste du programme. En java, toutes d eclaration ou d enition de variables, de fonctions ou de proc edures se fait ` a linterieur dune classe. La classe Bonjour, du fait quelle contient la proc edure main, doit etre contenue dans un chier de m eme nom Bonjour.java. On verra que cest plus g en eralement le cas de toutes les classes dites publiques.

Un premier programme Java

// fichier Bonjour.java class Bonjour{ public static void main ( String [] args ) { System.out.println("Hello"); } } Si on ne garde que le texte en noir, on a un quasiment programme C, on expliquera petit ` a petit le sens du reste du programme. editeur de texte (nedit, emacs) Bonjour.java j ecris le code de mon 1er programme Bonjour.java compilation: > javac Bonjour.java le compilateur javac produit le bytecode Bonjour.class ex ecution: > java Bonjour linterpr eteur java interpr` ete le bytecode et ecrit Hello. Comme en C lex ecution d ebute par lappel de la m ethode main.

Un deuxi` eme exemple dans le style du C

// fichier SommeCarres.java class SommeCarres{ static int calcul (int n){ int i,s=0; for (i=0;i<n;i++) s=s+i*i; return s; } public static void main ( String [] args ){ if (args.length != 1) System.out.println("Donner le nb de termes en argument"); else System.out.println("Somme des carr es ="+calcul(args[0])); } } ` premi` A ere vue, lint erieur dune classe ressemble ` a un programme C: d eclarations de variables, fonctions, boucles, tests, etc.

Les types en java

Types primitifs: caract` eres, entiers, r eels et bool eens char: caract` eres, cod es sur 2 octets (code unicode, au lieu dASCII du C) byte, short, int, long: entiers sur 1, 2, 4 ou 8 octets float, double : ottants sur 4 ou 8 octets. boolean : valeur true ou false Les op erateurs arithm etiques sont essentiellement les m emes quen C. Les types num eriques par d efauts des constantes explicites sont int et double. Types r ef erenc es: les types complexes sont d enis par les classes, qui remplacent les structures du C: class Point{ float x,y; d enition dun type dobjets avec deux champs ottants. } Tableaux, cha nes: pour les tableaux, int [], Point [], comme en C; pour les cha nes, la classe String.

Introduction Premiers pas en Java La notion dobjet et les classes Un peu de syntaxe de Java Une classe du JDK pour les entr ees sorties. La gestion des erreurs ` a laide des exceptions Variables de classes ou dinstance

Les classes et un premier aper cu de la notion dobjet.

L ecriture dune classe permet de d enir un nouveau type dobjets et/ou des fonctions ou proc edures relatives ` a cette classe. // fichier ProgrammeTest.java class Point{ float x,y; static void afficheAbscisse(Point p){ System.out.println(p.x); } } class ProgrammeTest{ public static void main ( String [] args){ Point p; p = new Point(); Point.afficheAbscisse(p); } }

Les classes et un premier aper cu de la notion dobjet.

L ecriture dune classe permet de d enir un nouveau type dobjets et/ou des fonctions ou proc edures relatives ` a cette classe. // fichier ProgrammeTest.java class Point{ float x,y; d enition dun type dobjets avec deux champs ottants. static void afficheAbscisse(Point p){ System.out.println(p.x); } } class ProgrammeTest{ public static void main ( String [] args){ Point p; p = new Point(); Point.afficheAbscisse(p); } }

Les classes et un premier aper cu de la notion dobjet.

L ecriture dune classe permet de d enir un nouveau type dobjets et/ou des fonctions ou proc edures relatives ` a cette classe. // fichier ProgrammeTest.java class Point{ float x,y; d enition dun type dobjets avec deux champs ottants. static void afficheAbscisse(Point p){ System.out.println(p.x); } d enition dune fonction relative aux Points } class ProgrammeTest{ public static void main ( String [] args){ Point p; p = new Point(); Point.afficheAbscisse(p); } }

Les classes et un premier aper cu de la notion dobjet.

L ecriture dune classe permet de d enir un nouveau type dobjets et/ou des fonctions ou proc edures relatives ` a cette classe. // fichier ProgrammeTest.java class Point{ float x,y; d enition dun type dobjets avec deux champs ottants. static void afficheAbscisse(Point p){ System.out.println(p.x); } d enition dune fonction relative aux Points } class ProgrammeTest{ public static void main ( String [] args){ Point p; d eclaration dune variable de type Point p = new Point(); Point.afficheAbscisse(p); } }

Les classes et un premier aper cu de la notion dobjet.

L ecriture dune classe permet de d enir un nouveau type dobjets et/ou des fonctions ou proc edures relatives ` a cette classe. // fichier ProgrammeTest.java class Point{ float x,y; d enition dun type dobjets avec deux champs ottants. static void afficheAbscisse(Point p){ System.out.println(p.x); } d enition dune fonction relative aux Points } class ProgrammeTest{ public static void main ( String [] args){ Point p; d eclaration dune variable de type Point p = new Point(); cr eation dun objet Point ( malloc) Point.afficheAbscisse(p); } }

Les classes et un premier aper cu de la notion dobjet.

L ecriture dune classe permet de d enir un nouveau type dobjets et/ou des fonctions ou proc edures relatives ` a cette classe. // fichier ProgrammeTest.java class Point{ float x,y; d enition dun type dobjets avec deux champs ottants. static void afficheAbscisse(Point p){ System.out.println(p.x); } d enition dune fonction relative aux Points } class ProgrammeTest{ public static void main ( String [] args){ Point p; d eclaration dune variable de type Point p = new Point(); cr eation dun objet Point ( malloc) Point.afficheAbscisse(p); utilisation dune fonction dune autre classe } }

Les classes et un premier aper cu de la notion dobjet.

L ecriture dune classe permet de d enir un nouveau type dobjets et/ou des fonctions ou proc edures relatives ` a cette classe. // fichier ProgrammeTest.java class Point{ float x,y; d enition dun type dobjets avec deux champs ottants. static void afficheAbscisse(Point p){ System.out.println(p.x); } d enition dune fonction relative aux Points } class ProgrammeTest{ public static void main ( String [] args){ Point p; d eclaration dune variable de type Point p = new Point(); cr eation dun objet Point ( malloc) Point.afficheAbscisse(p); utilisation dune fonction dune autre classe } On dit que lobjet cr ee est une instance de la classe Point }

Introduction Premiers pas en Java La notion dobjet et les classes Un peu de syntaxe de Java Une classe du JDK pour les entr ees sorties. La gestion des erreurs ` a laide des exceptions Variables de classes ou dinstance

Organisation du code
Un programme Java est form e dun ou plusieurs chiers, contenant chacun une ou plusieurs d enitions de classe. En 1` ere approx, une d enition de classe est de la forme: <modificateur> class <NomDeClasse> { <d eclaration des variables globales de la classe> <d efinition des m ethodes de la classe> } Le modicateur permet de pr eciser les propri et es de la classe (cf. plus loin) Les m ethodes sont les fonctions ou proc edures fournies dans la classe. Elles sont organis ees ` a peu pr` es comme des fonctions du C: <modificateur> <type retour> <nom> (<liste parametres> ){ <d eclaration des variables locales> <instructions> }

Relisons lexemple
// fichier SommeCarres.java class SommeCarres{ static int calcul (int n){ int i,s=0; for (i=0;i<n;i++) s=s+i*i; return s; } public static void main ( String [] args ){ if (args.length != 1) System.out.println("Donner le nb de termes en argument"); else System.out.println("Somme des carr es ="+calcul(args[0])); } } Le chier contient une classe (SommeCarres) contenant deux m ethodes (calcul et main).

Les variables locales (i.e. apparaissant dans les m ethodes)

Les variables doivent etre d eclar ees pour pouvoir etre utilis ees (comme en C). variables de type primitif int entier; double reel = 2.5; char caractere = ` a; la place m emoire n ecessaire est allou ee ` a la d eclaration. variables de type r ef erenc e: int [] tableau; float [][] matrice; Point p; Ces variables ressemblent aux pointeurs du C: ` a la d eclaration dune telle variable, seule la place pour stoquer ladresse dun objet est allou ee; il faudra ensuite cr eer lobjet ` a laide dun appel new. int p = new Point(); Lobjet cr e e par new est appel e une instance de sa classe.

Blocs, port ee, surcharge

Blocs. Comme en C, les accolades { et } d elimitent des blocs dinstructions. Par <instruction> on d esigne une instruction el ementaire ou un bloc. Port ee. Si un bloc contient des d eclarations de variables, celles-ci ne sont visibles que dans le bloc. Contrairement au C, java ne permet pas de r eutiliser un nom de variable locale d ej` a visible dans le bloc courant. Lexemple suivant, ` a lint erieur dun bloc, provoque une erreur ` a la compilation: int i=1; { int i=2; } Surcharge. Par contre on peut d enir plusieurs m ethodes ayant le m eme nom dans la m eme classe, si elles ont des signatures di erentes (cest-` a-dire des arguments de types di erents).

Constantes, expressions, conversion (cast)

Une constante est une variable qui ne peut etre modi ee: final double pi = 3.14 Les expressions sont form ees de variables et de constantes combin ees ` a laide dop erateurs ( les m emes quen C, avec les m emes priorit es): le type de lexpression doit etre coh erent: 2*true provoque une erreur. seules les conversions byteshort . . . double sont implicites: float angle = pi; provoque une erreur, il faut une conversion explicite (cast) float angle = (float) pi; les variables doivent etre initialis ees: int i = 1, j, k; k = i + j; provoque une erreur ` a la compilation (contrairement au C) Les expressions peuvent aussi contenir des appels de fonctions.

Chaines
Les chaines sont manipul ees ` a laide de la classe String La d eclaration dune chaine alloue la place pour une r ef erence: String mot; Alors quon cr ee normalement les objets par un appel new, on peut cr eer des cha nes explicitement avec labbr eviation: mot = "Bonjour"; une chaine est un objet constant: ` a lex ecution du fragment mot = "Bonjour"; mot = "Ciao"; deux objets di erents sont cr e es successivement; au d ebut la variable mot contient la r ef erence ` a la 1` ere cha ne, puis la r ef erence ` a la 2nde. lorsquun objet nest plus r ef erenc e par aucune variable la m emoire est automatiquemet lib er e par le GC (garbage collector). Lop erateur + agit par concat enation sur les cha nes: mot = "Ciao " + nom + ", tu as le num ero "+ i + "."; Les types primitifs sont munis dune fonction de conversion en cha ne appel ee implicitement dans les expressions de cha ne.

Instructions de contr ole du ot

Conditionnelles: if ( <condition> ) <instruction si true> [else <instruction si false> ] switch(<condition> ){ case<valeur> : <instruction> [break;] case<valeur> : <instruction> [break;] ... [default:<instruction> ] } It erations: while ( <condition> ) <instruction> do <instruction> while (<instruction> ) for (<init> ; <arr^ et> ; <incr em> ) <instruction> Les instructions continue ou break provoquent la sortie du bloc dinstruction de lit eration la plus interne, avec ou sans poursuite de lit eration.

Tableaux
Comme en C, un tableau est form e dobjets tous de m eme type. D eclaration: int [] tableauEntiers; String [] args; int [] [] matrice; La taille nest pas sp eci ee ` a la d eclaration. Allocation: tableauEntier = new int[10]; args = new String [20]; matrice = {{1,2,3},{1,2},{1,2,3,4,5,6}} matrice = new int [] [15]; Lappel new <type> [n] alloue un tableau de n objets du type sp eci e et renvoit la r ef erence ` a ce tableau. Utilisation: for (i=0; i<tableauEntier.length; i++) System.out.println(tableauEntier[i]);

Variables de classes et variables dinstances

Dans la d enition dune classe on distingue deux types de variables globales: Variable de classes: une variable est cr e e pour toute la classe et elle est partag ee par toutes les instances. Indiqu ee par le mot clef static. Variable dinstance: une variable est cr e e pour chaque instance lors de son allocation par new. class Point{ D` es la compilation, la variable static int nbPoints; nombrePoints est cr e ee. float x,y; Chaque fois quun objet de la classe } Point est cr e e (appel new Point()), une paire de variables x et y lui sont associ ees. Apr` es lex ecution du fragment Point [] tableau; for (i=0; i<10; i++){ tableau[i]=new Point(); nbPoints++ } on a allou e 10 paires de float (les tableau[i].x et tableau[i].y) mais il ny a toujours quune seule variable nbPoints, augment ee de 10.

Introduction Premiers pas en Java La notion dobjet et les classes Un peu de syntaxe de Java Une classe du JDK pour les entr ees sorties. La gestion des erreurs ` a laide des exceptions Variables de classes ou dinstance

Entr ee sortie: le package java.io.Console

Dans un premier temps on peut se limiter ` a la classe java.io.Console qui fournit des entr ees sorties au clavier dutilisation imm ediate. Chargement: ajouter import java.io.Console; en d ebut de chier D eclarer et activer la console: Console cons = System.Console(); Lecture et ecriture: cons.readLine(): renvoit une cha ne de caract` ere contenant une ligne entr ee au clavier. Lappel peut inclure une cha ne dinvitation pass ee en param` etre, par ex: reponse = cons.readLine("question ? ");

cons.printf(String format, [arguments du format]): ecrit une cha ne formatt ee sur le terminal. Conversion: Aux types primitifs (int, double,...) correspondent des classes (java.lang.Integer, java.lang.Double,...) qui fournissent des m ethodes: int Integer.parseInt(String s): convertir une cha ne en entier. String Integer.toString(int i): renvoit une cha ne repr esentant lentier (utilis e implicitement dans "les " + i + " amis"). int Double.parseDouble(String s): idem pour les doubles, String Double.toString(double d)

Entr ee sortie: le package java.io.Console

Un exemple // Fichier Exemple.java import java.io.Console; class Exemple{ static int annee = 2009; public static void main(String [] args){ Console cons = System.Console(); String texte = cons.readLine("Entrer un entier: ") int i = Integer.parseInt(texte); cons.printf("Tu es n e en %d.%n", annee-i); } } Format: Les cha nes formatt ees de Java ressemblent ` a celles du C: les sp ecicateurs de format sont de la forme %[i$]c o` u le caract` ere c sera typiquement: s pour une cha ne, d pour un entier, f pour un ottant, c pour un caract` ere et n pour le retour ` a la ligne, tandis que lindice i$ optionnel indique le num ero de largument ` a ins erer.
cons.printf("M. %1$s %3$s et Mme %2$s %3$s.", prenomMari, prenomFemme, nomFamille)

Introduction Premiers pas en Java La notion dobjet et les classes Un peu de syntaxe de Java Une classe du JDK pour les entr ees sorties. La gestion des erreurs ` a laide des exceptions Variables de classes ou dinstance

Exceptions: un m ecanisme de gestion des erreurs

Une op eration qui produit une erreur (par ex. division par 0) l` eve une exception, qui se propage dans la pile des m ethodes ayant conduit ` a lerreur jusqu` a ce quelle soit attrap ee : si elle nest pas attrap ee avant d etre propag ee par la m ethode main, elle provoque larr et de lex ecution. class Divise{ static int div(int i, int j){ return(i/j); } public static void main (String [] args){ int i=3, j=0, d=0; try{ d=div(i,j); }catch(ArithmeticException e){ System.out.println("division par zero); } } Le pi` ege ` a exception se pose autour dun bloc: } try{bloc}catch(UneException){que faire} catch(UneAutre){que faire}

Exceptions: un m ecanisme de gestion des erreurs

Une op eration qui produit une erreur (par ex. division par 0) l` eve une exception, qui se propage dans la pile des m ethodes ayant conduit ` a lerreur jusqu` a ce quelle soit attrap ee : si elle nest pas attrap ee avant d etre propag ee par la m ethode main, elle provoque larr et de lex ecution. class Divise{ static int div(int i, int j){ la division par 0 l` eve ArithmeticException return(i/j); } public static void main (String [] args){ int i=3, j=0, d=0; try{ d=div(i,j); }catch(ArithmeticException e){ System.out.println("division par zero); } } Le pi` ege ` a exception se pose autour dun bloc: } try{bloc}catch(UneException){que faire} catch(UneAutre){que faire}

Exceptions: un m ecanisme de gestion des erreurs

Une op eration qui produit une erreur (par ex. division par 0) l` eve une exception, qui se propage dans la pile des m ethodes ayant conduit ` a lerreur jusqu` a ce quelle soit attrap ee : si elle nest pas attrap ee avant d etre propag ee par la m ethode main, elle provoque larr et de lex ecution. class Divise{ static int div(int i, int j){ la division par 0 l` eve ArithmeticException return(i/j); } cette exception nest pas attrap ee dans div (pas de try) public static void main (String [] args){ int i=3, j=0, d=0; try{ d=div(i,j); }catch(ArithmeticException e){ System.out.println("division par zero); } } Le pi` ege ` a exception se pose autour dun bloc: } try{bloc}catch(UneException){que faire} catch(UneAutre){que faire}

Exceptions: un m ecanisme de gestion des erreurs

Une op eration qui produit une erreur (par ex. division par 0) l` eve une exception, qui se propage dans la pile des m ethodes ayant conduit ` a lerreur jusqu` a ce quelle soit attrap ee : si elle nest pas attrap ee avant d etre propag ee par la m ethode main, elle provoque larr et de lex ecution. class Divise{ static int div(int i, int j){ la division par 0 l` eve ArithmeticException return(i/j); } cette exception nest pas attrap ee dans div (pas de try) public static void main (String [] args){ int i=3, j=0, d=0; try{ d=div(i,j); elle remonte dans main, o` u elle est attrap ee }catch(ArithmeticException e){ System.out.println("division par zero); } } Le pi` ege ` a exception se pose autour dun bloc: } try{bloc}catch(UneException){que faire} catch(UneAutre){que faire}

Exceptions: un m ecanisme de gestion des erreurs

Une op eration qui produit une erreur (par ex. division par 0) l` eve une exception, qui se propage dans la pile des m ethodes ayant conduit ` a lerreur jusqu` a ce quelle soit attrap ee : si elle nest pas attrap ee avant d etre propag ee par la m ethode main, elle provoque larr et de lex ecution. class Divise{ static int div(int i, int j){ la division par 0 l` eve ArithmeticException return(i/j); } cette exception nest pas attrap ee dans div (pas de try) public static void main (String [] args){ int i=3, j=0, d=0; try{ d=div(i,j); elle remonte dans main, o` u elle est attrap ee }catch(ArithmeticException e){ System.out.println("division par zero); le message derreur sache } } Le pi` ege ` a exception se pose autour dun bloc: } try{bloc}catch(UneException){que faire} catch(UneAutre){que faire}

Exceptions: un m ecanisme de gestion des erreurs

` c A ot e des erreurs dex ecution, il est possible dutiliser les exceptions pour rep erer la mauvaise utilisation dune fonction: Ainsi la m ethode in parseInt(String s) du package java.lang.Integer l` eve une exception si la cha ne quon lui donne ne repr esente pas un entier. Si on est pas s ur que la chaine pass ee en argument repr esente un entier, on peut metttre un couple try/catch pour pr eciser comment le probl` eme doit etre trait e. try{ i=parseInt(s); }catch(NumberFormatException e){ System.out.println("s non entier, je prends i=0"); i=0; } Dans ce cas lex ecution continuera avec i=0 si la chaine n etait pas valide. On aurait pu mettre System.exit(1) pour interrompre apr` es le message.

Introduction Premiers pas en Java La notion dobjet et les classes Un peu de syntaxe de Java Une classe du JDK pour les entr ees sorties. La gestion des erreurs ` a laide des exceptions Variables de classes ou dinstance Les prochaines fois: 2` eme cours: Les objets. Lh eritage. 3` eme cours: Les applets.

Cours intensif Java

2` eme cours: h eritage
Janvier 2011

Enrica Duchi

LIAFA, Paris 7

Enrica.Duchi@liafa.jussieu.fr

Variables de classe et dinstance; constantes Constructeurs M ethodes de classe et dinstance H eritage Classes abstraites et interfaces Modicateurs dacc` es Packages

Rappel: Variables de classes et variables dinstances

Dans la d enition dune classe on distingue deux types de variables globales: Variable de classes: une variable est cr e e pour toute la classe et elle est partag ee par toutes les instances. Indiqu ee par le mot clef static. Variable dinstance: une variable est cr e e pour chaque instance lors de son allocation par new. class Point{ D` es la compilation, la variable static int nbPoints; nombrePoints est cr e ee. float x,y; Chaque fois quun objet de la classe } Point est cr e e (appel new Point()), une paire de variables x et y lui sont associ ees. Apr` es lex ecution du fragment Point [] tableau; for (i=0; i<10; i++){ tableau[i]=new Point(); nbPoints++ } on a allou e 10 paires de float (les tableau[i].x et tableau[i].y) mais il ny a toujours quune seule variable nbPoints, augment ee de 10.

Constantes, initialisation
Les constantes sont construites avec le mot clef final. final static float Pi=3.1415; Une constante nest plus modiable apr` es sa d eclaration, il faut donc linitialiser imm ediatement, et il est inutile dintroduire des constantes qui ne soient pas statiques (on aurait autant de copies identiques que dobjets). Les variables globales (dinstance ou de classe) sont initialis ees par d efaut en Java, alors que les variables locales (d enies dans les m ethodes) doivent etre initialis ee avant d etre utilis ee sous peine derreur de compilation,

Les valeurs par d efaut sont 0 pour les types num eriques, false pour boolean. Les variables de type non primitif contiennent des r ef erences ` a des objets (et non des objets directement). Elles sont donc initialis ees par d efaut ` a null.

Vers la programmation objet. Premier sch ema

classes class Point nbPts=3 instances x=2 y=1 class Point{ static int nbPts; oat x,y; } class Cercle{ nal static oat pi = 3.1415; static int nbCercles; Point centre; oat rayon; } class Cercle pi=3.1415 nbCercles=2

x=3 y=0

x=0 y=1

class MonExecutable{ public static void main (String [] args){ Point p1, p2, p3; Cercle c1, c2; p1=new Point(); p2=new Point(); p3=new Point(); p1.x=2; p1.y=1; p2.x=3; p3.y=1; c1=new Cercle(); c1.centre=p2; c1.rayon=3; c2=new Cercle(); c2.centre=p3; c2.rayon=1; Point.nbPts=3; Cercle.nbCercles=2; }

centre = rayon = 3 centre = rayon = 1

class MonExecutable p1= p2= p3= c1= c2=

Vers la programmation objet. Premier sch ema

classes class Point nbPts=3 instances x=2 y=1 class Point{ static int nbPts; oat x,y; } class Cercle{ nal static oat pi = 3.1415; static int nbCercles; Point centre; oat rayon; } class Cercle pi=3.1415 nbCercles=2

x=3 y=0

x=0 y=1

class MonExecutable{ public static void main (String [] args){ Point p1, p2, p3; Cercle c1, c2; p1=new Point(); p2=new Point(); p3=new Point(); p1.x=2; p1.y=1; p2.x=3; p3.y=1; c1=new Cercle(); c1.centre=p2; c1.rayon=3; c2=new Cercle(); c2.centre=p3; c2.rayon=1; Point.nbPts=3; Cercle.nbCercles=2; }

centre = rayon = 3 centre = rayon = 1

class MonExecutable p1= p2= p3= c1= c2=

on voudrait faire ca en 1 op eration

Variables de classe et dinstance; constantes Constructeurs M ethodes de classe et dinstance H eritage Classes abstraites et interfaces Modicateurs dacc` es Packages

Constructeurs
Les constructeurs sont des m ethodes particuli` eres, de m eme nom que la classe, qui permettent de sp ecier des op erations ` a faire lors de la cr eation des objets par new. Ils sont d enis dans la classe juste apr` es les variables. class Point{ static int nbPts; float x,y; Point(float nx, float ny){ x=nx; y=ny; nbPts++; } } On peut alors ecrire: Point p = new Point(3,1);

Constructeurs et surcharge
On peut donner plusieurs constructeurs pour une m eme classe ` a condition quils aient des signatures (types des arguments) di erents. class Point{ static int nbPts; float x,y; Point(){ nbPts++; } Point(float nx, float ny){ x=nx; y=ny; nbPts++; } } Dans cet exemple on a red enit le constructeur par d efaut (sans argument), le compteur nbPts sera donc incr ement e par chaque appel new Point()

Lobjet this et le constructeur this()

Les variables locales peuvent cacher des variables dinstances. Dans ce cas on peut utiliser this, qui d esigne lobjet courant, pour lever lambiguit e: class Point{ static int nbPts; float x,y; Point(float x, float y){ this.x=x; this.y=y; nbPts++; } } Lappel this(arguments) permet quant ` a lui dutiliser un constructeur pour en d enir un autre. Ainsi si on ajoute dans la classe Point le fragment Point(){ this(1,1); } le constructeur par d efaut est red eni pour incr ementer nbPts et donner la valeur (1,1) aux points cr ees par new Point()

Vers la programmation objet. Avec constructeurs

class Point{ static int nbPts; float x,y; Point(float x, float y){ this.x=x; this.y=y; nbPts++; } } class Cercle{ nal static oat pi = 3.1415; static int nbCercles; Point centre; oat rayon; Cercle(Point p, oat r){ centre = p; rayon = r; nbCercles++; } } class MonExecutable{ public static void main (String [] args){ Point p1, p2, p3; Cercle c1, c2; p1=new Point(1,2); p2=new Point(3,0); p3=new Point(0,1); c1=new Cercle(p2,3); c2=new Cercle(p3,1); } classes class Point nbPts=3 instances x=2 y=1

x=3 y=0

x=0 y=1

class Cercle pi=3.1415 nbCercles=2

centre = rayon = 3 centre = rayon = 1

class MonExecutable p1= p2= p3= c1= c2=

Variables de classe et dinstance; constantes Constructeurs M ethodes de classe et dinstance H eritage Classes abstraites et interfaces Modicateurs dacc` es Packages

M ethodes de classes et m ethode dinstances

Comme les variables, les m ethodes sont de deux types: M ethode de classes: elle peut etre invoqu ee m eme sil ny a pas dinstances de la classe; elle na acc` es directement quaux variables de classe de la classe. Indiqu ee par le mot clef static. M ethode dinstance: elle doit etre invoqu ee par linterm ediaire dun objet; la m ethode dun objet a acc` es aux variables dinstance de cet objet ainsi qu` a toutes les variables de classe de sa classe. class Point{ float x,y; static boolean compare(Point p1, Point p2){ return (p1.x == p2.x) && (p1.y == p2.y); } boolean equals(Point p){ return (x == p.x) && (y == p.y); } } Les appels compare(p1,p2) et p1.equals(p2) sont equivalents.

M ethodes de classes et m ethode dinstances

Les variables et m ethodes de classes et dinstances peuvent cohabiter: class Point{ static int nbPts; float x,y; Point(float x, float y){ this.x=x; this.y=y; nbPts++; } static void remetAZero(){ nbPts = 0; } String toString(){ return("(" + x + "," + y + ")"); } } On verra que les classes de la JDK poss` edent toutes des m ethodes toString et equals.

Remarques sur la manipulation des variables

Les variables de type non primitif contiennent des r ef erences ` a des objets: Point unPoint, leMeme; unPoint = new Point(2,1); leMeme = unPoint; dans ce fragment la variable leMeme indique le m eme objet que unPoint. Pour permettre la duplication on peut fournir une m ethode clone: class Point implements clonable{ signale que la m ethode est disponible (cf plus loin) ... Point clone(){ Point p = new Point(this.x, this.y); } } On peut alors ecrire: Point unPoint, unAutreMaisIdentique; unPoint = new Point(2,1); unAutreMaisIdentique = unPoint.clone(); Au retour dun appel de m ethode, les variables de type primitifs pass ees en param` etre ne sont pas modi ees mais pour les autres on a pass e une r ef erence.

Variables de classe et dinstance; constantes Constructeurs M ethodes de classe et dinstance H eritage Classes abstraites et interfaces Modicateurs dacc` es Packages

Sp ecication informelle (1` ere partie)

On d esire ecrire une biblioth` eque de manipulation de recettes de cuisine... Une recette est d ecrite par trois informations: un num ero, un titre et une note dappr eciation le num ero et le titre sont x es une fois pour toute ` a la cr eation de la recette; le titre est une cha ne de caract` ere en majuscule; les num eros sont donn es dans lordre croissant de cr eation des recettes. la note est un entier entre 0 et 20. Dans un premier temps, on veut pouvoir: obtenir la description dune recette sous forme de chaine de caract` ere modier la note dune recette

La classe recette (1` ere version)

class Recette { static int compteur; String n; String nom; int note; Recette(String nom){ this.n=compteur; compteur++; this.nom = nom.toUpperCase(); } Recette(String nom, int note){ this(nom); changeNote(note); } void changeNote(int note){ if (note>=0 && note<=20) this.note=note; } String description(){ return "Recette:" + this.nom + "; Note:" +this.note; }

La classe recette (1` ere version)

class Recette { static int compteur; String n; String nom; int note; Recette(String nom){ this.n=compteur; compteur++; this.nom = nom.toUpperCase(); } Recette(String nom, int note){ this(nom); changeNote(note); } void changeNote(int note){ if (note>=0 && note<=20) this.note=note; } String description(){ return "Recette:" + this.nom + "; Note:" +this.note; } le compteur qui sert ` a num eroter les recettes: variable de classe

La classe recette (1` ere version)

class Recette { static int compteur; String n; String nom; int note; Recette(String nom){ this.n=compteur; compteur++; this.nom = nom.toUpperCase(); } Recette(String nom, int note){ this(nom); changeNote(note); } void changeNote(int note){ if (note>=0 && note<=20) this.note=note; } String description(){ return "Recette:" + this.nom + "; Note:" +this.note; } le compteur qui sert ` a num eroter les recettes: variable de classe le numero dune recette: variable dinstance

La classe recette (1` ere version)

class Recette { static int compteur; String n; String nom; int note; Recette(String nom){ this.n=compteur; compteur++; this.nom = nom.toUpperCase(); } Recette(String nom, int note){ this(nom); changeNote(note); } void changeNote(int note){ if (note>=0 && note<=20) this.note=note; } String description(){ return "Recette:" + this.nom + "; Note:" +this.note; } le compteur qui sert ` a num eroter les recettes: variable de classe le numero dune recette: variable dinstance

les constructeurs

La classe recette (1` ere version)

class Recette { static int compteur; String n; String nom; int note; le compteur qui sert ` a num eroter les recettes: variable de classe le numero dune recette: variable dinstance

Recette(String nom){ this.n=compteur; compteur++; this.nom = nom.toUpperCase(); les constructeurs } Recette(String nom, int note){ this(nom); changeNote(note); } utilisation habituelle de this() pour eviter de dupliquer le code void changeNote(int note){ if (note>=0 && note<=20) this.note=note; des m ethodes dinstance } String description(){ return "Recette:" + this.nom + "; Note:" +this.note; }

Sp ecication informelle (2` eme partie)

On d ecide dintroduire un nouveau type de recettes: Une recette exotique : est une recette avec une caract eristique suppl ementaire, le nom du pays dorigine. La description des recettes exotiques doit comporter le pays. Plut ot que dintroduire le traitement de ce cas particulier dans la classe Recette, ce qui la rendrait inutilement compliqu ee pour les recettes normales, on introduit une nouvelle classe Exotique qui en h erite. Recette Exotique

Lh eritage: un exemple
Le mot clef extends permet de faire h eriter une classe dune classe d ej` a existente: class Exotique extends Recette{ String pays; }

Recette Exotique

Les objets de la classe Exotique h eritent des variables et m ethodes de la classe Recette (les champs nom, note, la m ethode changeNote,...) et peuvent poss eder des propri et es suppl ementaires (variable dinstance pays). Une classe ne peut h eriter directement que dune autre classe: on parle dh eritage simple (et non multiple).

Lh eritage: un exemple
Le mot clef extends permet de faire h eriter une classe dune classe d ej` a existente: class Exotique extends Recette{ String pays; } Objets Recette Exotique

Les objets de la classe Exotique h eritent des variables et m ethodes de la classe Recette (les champs nom, note, la m ethode changeNote,...) et peuvent poss eder des propri et es suppl ementaires (variable dinstance pays). Une classe ne peut h eriter directement que dune autre classe: on parle dh eritage simple (et non multiple). Lorganisation en sous-classe forme un arbre, de racine la classe Objet. Si une classe na pas de classe m` ere d enie par extend, elle h erite automatiquement de la classe Objet. La classe Objet contient des m ethodes toString et equals qui sont donc h erit ees par toutes les classes.

Instanciation dun objet dune sous-classe

La cr eation dun objet par lappel: Exotique monTagine = new Exotique ("Tagine", "Maroc"); appelle un constructeur de la classe Exotique. Soit le constructeur Exotique est red eni et contient un appel explicite au constructeur de la classe m` ere: class Exotique extends Recette{ String pays; Exotique(String nom, String pays){ super(nom); this.pays = pays.toUpperCase(); } } Si super nest pas appel e explicitement, le compilateur introduit automatiquement un appel super() au constructeur par d efaut de la classe m` ere, qui doit alors avoir et e d eni explicitement. Dans tous les cas un constructeur de la classe m` ere est appel e.

H eritage des m ethodes, red enition

La classe lle peut utiliser les m ethodes h erit ees de sa m` ere: monTagine.description() renvoit : "Recette:Tagine; Note:15" Mais on peut red enir la m ethode description: class Exotique extends Recette{ ... String description(){ return super.description() + "Origine:" + this.pays; } on utilise la m ethode h erit ee pour d enir la nouvelle }

H eritage, transtypage entre classes et sous-classes

On peut r ef erencer un objet de sous-classe dans une variable de la classe m` ere, mais pas le contraire: Recette uneRecette = new Recette("Blanquette"); Exotique uneExotique = new Exotique("Couscous", "Japon"); Recette uneAutre = uneExotique; // ok Exotique uneDerniere = uneRecette; // erreur compil en eet, sinon on pourrait compiler uneDerniere.pays, alors que lobjet r ef erenc e na pas de champs pays.

H eritage, transtypage entre classes et sous-classes

On peut r ef erencer un objet de sous-classe dans une variable de la classe m` ere, mais pas le contraire: Recette uneRecette = new Recette("Blanquette"); Exotique uneExotique = new Exotique("Couscous", "Japon"); Recette uneAutre = uneExotique; // ok Exotique uneDerniere = uneRecette; // erreur compil en eet, sinon on pourrait compiler uneDerniere.pays, alors que lobjet r ef erenc e na pas de champs pays. La m ethode appliqu ee ` a un objet d epend du type de lobjet et pas du type de la variable par laquelle on y acc` ede: String s = unAutre.description();

H eritage, transtypage entre classes et sous-classes

On peut r ef erencer un objet de sous-classe dans une variable de la classe m` ere, mais pas le contraire: Recette uneRecette = new Recette("Blanquette"); Exotique uneExotique = new Exotique("Couscous", "Japon"); Recette uneAutre = uneExotique; // ok Exotique uneDerniere = uneRecette; // erreur compil en eet, sinon on pourrait compiler uneDerniere.pays, alors que lobjet r ef erenc e na pas de champs pays. La m ethode appliqu ee ` a un objet d epend du type de lobjet et pas du type de la variable par laquelle on y acc` ede: la variable unAutre est de type Recette String s = unAutre.description();

H eritage, transtypage entre classes et sous-classes

On peut r ef erencer un objet de sous-classe dans une variable de la classe m` ere, mais pas le contraire: Recette uneRecette = new Recette("Blanquette"); Exotique uneExotique = new Exotique("Couscous", "Japon"); Recette uneAutre = uneExotique; // ok Exotique uneDerniere = uneRecette; // erreur compil en eet, sinon on pourrait compiler uneDerniere.pays, alors que lobjet r ef erenc e na pas de champs pays. La m ethode appliqu ee ` a un objet d epend du type de lobjet et pas du type de la variable par laquelle on y acc` ede: la variable unAutre est de type Recette String s = unAutre.description(); mais elle pointe sur un objet de la classe Exotique.

H eritage, transtypage entre classes et sous-classes

On peut r ef erencer un objet de sous-classe dans une variable de la classe m` ere, mais pas le contraire: Recette uneRecette = new Recette("Blanquette"); Exotique uneExotique = new Exotique("Couscous", "Japon"); Recette uneAutre = uneExotique; // ok Exotique uneDerniere = uneRecette; // erreur compil en eet, sinon on pourrait compiler uneDerniere.pays, alors que lobjet r ef erenc e na pas de champs pays. La m ethode appliqu ee ` a un objet d epend du type de lobjet et pas du type de la variable par laquelle on y acc` ede: la variable unAutre est de type Recette String s = unAutre.description(); mais elle pointe sur un objet de la classe Exotique. Cest donc la m ethode de la classe Exotique qui est utilis ee

H eritage, transtypage entre classes et sous-classes

On peut r ef erencer un objet de sous-classe dans une variable de la classe m` ere, mais pas le contraire: Recette uneRecette = new Recette("Blanquette"); Exotique uneExotique = new Exotique("Couscous", "Japon"); Recette uneAutre = uneExotique; // ok Exotique uneDerniere = uneRecette; // erreur compil en eet, sinon on pourrait compiler uneDerniere.pays, alors que lobjet r ef erenc e na pas de champs pays. Si on manipule un tableau de recettes dont certaines sont exotiques et dautres pas, on peut avoir besoin de tester le type de la recette: static listerOrigine(Recette [] tableau){ for (i=0; i<tableau.length; i++) if (tableau[i] instanceof Exotique) System.out.println(tableau[i].pays); }

La classe recette (2` eme version)

class Recette { static int compteur; String n; String nom; int note; Recette(String nom){ this.n=compteur; compteur++; this.nom = nom.toUpperCase(); } Recette(String nom, int note){ this(nom); changeNote(note); } class Exotique extends Recette{ String pays; Exotique(String nom, String pays){ super(nom); this.pays = pays.toUpperCase(); } String description(){ return super.description() + this.pays; } }

void changeNote(int note){ if (note>=0 && note<=20) this.note=note; } String description(){ return "Recette:" + this.nom + "; Note:" +this.note; }

En particulier on remarque que les recettes Exotique sont des recettes ` a part enti` ere: elles seront num erot ees avec les recettes normales, via la variable compteur.

Variables de classe et dinstance; constantes Constructeurs M ethodes de classe et dinstance H eritage Classes abstraites et interfaces Modicateurs dacc` es Packages

Sp ecication informelle (3` ere partie)

On voudrait maintenant faire plus g en eralement des ches cuisines, bricolages, chansons... Les ches cuisines sont exactement des recettes Pour chaque che, on doit avoir une date de cr eation On veut imposer que toutes les ches des sous-classes poss` edent leur propre m ethode description. Fiche Bricolage Recette Exotique Chanson

Classes abstraites
Les classes abstraites donnent la possibilit e de d eclarer certaines m ethodes sans les impl ementer (m ethodes abstraites). abstract class Fiche{ Date dateCreation; Fiche(){ this.dateCreation = Date.getDate(); } abstract String description (); String afficheCreation(){ return dateCreation; } } Les classes abstraites ne sont pas instanciables: pas dobjets abstraits ! Une classe abstraite peut contenir m ethodes non abstraites et variables. Une sous-classe non-abstraite dune classe abstraite doit d enir explicitement toutes les m ethodes abstraites dont elle a h erit e.

La classe recette (3` eme version)

class Recette extends Fiche{ static int compteur; String n; String nom; int note; Recette(String nom){ this.n=compteur; compteur++; this.nom = nom.toUpperCase(); } Recette(String nom, int note){ this(nom); changeNote(note); } void changeNote(int note){ if (note>=0 && note<=20) this.note=note; } String description(){ return "Recette:" + this.nom + "; Note:" +this.note; } abstract class Fiche{ Date dateCreation; Fiche(){ this.dateCreation = Date.getDate(); } abstract String description (); String afficheCreation(){ return dateCreation; } } class Exotique extends Recette{ String pays; Exotique(String nom, String pays){ super(nom); this.pays = pays.toUpperCase(); } String description(){ return super.description() + this.pays; } }

En particulier on remarque que les recettes impl ementent bien la m ethode description comme demand e.

Sp ecication informelle (4` ere partie)

On veut maintenant unier le traitement de linformation dorigine des recettes exotiques, chansons du monde,... Une che est Geographique si elle poss` ede une m ethode origine qui donne son pays dorigine.

Fiche Bricolage Recette Exotique

Geographique Chanson

On ne peut pas utiliser directement lh eritage (extend) car on a interdit lh eritage multiple.

Interfaces
Une interface est une classe enti` erement abstraite: les variables sont implicitement static et final (uniquement des constantes) et les m ethodes implicitement d eclar ees abstraites. interface Geographique{ String Origine(); } On ajoute ` a la d enition de la classe Exotique: class Exotic extends Recette implements Geographique{ ... Les constantes et m ethodes sont h erit ees par toute classe qui impl emente linterface. Pour etre instanciable (non abstraite), une telle classe doit d enir toutes les m ethodes de linterface. Une classe peut impl ementer plusieurs interfaces, alors quelle ne peut h eriter que dune classe. Un interface peut elle-m eme h eriter de plusieurs interfaces.

La classe recette (4` eme version)

abstract class Fiche{ Date dateCreation; Fiche(){ this.dateCreation = Date.getDate(); } abstract String description (); String afficheCreation(){ return dateCreation; } } class Recette extends Fiche{ static int compteur; String n; String nom; int note; Recette(String nom){ this.n=compteur; compteur++; this.nom = nom.toUpperCase(); } Recette(String nom, int note){ this(nom); changeNote(note); } interface Geographique{ String Origine(); }

class Exotique extends Recette implements Geographique{ String pays; Exotique(String nom, String pays){ super(nom); this.pays = pays.toUpperCase(); } String description(){ return super.description() + this.pays; } String Origine(){ return this.pays; } }

void changeNote(int note){ if (note>=0 && note<=20) this.note=note; } String description(){ return "Recette:" + this.nom + "; Note:" +this.note; }

Variables de classe et dinstance; constantes Constructeurs M ethodes de classe et dinstance H eritage Classes abstraites et interfaces Modicateurs dacc` es Packages

Sp ecication informelle (5` ere partie)

On veut limiter le risque dutilisation erron ee (ou malicieuse) de notre classe recette. En particulier: On a sp eci e que la note dune recette doit etre comprise entre 0 et 20, on a mis un test pour cela dans la m ethode changeNote. Mais il faudrait forcer les m ethodes qui utilisent la classe recette ` a utiliser cette m ethode pour changer la note. On a sp eci e que le nom dune recette ne doit jamais changer. On va utiliser pour cela des modicateurs dacc` es.

Modicateurs dacc` es
Les modicateurs dacc` es permettent de pr eciser qui peut acc eder ` a chaque variable, m ethode ou classe: private: la variable ou m ethode nest accessible que dans sa classe. public: la variable ou m ethode est accessible sans restriction. On prot` ege les variables en les d eclarant private:
class Recette extends Fiche{ private static int compteur; private String n; private String nom; private int note; ...

Puis on donne un acc` es contr ol e ` a ces variables par linterm ediaire de m ethodes accesseurs: public void changeNote(int note){ accesseur en modication if (note>=0 && note<=20) this.note=note; garanti que 0 note 20. }
public int renvoitNote(){ return note; }

accesseur en lecture

Modicateurs dacc` es et packages

On peut regrouper plusieurs classes pour former un package : par exemple toutes les classes pour manipuler nos ches. (On verra bient ot comment) Il y a alors quatre types de modicateurs dacc` es: private: acc` es limit e aux m ethodes de la classe sans modicateur: acc` es limit es aux m ethodes du package protected: acc` es limit e aux m ethodes du packages et aux classes qui h eritent de la classe public: pas de restriction dacc` es. Les variables priv ees (private) sont h erit ees par les sous-classes mais restent inaccessibles, sauf sil existe un accesseur moins strict. Par exemple si dans la classe Recette on a rendu nom priv ee:
class Recette extends Fiche{ ... private String nom; ...

le constructeur de la classe Exotique ne peut acc eder ` a cette variable que par linterm ediaire des constructeurs publique de la classe Recette, ` a laide dappels de la forme super(...)

Variables de classe et dinstance; constantes Constructeurs M ethodes de classe et dinstance H eritage Classes abstraites et interfaces Modicateurs dacc` es Packages

Packages
Pour permettre la r eutilisation de code, on organise les classes en packages. Cest le cas notamment des biblioth` eques standards (le JDK): java.lang, automatiquement charg ee, contient les classes de bases (Object, System, String java.io contient di erentes classes dentr ee-sortie. java.util contient di erentes classes utiles (Date,...) java.applet pour les applets. java.awt et javax pour les interfaces graphiques Pour pouvoir utiliser une de ces classes il faut limporter (ou importer tout le package), en mettant en t ete de chier une directive de la forme: import java.util.Date ou import java.util.* Pour les packages personnels il faut indiquer leur chemin dans la variable denvironnement CLASSPATH avec: setenv CLASSPATH ~/mespackages puis les importer avec une directive: import monPackage.maClasse

Packages personnels
Sp ecier le package dappartenance en t ete de chaque chier: package nomPackage Placer les chiers .class dans un r epertoire qui porte le nom du package: soit ` a la main soit directement via le compilateur: javac -d <nom repertoire> <fichiers.java> Chaque chier du package peut contenir une classe publique, indiqu ee par un modicateur public et portant le m eme nom que le chier. Les classes qui ne sont pas publiques (sans modicateur) ne sont accessibles que depuis les classes du package. // fichier Recette.java package mesFiches; public class Recette{ ... Par d efaut, tous les chiers du r epertoire courant qui nont pas de directive package sont consid er es comme formant un package.

Packages personnels: un exemple

Supposons quon compile les chiers
// fichier Recette.java package mesFiches; public class Recette{ ... // fichier Exotique.java package mesFiches; public class Exotique extends Recette{ ...

et quon place les chiers Recette.class et Exotique.class dans un sous-r epertoire mesFiches du r epertoire mesPackages du CLASSPATH. On peut alors utiliser le package dans un autre chier (m eme situ e ailleurs): // fichier Test.java import mesFiches.* public class Test{ public static void main ( String [] args){ Exotique monTagine = new Exotique("Tagine", "Maroc"); ... }

Variables de classe et dinstance; constantes Constructeurs M ethodes de classe et dinstance H eritage Classes abstraites et interfaces Modicateurs dacc` es Packages Prochain cours: Applets

Cours intensif Java

3` eme cours: Applets
Janvier 2011

Enrica Duchi

LIAFA, Paris 7

Enrica.Duchi@liafa.jussieu.fr

Introduction Composants graphiques avec AWT Applet et cycle de vie Applet dans HTML Utilitaire jar et appletviewer Des composants pour interagir enements et capteurs Ev` Applet avec ev` enements

CoursJava3.pdf

Des composants pour interagir

Voici quelques autres sous-classes de la classe component, qui peuvent etre ajout es comme pr ec edemment ` a tout objet de type container ` a laide la m ethode add: Button. Lajout dun objet de cette classe produit un bouton cliquable. List. Pour faire des listes de choix multiple. Menu. Pour faire des menus (!) etc... On se contentera dillustrer le cas des boutons, le principe est le m eme pour les autres mais le code plus long ` a ecrire.

Des composants pour interagir: un bouton

Le fragment de code suivant cr e e une fen etre (objet de la classe Frame, sous classe de Contener donc apte ` a accueillir des composants. Puis on place un bouton dans cette fen etre. Frame f = new Frame ("une fenetre"); Button b = new Button ("Cliquez ici"); f.add(b); f.pack(b); f.setVisible(true);

Des composants pour interagir: un bouton

Le fragment de code suivant cr e e une fen etre (objet de la classe Frame, sous classe de Contener donc apte ` a accueillir des composants. Puis on place un bouton dans cette fen etre. Frame f = new Frame ("une fenetre"); Button b = new Button ("Cliquez ici"); f.add(b); ajout du bouton dans la fen etre f.pack(b); f.setVisible(true);

Des composants pour interagir: un bouton

Le fragment de code suivant cr e e une fen etre (objet de la classe Frame, sous classe de Contener donc apte ` a accueillir des composants. Puis on place un bouton dans cette fen etre. Frame f = new Frame ("une fenetre"); Button b = new Button ("Cliquez ici"); f.add(b); ajout du bouton dans la fen etre f.pack(b); ajustement de la taille de la fen etre f.setVisible(true);

Des composants pour interagir: un bouton

Le fragment de code suivant cr e e une fen etre (objet de la classe Frame, sous classe de Contener donc apte ` a accueillir des composants. Puis on place un bouton dans cette fen etre. Frame f = new Frame ("une fenetre"); Button b = new Button ("Cliquez ici"); f.add(b); ajout du bouton dans la fen etre f.pack(b); ajustement de la taille de la fen etre f.setVisible(true); la fen etre visible avec un bouton cliquable

Des composants pour interagir: un bouton

Le fragment de code suivant cr e e une fen etre (objet de la classe Frame, sous classe de Contener donc apte ` a accueillir des composants. Puis on place un bouton dans cette fen etre. Frame f = new Frame ("une fenetre"); Button b = new Button ("Cliquez ici"); f.add(b); ajout du bouton dans la fen etre f.pack(b); ajustement de la taille de la fen etre f.setVisible(true); la fen etre visible avec un bouton cliquable Lorsquon clique sur ce bouton, il r eagit graphiquement. Cependant il ny pas encore daction associ ee dans le code.

Des composants pour interagir: un bouton

Le fragment de code suivant cr e e une fen etre (objet de la classe Frame, sous classe de Contener donc apte ` a accueillir des composants. Puis on place un bouton dans cette fen etre. Frame f = new Frame ("une fenetre"); Button b = new Button ("Cliquez ici"); f.add(b); ajout du bouton dans la fen etre f.pack(b); ajustement de la taille de la fen etre f.setVisible(true); la fen etre visible avec un bouton cliquable Lorsquon clique sur ce bouton, il r eagit graphiquement. Cependant il ny pas encore daction associ ee dans le code. Une premi` ere etape est dassocier un nom de commande au bouton: b.setActionCommand("Terminer") Ce nom de commande sera utilis e dans la d enition de l ev` enement associ e au d eclanchement du bouton.

Introduction Composants graphiques avec AWT Applet et cycle de vie Applet dans HTML Utilitaire jar et appletviewer Des composants pour interagir enements et capteurs Ev` Applet avec ev` enements

CoursJava3.pdf

Le mod` ele event/listener dAWT et SWING

Nous allons maintenant voir associer des actions aux boutons et autres composants quon voudrait interactifs. Nous pr esentons pour cela le mod` ele ev` enement / capteur, introduit dans la seconde version de la biblioth` eque AWT.
Beaucoup dapplications utilisent maintenant la biblioth` eque SWING, mais le principe est le m eme ` a quelques d etails pr` es.

Lid ee est de d ecoupler en 2 parties la gestion des interactions: Le syst` eme graphique de JAVA soccupe danalyser les ev` enements physique (d eplacement de la souris, clic, entr ee au clavier...) et de les transformer en ev` enements logiques (appuis sur un bouton, choix dans un menu d eroulant, redimensionnement dune fen etre,...) associ es aux composants de linterface de lapplet. Le programmeur d eclare des objets comme capteurs pour les ev` enements logiques qui lint eressent et fournit ` a ces capteurs des m ethodes d ecrivant les actions ` a eectuer.

Les ev` enements et capteurs

` chaque A ev` enement d etect e par le syst` eme est associ e un objet de lune des classes d ev` enements de java.awt.event.* Les objets de la classe ActionEvent sont associ ees aux actions el ementaires: d eclanchement dun bouton; choix dans une checklist,... Aux di erents types d ev` enements possibles sont associ es dautres classes: MouseEvent, TextEvent, WindowEvent,... Pour quun ev` enement puisse produire une action, il faut quil soit d etect e par un capteur du bon type: Pour pouvoir d etecter une ActionEvent, le capteur doit appartenir ` a une classe qui impl emente linterface ActionListener de java.awt.event. Pour d etecter un MouseEvent il faut un capteur dune classe qui impl emente MouseListener, etc.

Les capteurs de la classe ActionListener (pour les boutons)

Nimporte quel objet peut etre un capteur pour les ev` enements ActionEvent du moment que sa classe impl emente linterface ActionListener: La condition pour implementer cette interface est davoir une m ethode public void actionPerformed(ActionEvent) qui d enit laction ` a eectuer quand le bouton est utilis e. Exemple: on d enit une classe de capteur par class MonCapteur implements ActionListener{ public void actionPerformed(ActionEvent a){ System.out.println("On sar^ ete"); System.out.exit(1); } } Si un objet capteur de ce type est activ e, il ecrit le message On sar^ ete et ferme lapplication.

Les capteurs
Pour rendre un bouton actif il faut lui attacher un capteur ` a laide de la m ethode public void addActionListener(ActionListener) de la classe Button. Exemple: on compl` ete la mise en place de notre bouton pr ec edent: Frame f = new Frame ("une fenetre"); Button b = new Button ("Cliquez ici pour fermer"); b.addActionListener(new MonCapteur()); f.add(b); f.pack(b); f.setVisible(true);

Les ev` enements et la classe java.awt.event.ActionEvent

Les objets ActionEvent poss` edent des m ethodes permettant den savoir plus sur les ev` enements auxquels ils sont associ es: la m ethode Object getSource() renvoit directement un pointeur sur lobjet (ie le bouton) ` a lorigine de l ev` enement. la m ethode String getActionCommand() renvoit le message de commande associ e au bouton au moment o` u il a et e utilis e: ce message de commande doit avoir et e d eni par un appel monBouton.setActionCommand("maCommande");

Lexemple en entier
class MonCapteur implements ActionListener{ public void actionPerformed(ActionEvent evt){ System.out.println("Clic sur le bouton de " + evt.getActionCommand()); } } class Exemple{ Button b1,b2; Frame f; void creationBoutons(){ b1 = new Button ("Bouton de gauche"); b1.setActionCommand("gauche"); b1.addActionListener(new MonCapteur()); b2 = new Button ("Bouton de droite"); b2.setActionCommand("droite"); b2.addActionListener(new MonCapteur()); } public void main(String [] args){ fenetre = new Frame ("une fenetre"); creationBoutons(); fenetre.add(b1); fenetre.add(b2) fenetre.pack(); fenetre.setVisible(true); } }

Introduction Composants graphiques avec AWT Applet et cycle de vie Applet dans HTML Utilitaire jar et appletviewer Des composants pour interagir enements et capteurs Ev` Applet avec ev` enements

CoursJava3.pdf

Applet avec ev` enements

Il faut maintenant int egrer la gestion des ev` enements au sein du cycle de vie de lapplet: init(), start(), stop(), destroy(), paint() Dans init() on met ce qui doit etre fait au d emarrage de lapplet: cest donc la quon met la denition de la mise en page, la cr eation des boutons et des capteurs. Dans start() et stop() on active/d esactive les eventuelles animations, pour eviter de travailler quand lapplet nest pas visible Dans paint() on met ` a jour lachage. Dans les m ethodes actionPerformed() des capteurs, on eectue les actions associ ees aux boutons.

// fichier AppletBouton.java import java.awt.*; import java.applet.*; import java.awt.event.*;

Un exemple

public class AppletBouton extends Applet implements ActionListener { Button okButton; Button wrongButton; boolean couleur; public void init() { setLayout(new FlowLayout()); okButton = new Button("Change couleur!"); wrongButton = new Button("Ne pas cliquer!"); add(okButton); add(wrongButton); okButton.addActionListener(this); wrongButton.addActionListener(this); } public void paint(Graphics g) { if (couleur) g.setColor(Color.red); else g.setColor(Color.blue); } public void actionPerformed(ActionEvent evt) { if (evt.getSource() == okButton){ couleur = (couleur == false); repaint(); } else if (evt.getSource() == wrongButton) { wrongButton.setLabel("Arrgghhh!"); repaint(); } } }

Ici lapplet fait elle-m eme oce de capteur