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