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

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

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

Présentations similaires


Présentation au sujet: "Programmation Objet en JAVA : Remise à niveau 2ème partie Structures de données et méthodes Alexandre Allauzen (Université Paris-Sud / LIMSI-CNRS)"— Transcription de la présentation:

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

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

3 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).

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

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

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

7 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

8 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

9 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

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

11 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 nest pas obligatoirement un if, un for ou un while VarLoc++; marche aussi linitialisation des variables nest pas obligatoire mais préférable

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

13 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

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

15 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

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

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

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

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

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

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

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

23 Flot de contrôle - 2 Boucle tant que faire / répéter tant que while (condition) {bloc} do {bloc} while (condition) // Chercher un élément nul dans un tableau int i = 0; while ((tab[i] != 0)&& (i0)

24 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

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

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

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

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

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

30 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

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

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

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

34 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 0

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

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

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

38 Passage par valeur -1 aObjet#0#a bObjet#1#b x#23 y#34 public static void echange(int a, int b) { int tmp = a ; a = b; b = tmp; } public static void echange(Integer a, Integer b) { Integer tmp = a; a = b; b = tmp; System.out.println("dedans :" + a + " " + b); } public static void main(String[] args) { Integer 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); } a#553 b#574 a#554 b#573 Appel de la méthode :

39 Passage par valeur -2 aObjet#0#a bObjet#1#b x#23 y#34 a#78#a b#79#b a#78#b b#79#a Appel de la méthode : public static void echange(int a, int b) { int tmp = a ; a = b; b = tmp; } public static void echange(Integer a, Integer b) { Integer tmp = a; a = b; b = tmp; System.out.println("dedans :" + a + " " + b); } public static void main(String[] args) { Integer 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); }

40 Mais pourquoi ? 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]); System.out.println("Avant "+ tab[0]); annule(tab); System.out.println("Apres "+ tab[0]); }; > java Test Avant 2 Apres 2 Avant 2 Apres 0 t#45#x 2 #x+15 #x+2...

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

42 Méthode d'objet Par opposition aux méthodes de classe (static) La signature s'écrit de la même manière au sein de la classe, sans le mot clé static : nomDeMethode(liste des params formels) Nécessite l'existence d'un objet pour être invoquée : monObjet.laMethode(liste des params effectifs); Le constructeur est une méthode particulière : 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;

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


Télécharger ppt "Programmation Objet en JAVA : Remise à niveau 2ème partie Structures de données et méthodes Alexandre Allauzen (Université Paris-Sud / LIMSI-CNRS)"

Présentations similaires


Annonces Google