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

Programmation Objet en JAVA : Remise à niveau 2ème partie

Structures de données et méthodes

Alexandre Allauzen (Université Paris-Sud / LIMSI-CNRS)

[email protected]

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 falseA boolean value (true or false)boolean

16-bit Unicode characterA single characterchar

(autres types)

64-bit IEEE 754Double-precision floating pointdouble

32-bit IEEE 754Single-precision floating pointfloat

(nombres réels)

64-bit two's complementLong integerlong

32-bit two's complementIntegerint

16-bit two's complementShort integershort

8-bit two's complementByte-length integerbyte

(entiers)

Taille et FormatDescriptionMot 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 2Int Alloc = petiteFamilleType * 1500;Hiérarchie des types : byte < short < int < long < float < double


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


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

}

public class Etudiant{final static String nom;// faux(...)

}

public class Etudiant{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.Mathpublic 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

• 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 == != & ^ | && ||

? : = += -= *= /= %= &= |= ^=

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érencedouble[] 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}

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}

while (condition)

// 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+=ii--

} while (i>0)


Boucle pour – for :

for (expr1; expr2; expr3)

{bloc}

fonctionnement :

expr1

if (expr2==true){

bloc

expr3

}

float moyenne= 0;// Initialisation d'un tableau d'entierint[] 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


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 !

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;

} }}

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

whilestaticinstanceofdo

volatileshortimportdefault

voidreturnimplementscontinue

trypublicifconst *

transient protectedgoto *class

throwsprivateforchar

throwpackagefloatcatch

thisnewfinallycase

synchronizednativefinalbyte

switchlongextendsbreak

superinterfaceelseboolean

strictfp **intdoubleabstract

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

DescriptionValeur UnicodeCaractère

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înesString motConstruit = "Sous-chaîne";String racine = motConstruit.substring( 5 ,

motConstruit.length() - 5 );char tiret = motConstruit.charAt( 4 );

→ Voir la doc de la classe


• É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 !


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

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

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;

}

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

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 4Après :3 4

Passage par valeur -1

var @ val

aObjet #0 #a

bObjet #1 #b

x #2 3

y #3 4





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

}

var @ val

a #55 3

b #57 4

a #55 4

b #57 3

Appel de la méthode :

Passage par valeur -2

var @ val

aObjet #0 #a

bObjet #1 #b

x #2 3

y #3 4

var @ val

a #78 #a

b #79 #b

a #78 #b

b #79 #a

Appel de la méthode :





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

}

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 TestAvant 2Apres 2Avant 2Apres 0

var @ val

t #45 #x

#x 2

#x+1 5

#x+2 -1

... ...

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





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 4Après :3 4

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 :

<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 incorrectx+=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.

Documents

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