Cours 2

I. Recopies I.1 Type primitif int vE1=12;  int vE2;  vE2=vE1;  vE1=vE1*2;  S.o.p(vE2);   ? (voir dessin) §
I.2 Type objet Cercle vC1=new Cercle(0,0,12);  Cercle vC2;  vC2=vC1;  vC1.doubleTaille();  S.o.p(vC2.getDiametre());   ? (voir dessins, clonage) §
- - - - - - - - - - - - - - - - - - - - - - - - travail personnel :
I.3 Passage de paramètre ("par recopie") I.3.1 type primitif ==> recopie de valeur ==> aucun danger void fois2( int pN ) { pN = pN*2; S.o.p(pN); pN=0; }
ailleurs : int vI=12; fois2(vI); S.o.p(vI);
I.3.2 type objet ==> recopie de référence ==> aucun danger pour la référence mais pour l'objet ! void fois2( Cercle pC ) { pC.doubleTaille(); S.o.p(pC.getDiametre()); pC=null;}
ailleurs : Cercle vC=new Cercle(0,0,12); fois2(vC); S.o.p(vC.getDiametre());
I.3.3 pour éviter toute ambiguïté : final ==> ni pN = ... ; ni pC = ... ;
- - - - - - - - - - - - - - - - - - - - - - - -

I.4 Suppression d'objet I.4.1 vC2 = null; ne supprime pas. S'il n'y a pas d'autres références, marque pour suppression.
I.4.2 Garbage Collector = ramasse-miettes, compteur de références, tâche de fond
- - - - - - - - - - - - - - - - - - - - - - - - non traité :
I.5 Composition I.5.1 Exemple du véhicule : x, y, chassis, roueAv, roueAr (voir dessin) §
I.5.2 Relation entre objets ==> diagramme d'objets [**] (voir dessin) §
I.5.3 ==> diagramme de classes [**] (voir dessin) §
I.5.4 Recopie, clonage simple (voir dessins) §
[**] Télécharger le viewer PowerPoint si nécessaire.
- - - - - - - - - - - - - - - - - - - - - - - -
II. Méthodes particulières (ordre conseillé :) II.1 Accesseurs (ou fonctions d'accès ou getters) : public typeAttribut getNomAttribut()
  { return this.aNomAttribut; }

protection ==> ne peut être modifié
II.1bis Fonctions d'état (accesseurs particuliers, booléens) : public boolean estAdjectif()
  { ... return valeurBooléenne; }
II.2 Modificateurs (ou procédures de modification ou setters) : public void setNomAttribut( typeAttribut pNomParamètre )
  { this.aNomAttribut= pNomParamètre; }

protection ==> tests de cohérence, maintenabilité
II.3 Exemple complet
III. Expressions III.1 Expression arithmétique (entière)
1.1) valeur littérale : -123 ou +45 ou 67
1.2) variable : (locale, attribut, paramètre)
1.3) constante : (locale, attribut, paramètre) déclarée comme suit :
final int CONSTANTE_LOCALE = 10;
private final int ATTRIBUT_CONSTANT = 10;
final int pNomParametre
==> reste constant pendant la méthode
1.4) appel de fonction : objet.getDiametre()
1.5) OP1(expression_arithmétique) : - ou +
1.6) expression_arithmétique OP2 expression_arithmétique : + - * / %
[division entière : / → quotient, % → reste]
III.2 Expression booléenne
2.1) valeur littérale : true ou false
2.2) variable : (locale, attribut, paramètre)
2.3) constante : (locale, attribut, paramètre) déclarée comme suit :
• locale : inutile
private final boolean ATTRIBUT_CONSTANT = true; : rarement utile
final boolean pNomParametre
==> reste constant pendant la méthode
2.4) appel de fonction : objet.estVisible()
2.5) résultat d'une comparaison avec : < > <= >= == !=
2.6) OP1(expression_booléenne) : ! → NON
2.7) expression_booléenne OP2 expression_booléenne : && → ET ou || → OU
2.8) évaluation paresseuse : s'arrête dès qu'on peut déterminer le résultat (faux avec ET, vrai avec OU) ==> non commutatif (mais même résultat)
2.9) Exemple de gauche à droite :   0 < x < 10
III.3 Expression référence
3.1) valeur littérale : null et this
3.2) variable : vC1 ou pV1 ou aV1
3.3) new NomClasse()
3.4) appel de fonction : objet.getRoueAv()
III.4 Priorité des opérateurs : voir ce tableau
IV. Tests IV.1 SI ALORS : if ( expression booléenne ) { instructions si vraie } parenthèses obligatoires même si simplement (ok), certaines instructions écrites ne sont jamais exécutées. IV.2 SI ALORS SINON : if ( expression booléenne ) { instructions si vraie } else { instructions si fausse } Une (et une seule) des deux branches est exécutée. IV.3 une instruction sans {} ==> danger ! (en cas d'ajout ou d'imbrication)
IV.4 if successifs non indépendants if (a<0) S.o.p("neg");   if (a>0) S.o.p("pos");   if (a==0) S.o.p("nul");
- amélioration 1 : ajouter 2 else  
- amélioration 2 : supprimer le 3ème if
V. Récursivité
V.1 Une définition : découper un problème en une multitude de sous-problèmes similaires plus simples.
Souvent une manière très naturelle de résoudre un problème complexe. Exemple des tours de Hanoï sur wikipedia :
V.2 En java, une méthode peut s'appeler elle-même sans aucune déclaration particulière.
V.3 Élégant mais pas le plus efficace ni en temps ni en mémoire. Répéter des instructions efficacement ==> boucle (voir cours suivant)
- - - - - - - - - - - - - - - - - - - - - - - - travail personnel :
V.4 Exemple de procédure : On suppose savoir faire {AfficherUne *} {AfficherLes N *} := {AfficherUne *} PUIS {AfficherLes N-1 *}
et ainsi de suite jusqu'au cas terminal : N vaut 1.
Dans ce cas, il suffit d'appeler {AfficherUne *} et il est inutile de rappeler {AfficherLes 0 *} !
V.5 Exercice : écrire la fonction factorielle en utilisant la récursivité. Aide : règle de récurrence n! = n × (n-1)! et cas terminal n≤1 → 1 - - - - - - - - - - - - - - - - - - - - - - - -
Lire le poly :
tout jusqu'à la section 2.2, sections 2.3, 3.1, 4, 5.2.0, 6, 7.1, 7.2, 8.1, 8.2.1.1, et annexes 6 & 7


--> Dernière mise à jour :