Alexandre Allauzen (Université Paris-Sud / LIMSI-CNRS) Programmation Objet en JAVA : Remise à niveau 2ème partie Structures de données et méthodes Alexandre Allauzen (Université Paris-Sud / LIMSI-CNRS) allauzen@limsi.fr

Le cas du cercle Ecrire une classe représentant un cercle, spécifions : L'état est défini par : un centre : un point un rayon : un float une couleur : une color Le comportement attendu : se déplacer ? oui changer de rayon ? oui changer de couleur ? non mais couleur = f(rayon). connaître sa position, rayon, couleur, surface ? oui A partir des spécifications, on peut définir : les attributs, leurs types Le choix du programmeur pas de l'utilisateur Définit les signatures des méthodes : public (l'interface) en accord avec l'utilisateur. Pour le reste ....

L'utilisateur dit (en java) public class UtilisationDuCercle { public static void main (String[] args) { ... Point centre = new Point(5,2); /* construction */ Cercle c1 = new Cercle(centre, 5); /* connaitre sa couleur pour le déplacer */ if (c1.getCouleur().equals(Color.BLACK)) c1.setPosition(new Point(4,8)); /* Modifier son rayon, et que la couleur soit modifier */ c1.setRayon(2); } Etude de cas (use case) Spécification des signatures Spécification du mode de communication d'un objet de la classe, de l'interface. Spécification de la « télé-commande » Accord entre le concepteur et l'utilisateur. Le concepteur doit prévoir une interface suffisante pour créer une classe utile. Prévoir des méthodes internes à l'objet (privées).

La classe Cercle -1 import java.awt.Color; import java.awt.Point; public class Cercle { /* Les attributs */ private Point centre; private float rayon; private Color color; /* Le constructeur */ public Cercle(Point c, int r) { rayon = r; /*Attention a centre = c; */ centre = new Point(c); updateColor(); }

La classe Cercle - 2 /* Création des accès selon les besoins : * getter & setter (lecture/écriture). */ public Color getColor() { return color; } public Point getCentre() { return centre; public void setCentre(Point centre) { this.centre = centre; public float getRayon() { return rayon;

La classe Cercle - 3 /* La modification du rayon peut entrainer la modification de la * couleur */ public void setRayon(float rayon) { this.rayon = rayon; updateColor(); } /* Création d'une méthode privée updateColor */ private void updateColor(){ color = Color.BLACK; if (rayon>10) color = Color.RED; /* Gestion de l'affichage texte */ public String toString(){ return "Cercle de centre " + centre.toString() + " de couleur " + color.toString() + " et de rayon " + rayon;

Identificateurs Sert à nommer les classes, les variables, les méthodes... de longueur quelconque commence par une lettre Unicode (ASCII recommandés) peut ensuite contenir des lettres ou des chiffres ou le « _ » hors mot réservé du langage (mot clé) Ne faites pas original mais efficace, lisible et complet

Convention d'identification Les noms de classes commencent par une majuscule (les seuls avec les constantes) : Visage, Object, Cercle Les mots contenus dans un identificateur commencent par une majuscule : MaClasse, maMethode, maVar ageDuCapitaine mieux que ageducapitaine et que age_du_capitaine Les constantes sont toutes en majuscules et les mots sont séparés par le « _ » : MA_CONSTANTE

Types de données 2 grands types de données : types primitifs les variables contiennent des valeurs stockés sur la pile indépendants de l'architecture objets (instances de classes) les variables contiennent des références stockés sur le tas, référence sur la pile. Les types primitifs existent en version objet ou « class » (wrapper), 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. Pour les objets c'est nécessairement fait par l'appel du constructeur. 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. L'objet est construit par l'appel du constructeur et de : new. (Instanciation) 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

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

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 une majuscule à chaque nouveau début de mot

Constante, final et static public class Etudiant{ final String nom;// doit être initialisée // par le constructeur (...) } final static String nom;// faux final String NOM = « Toto »;

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} // Chercher un élément nul dans un tableau int i = 0; while ((tab[i] != 0)&& (i<tab.length)) 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 > 1 2 3 4 6 7 8 9 10

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 \u0000 - \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ères - 1 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ères - 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ères - 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 ); Formatage 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édural » reste d'actualité : une bonne méthode (ou fonction) est courte, sinon, elle est mauvaise et doit être repensée et/ou décomposé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

Passage par valeur -1 var @ val aObjet #0 #a bObjet #1 #b x #2 3 y #3 4 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 aObjet = new Integer(3); Integer bObjet= new Integer(4); int x = 3; int y = 4; echange(x,y); System.out.println("Après :" + x + " " + y); echange(aObjet,bObjet); System.out.println("Après :" + a + " " + b); Appel de la méthode : var @ val a #55 3 b #57 4

Passage par valeur -2 var @ val aObjet #0 #a bObjet #1 #b x #2 3 y #3 4 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 aObjet = new Integer(3); Integer bObjet= new Integer(4); int x = 3; int y = 4; echange(x,y); System.out.println("Après :" + x + " " + y); echange(aObjet,bObjet); System.out.println("Après :" + a + " " + b); Appel de la méthode : var @ val a #78 #a b #79 #b

Mais pourquoi ? > java Test Avant 2 Apres 2 Apres 0 var @ val t #45 public class Test{ public static void annule(int a ){ a = 0; } public static void annule(int tab[] ){ tab[0]=0; public static void main(String[] args) { int[] tab = { 2, 5, -1, 4, 3 }; System.out.println("Avant "+ tab[0]); annule(tab[0]); // Test.annule(tab[0]) System.out.println("Apres "+ tab[0]); annule(tab); }; > java Test Avant 2 Apres 2 Apres 0 var @ val t #45 #x 2 #x+1 5 #x+2 -1 ...

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 : pas de valeur de retour, mais des paramètres. Toute classe proprement faite possède ses constructeurs (au moins 1) qui garantissent la création et l'initialisation propre des objets. 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;

Résumé En POO, tout est objet. Java = environnement de programmation Objet . La syntaxe est proche du C/C++. Un programme objet = création d'objets et leurs interactions. Un objet a un type défini par la classe à laquelle il appartient. Un objet possède des attributs et des méthodes. Principe d'encapsulation : données privées, l'accès et la manipulation d'un objet se fait via son interface. Les classes doivent être réutilisables (doc, interface générale). 2 types de variable : type primitif ou objet « Attention au passage par valeur des références, aux tableaux, ... » Bien définir ce que vous voulez, bien le chercher, bien l'utiliser.