Licence 1 MASS, parcours SEMS et ESD Introduction `a Java et `a l’algorithmique
S´ebastien Verel verel@i3s.unice.fr
http://www.i3s.unice.fr/∼verel
´Equipe ScoBi - Universit´e Nice Sophia Antipolis
22 f´evrier 2013
Travail de la semaine pass´ ee
Installer processing (done.)
Travailler `a partir des objectifs du cours
Travailler les exemples du cours (r´eussir `a extraire l’archive !) Travailler les exercices des TP 01, 02 et 03
Cr´eer des variations d’exemples et d’exercices (A m’envoyer +1)
Explorer les exemples de Processing
S´ebastien Verel S´eparation de codes et m´ethodes
Synth` ese
El`eves de synth`ese du jour ?
Objectifs de la s´ eance 4
1 Connaˆıtre le principe de s´eparation de code
2 Ecrire correctement une m´ethode java
3 Comprendre et calculer le r´esultat d’un algorithme donn´e
4 Modifier un algorithme donn´e
5 Utiliser une partie d’algorithme donn´e
6 Corriger un algorithme donn´e Question principale du jour :
Comment ´ecrire r´eutiliser les algorithmes pour moins se fatiguer ?
S´ebastien Verel S´eparation de codes et m´ethodes
Choses encore myst´ erieuses
Vous avez ´ecrit depuis quelques temps ce genre de programme : float moyenne(int n) {
float a, m int i;
m = 0;
for(i = 0; i < n; i++) {
a = lire("taper un nombre ");
m = m + a;
}
m = m / n;
return m;
}
D’ailleurs m´ ethode ”lire”
import javax.swing.JOptionPane;
/*****************************************
* Lit un nombre entier au clavier
*
* entree :
* - message : message d’invite
*
* sortie :
* - nombre de type int
*****************************************/
int lire(String message) {
String str = JOptionPane.showInputDialog(null, message);
return Integer.parseInt(str) ; }
S´ebastien Verel S´eparation de codes et m´ethodes
Choses encore myst´ erieuses
void deviner(int n) { int rep;
rep = n - 1;
while (rep != n) {
rep = lire("Proposer un nombre entier");
}
println("Win win win !");
}
Choses encore myst´ erieuses
float u100() { float u = 1;
for(int i = 0; i < 101; i++) u = 0.5 * u + 2;
return u;
}
void setup() { println(u100());
}
S´ebastien Verel S´eparation de codes et m´ethodes
Choses encore myst´ erieuses
void setup() { size(500, 200);
smooth();
strokeWeight(20.0);
stroke(0, 100);
x = 0;
}
void draw() { background(226);
point(x, height / 2);
x = x + 1;
}
Choses myst´ erieuses
”coeur” du programme : facile ( !)
”d´ecoration autour du coeur” : sˆurement flou (pour l’instant) float moyenne(int n) {
float a, m int i;
...
return m;
}
ou encore
void deviner(int n) { int rep;
...
}
S´ebastien Verel S´eparation de codes et m´ethodes
De mˆ eme plus g´ en´ eralement
But
Donner un sens plus pr´ecis `a la ”d´ecoration”
Algorithme moyenne(n : entier) : r´eel d´ebut
variablem,a : r´eel variablei : entier ...
retourner m fin
Les ´ el´ ements du ”d´ ecors”
1. Fonctions
Comment les d´efinir ? Comment les utiliser ? 2. Valeur finale
Comment la d´efinir ? quels types utiliser ? 3. Param`etres
A quoi servent-ils ? comment les utiliser ? 4. Variables locales/globales
Comment les utiliser ?
Principe deS´eparation de code
S´ebastien Verel S´eparation de codes et m´ethodes
Plan
1 Fonctions et valeurs finales Fonctions
Valeurs finales
2 Param`etrer les algorithmes Param`etres
Variables locales
3 S´eparation de code
Une situation
void setup() {
println("La repetition est la base de l’arpentissage.");
println("L’entrainement assure la reussite.");
println();
println("Quoi qu’on en dise");
println();
println("La repetition est la base de l’apprentissage.");
println("L’entrainement assure la ruessite.");
println();
println("J’insiste encore une fois");
println();
println("La repetition est la base de l’apprentissage.");
println("L’entrainement assure reussite.");
println();
println("Je vous remercie de votre attention.");
}
S´ebastien Verel S´eparation de codes et m´ethodes
Analyse de la situation
3 fois le mˆeme morceaux de code
println("La repetition est la base de l’arpentissage.");
println("L’entrainement assure la reussite.");
Des erreurs dans les 3 parties
Difficile de modifier la partie de code commune
Impossible (ou tr`es incertain) de r´eutiliser le morceau de code
Solution
Centraliser en un seul endroit le morceaux de code en commun
Une meilleure situation
void texteImportant() {
println("La repetition est la base de l’arpentissage.");
println("L’entrainement assure la reussite.");
}
void setup() { texteImportant();
println();
println("Quoi qu’on en dise");
println();
texteImportant();
println();
println("J’insiste encore une fois");
println();
texteImportant();
println();
println("Je vous remercie de votre attention.");
}
S´ebastien Verel S´eparation de codes et m´ethodes
Une meilleure situation corrig´ ee
void texteImportant() {
println("La repetition est la base de l’apprentissage.");
println("L’entrainement assure la reussite.");
}
void setup() { texteImportant();
println();
println("Quoi qu’on en dise");
println();
texteImportant();
println();
println("J’insiste encore une fois");
println();
texteImportant();
println();
println("Je vous remercie de votre attention.");
}
Les fonctions sans valeur finale
En processing,
void nomFonction() {
... block d’instructions ...
}
De mani`ere g´en´erale en algorithmique, Algorithme nomFonction() : rien d´ebut
... morceau d’algorithme ...
fin
Remarques
nomFonction : peut ˆetre remplacer par n’importe quel nom, Dans un mˆeme programme, il ne peut y avoir 2 fonctions portant le mˆeme nom (sauf si elles n’ont pas les mˆemes param`etres),
Pas de valeur finale `a la fonction : type void qui signifie ”rien”, ”vide”.
S´ebastien Verel S´eparation de codes et m´ethodes
Exemple de valeur finale
int nombreHabitants() { return 63136180;
}
void setup() {
int nbFemmes = nombreHabitants() / 2;
float densite = nombreHabitants() / 670 922.0;
println("Il y a a peu pres " + nbFemmes + " en France.");
print("La densite de population en France ");
println("est de l’ordre de " + densite + " au km2.");
}
Mˆemes avantages qu’auparavant
Valeur finale : d´eclar´ee par le type avant le nom de la fonction Valeur finale : d´efinie par l’instruction return
Les fonctions avec valeur finale
En processing,
type nomFonction() {
... block d’instructions ...
return valeur ; }
De mani`ere g´en´erale en algorithmique, Algorithme nomFonction() :type d´ebut
... morceau d’algorithme ...
retourner valeur fin
Remarques
type peut ˆetre remplac´e par n’importe quel type
valeurest une valeur de type type (variable, constante, ou expression)
Apr`es l’ex´ecution de l’instructionreturn, l’ex´ecution de la fonction est stopp´ee
S´ebastien Verel S´eparation de codes et m´ethodes
En Java : une seule valeur finale
Attention : 1 seule valeur finale return x, y ; // impossible !
Il faudrait utiliser des types compos´es : voir plus tard...
Probl´ ematique
calculer la moyenne de 10 notes calculer la moyenne de 20 notes calculer la moyenne de 100 notes calculer la moyenne de 3 notes calculer la moyenne de 0 notes
S´ebastien Verel S´eparation de codes et m´ethodes
Probl´ ematique
Algorithme moyenne() : r´eel m←0
pour i de 1`a10 faire a ← lire(”entrer une note”) m←m+a
fin pour m←m/10 retourner m fin
Mauvaise id´ee
1 situation particuli`ere = 1 algorithme G´en´eraliser
Introduire un nombren `a fixer au moment de l’ex´ecution.
Probl´ ematique : proposition
Algorithme moyenne() : r´eel n←10
variablem : entier m←0
pour i de 1`an faire
a ← lire(”entrer une note”) m←m+a
fin pour m←m/n retourner m fin
Mieux puisqu’un seul changement `a faire
Mais toujours : 1 situation particuli`ere = 1 algorithme
S´ebastien Verel S´eparation de codes et m´ethodes
Probl´ ematique
G´en´eraliser
Introduire un nombren `a fixer au moment de l’ex´ecution de l’algorithme.
Algorithme moyenne() : r´eel variablem : entier
m←0
pour i de 1`an faire
a ← lire(”entrer une note”) m←m+a
fin pour m←m/n retourner m fin
Fixer la valeur de n ` a l’ex´ ecution
2 solutions possibles :
Demander la valeur de n dans l’algorithme ”moyenne” : n ← lire(”Taper le nombre de nombres”)
mauvaise solution
algorithme ”moyenne” effectue deux choses :
demander le nombre de notes ET calculer la moyenne.
Mettre n en param`etre de l’algorithme ”moyenne” : Algorithme moyenne(n : entier) : r´eel
S´ebastien Verel S´eparation de codes et m´ethodes
Vers la solution
Algorithme moyenne(n : entier) : r´eel m←0
pour i de 1`an faire
a ← lire(”entrer une note”) m←m+a
fin pour m←m/n retourner m fin
Autre probl` eme
Ecrire un algo qui d´etermine le plus gros gˆateau (en kg) parmi 3 (...)
si a<balors si b<calors
retourner c sinon
retourner b fin si
sinon
si a<c alors retourner c sinon
retourner a fin si
fin si fin
S´ebastien Verel S´eparation de codes et m´ethodes
Autre probl` eme
2 possiblit´es d’algorithme
Algorithme plusGros( ) : r´eel d´ebut
variable a, b, c : r´eel
a ←lire(”poids A”) b←lire(”poids B”)c ←lire(”poids C”) si a<balors
si b<calors retourner c sinon
retourner b fin si
sinon
si a<c alors retourner c sinon
retourner a fin si
fin si
Autre probl` eme
2 possiblit´es d’algorithme
Algorithme plusGros(a : r´eel, b : r´eel, c : r´eel) : r´eel d´ebut
si a<balors si b<calors
retourner c sinon
retourner b fin si
sinon
si a<c alors retourner c sinon
retourner a fin si
fin si fin
S´ebastien Verel S´eparation de codes et m´ethodes
Algorithme plusGros ` a pr´ ef` erer
Second algorithme : meilleur puisqu’il correspond `a notre attente : Seulement d´eterminer le plus gros gˆateau (en kg) `a partir de donn´ees.
et non r´ealiser en plus la tache de saisie de ces poids
Quand utiliser un (des) param` etre(s) ?
Questions `a se poser ?
L’algorithme doit-il r´esoudre un ensemble de probl`emes d´ependant de param`etres ?
Peut-on g´en´eraliser l’algorithme `a l’aide de variables ? La r´esolution du probl`eme n´ecessite-t-elle des donn´ees externes ?
Si oui `a moins une des questions :
−→utiliser un algorithme param`etr´e `a l’aide de variables
S´ebastien Verel S´eparation de codes et m´ethodes
Comment ´ ecrire un algorithme avec des param´ etres ?
Algorithme nomAlgo(nom1 : type1,nom2 : type2,nom3 : type3,... ) :type d´ebut
...
fin
nom1,nom2,nom3 sont des noms de variables type1, type2, type3 sont les types des variables correspondantes (bool´een, entier, r´eel, mot,...)
Exemple
Calculer la longueur de l’hypoth´enuse d’un triangle rectangle Algorithme hypothenuse(a : r´eel, b : r´eel) : r´eel
d´ebut ...
fin
S´ebastien Verel S´eparation de codes et m´ethodes
Traduire en java
Calculer la longueur de l’hypoth´enuse d’un triangle rectangle
Algorithme hypothenuse(a : r´eel, b : r´eel) : r´eel d´ebut
retourner sqrt(a2+b2) fin
Param` etres effectifs et formels
Algorithme hypothenuse(a : r´eel, b : r´eel) : r´eel d´ebut
...
fin
Les valeurs des param`etres sont fix´es lors de l’ex´ecution : c ← hypothenuse(3,4)
a et b sont des Param`etres formels: ils repr´esentent des nombres quelconques.
3 et 4 sont des Param`etres effectifs: valeurs des param`etres r´eellement utilis´es.
S´ebastien Verel S´eparation de codes et m´ethodes
En Java...
type nomAlgo(type1 nom1, type2 nom2, type3 nom3,...) { ...
}
nom1,nom2,nom3 sont des noms de variables qui sont de type type1 ,type2,type3
Autant de variables que n´ecessaire Sans param`etre :
type nomAlgo() { ...
}
Un petit exemple
double hypothenuse(double a, double b) { return sqrt(a * a + b * b);
}
S´ebastien Verel S´eparation de codes et m´ethodes
Commentaires
N´ecessaire pour :
clarifierl’utilisation de vos fonctions sans connaitre leur fonctionnement
indiquer la signification des variables param`etres
´
eviter les erreurs
/*****************************************
* Lit un nombre entier au clavier
*
* entree :
* - message : message d’invite
*
* sortie :
* - nombre de type int correspondant \unhbox \voidb@x \bgroup \let \unhbox \voidb@x \setbox \@tempboxa \hbox {a\global \mathchardef \accent@spacefactor \spacefactor }\accent 18 a\egroup \spacefactor \accent@spacefactor la valeur saisie
*****************************************/
int lire(String message) {
String str = JOptionPane.showInputDialog(null, message);
return Integer.parseInt(str) ;
S´ebastien Verel S´eparation de codes et m´ethodes
En Processing
Processing simplification orient´ee graphique de java Fonctions setup etdraw :
fonctions ex´ecut´ees automatiquement par Processing Fonctions ”´ev´enementielles” (keypressed,onMouse, etc.) : ex´ecut´ees lors de l’apparition de l’´ev´enement
Lorsqu’on d´efinit ses propres fonctions,
la d´efinition de la m´ethodesetup est n´ecessaire
S´ebastien Verel S´eparation de codes et m´ethodes
Utilisation de variables dans un algorithme
Enregistrer des r´esultats interm´ediares au cours d’un algorithme : Algorithme moyenne(n : entier) : r´eel
d´ebut
variablem,a : r´eel variablei : entier ...
retourner m fin
m,aet i sont des variables locales`a l’algorithme.
Remarque :
Toute variable utilis´ee dans un algorithme doit ˆetre d´eclar´ee.
Port´ ee des variables locales
les variables locales (m,a eti) ne sont accessibles que dans cet algorithme, c’est-`a-dire entre d´ebut et fin.
Algorithme moyenne(n : entier) : r´eel d´ebut
variablem,a : r´eel variablei : entier ...
retourner m fin
moyenne(5) m ←m+ 3
Cette derni`ere ligne n’a pas de sens, mn’existe pas `a l’ext´erieur de l’algorithme.
S´ebastien Verel S´eparation de codes et m´ethodes
Port´ e des variables locales
Les valeurs des variables locales n’alt`erent pas les valeurs des variables portant le mˆeme nom `a l’ext´erieur de l’algorithme.
variablem : r´eel m ←2
moyenne(5) m ←m+ 3
´
ecrire(m)
Variables locales et param` etres
Les variables d´eclar´ees en param`etre des algorithmes sont des variables locales `a l’algorithme avec les mˆemes propri´et´es.
Remarques dans ce cours :
valeurs initiales des variables en param`etre : celles donn´ees effectivement en ex´ecutant l’algorithme (passage par valeur) impossible de modifier la valeur d’une variable par l’ex´ecution d’un algorithme (pas de passage par adresse)
S´ebastien Verel S´eparation de codes et m´ethodes
En Java...
void deviner(int n) { int rep;
rep = n - 1;
while (rep != n) {
rep = lire("Proposer un nombre entier");
}
println("Win win win !");
}
Variables d´eclar´ees et accessibles seulement entre {et } de la m´ethode
Variable globale Java (Processing)
Une m´thode de processingpeut modifierla valeur d’une variable d´eclar´ee `a l’ext´erieure de la m´ethode
int n = 5;
void plus1() { n = n + 1;
}
void setup() { plus1();
print(n);
}
n a pour valeur 6
On parle alors devariable globalepar opposition `a variable locale.
S´ebastien Verel S´eparation de codes et m´ethodes
Variable globale Java
Eviter les variables globales pour ´eviter les modifications malheureuses et inattendues
Il vaut mieux ´ecrire : int plus1(int n)
return n + 1 ; }
void setup() { int n = 5;
n = plus1(n);
print(n);
}
En Java : commentaires !
/*****************************************
* Lit un nombre entier au clavier
*
* entree :
* - message : message d’invite
*
* sortie :
* - nombre correspondant \unhbox \voidb@x \bgroup \let \unhbox \voidb@x \setbox \@tempboxa \hbox {a\global \mathchardef \accent@spacefactor \spacefactor }\accent 18 a\egroup \spacefactor \accent@spacefactor la valeur saisie
*****************************************/
int lire(String message) {
String str = JOptionPane.showInputDialog(null, message);
return Integer.parseInt(str) ; }
S´ebastien Verel S´eparation de codes et m´ethodes
Quoi t’est-ce ?
Maintenant nous avons des algorithmes avec : des donn´ees en entr´ee,
une valeur finale de sortie un traitement local bien d´efini
M´ethode analytique (diviser pour r´egner)
D´ecouper le ”gros” probl`eme, et donc le code, en fonctions ind´ependantes simples
R´esolution de l’ensemble du probl`eme par l’assemblage des fonctions : cr´eation de ”gros” algorithmes
Avantages ` a s´ eparer le code en plusieurs sous-algorithmes ?
Suit la m´ethode de Descartes de la r´esolution de probl`eme Limitations des erreurs :
plus un algorithme est court moins il y a d’erreurs Algorithmes plus faciles `a ´ecrire :
Conception descendante (du g´en´erale au particulier) Algorithmes r´eutilisables :
plus facile `a adapter, `a reprendre pour d’autre algorithme (biblioth`eque)
Factorisation de l’algorithme :
ne pas ´ecrire beaucoups de fois les mˆemes algorithmes
S´ebastien Verel S´eparation de codes et m´ethodes
D´ emarche analytique (rappels)
Pr´eceptes de la m´ethode
l’´evidence :
” Le premier ´etait de ne recevoir jamais aucune chose pour vraie que je ne la connusse ´evidemment ˆetre telle ; c’est-`a-dire, d’´eviter soigneusement la pr´ecipitation et la pr´evention, et de ne comprendre rien de plus en mes jugements que ce qui se pr´esenterait si clairement et si distinctement `a mon esprit, que je n’eusse aucune occasion de le mettre en doute. ”
l’analyse:
”Le second, de diviser chacune des difficult´es que
j’examinerais, en autant de parcelles qu’il se pourrait, et qu’il serait requis pour les mieux r´esoudre. ”
D´ emarche analytique (rappels)
Pr´eceptes de la m´ethode
la synth`ese et le raisonnement :
”Le troisi`eme, de conduire par ordre mes pens´ees, en
commen¸cant par les objets les plus simples et les plus ais´es `a connaˆıtre, pour monter peu `a peu comme par degr´es jusques `a la connaissance des plus compos´es, et supposant mˆeme de l’ordre entre ceux qui ne se pr´ec`edent point naturellement les uns les autres.”
le d´enombrement :
”Et le dernier, de faire partout des d´enombrements si entiers et des revues si g´en´erales, que je fusse assur´e de ne rien omettre. ”
S´ebastien Verel S´eparation de codes et m´ethodes
Sous-algorithme
Un sous-algorithme est un algorithme.
Algorithme monAlgo(param`etres) : type d´ebut
...
...
retourner valeur fin
Exemple
Calcul de la somme de deux nombres entiers taper au clavier Algorithme somme( ) : entier
d´ebut
variablea,b : entier a← saisir10() b ← saisir10() retourner a+b fin
S´ebastien Verel S´eparation de codes et m´ethodes
Exemple
Saisir d’un entier taper au clavier compris entre 0 et 10 Algorithme saisir10( ) : entier
d´ebut
variablea : entier
a← lire(”Taper un nombre”) tant quea<0 ? ? 10<afaire
a ← lire(”nombre incorrect, veuillez retaper un nombre entre 0 et 10”)
fin tant que retourner a fin
Exemple
Saisir d’un entier taper au clavier compris entre 0 et 10 Algorithme saisir10( ) : entier
d´ebut
variablea : entier
a← lire(”Taper un nombre”) tant quea<0 ou 10<afaire
a ← lire(”nombre incorrect, veuillez retaper un nombre entre 0 et 10”)
fin tant que retourner a fin
S´ebastien Verel S´eparation de codes et m´ethodes
Exemple : mieux
Saisir d’un entier taper au clavier compris entre deux bornes Algorithme saisir(inf : entier, sup : entier) : entier
d´ebut
variablea : entier
a← lire(”taper un nombre”) tant quea<inf OU sup<a faire
´
ecrire(”nombre incorrect, veuillez retaper un nombre entre ”, inf, ” et ”, sup)
a ← lire(”taper un nombre”) fin tant que
retourner a fin
Exemple : traduire en JAVA
int saisir(int inf, int sup) { int a ;
a = lire("taper un nombre");
while ( a < inf || a < sup) {
println("nombre incorrect, veuillez retaper un nombre entre " + inf + " et " + sup);
a = lire("taper un nombre");
}
return a;
}
S´ebastien Verel S´eparation de codes et m´ethodes
Exemple : traduire en JAVA
/*****************************************
* Lit un nombre entier au clavier comprise
* dans un interval
*
* entree :
* - inf : borne inferieure de l’interval
* - sup : borne superieure de l’interval
*
* sortie :
* - nombre correspondant a la valeur saisie
* appartenant a [inf, sup]
*****************************************/
int saisir(int inf, int sup) { int a ;
a = lire("taper un nombre");
while ( a < inf && a < sup) {
println("nombre incorrect, veuillez retaper un nombre entre " + inf + " et " + sup);
a = lire("taper un nombre");
}
return a;
S´ebastien Verel S´eparation de codes et m´ethodes
Exemple de r´ eutilisation
Petit jeu o`u l’on doit deviner un nombre myst`ere entre 0 et 100
Algorithme deviner(n : entier) : rien d´ebut
variable a: entier a←0
tant quea6=n faire
a ← lire(”Taper un nombre”) si a<n alors
´ecrire(“trop petit”) sinon
´ecrire(“trop grand”) fin si
fin tant que
´ecrire(”gagn´e”) fin
S´ebastien Verel S´eparation de codes et m´ethodes
Exemple de r´ eutilisation
Petit jeu o`u l’on doit deviner un nombre myst`ere
Algorithme deviner(n : entier) : rien d´ebut
variable a: entier a←0
tant quea6=n faire a ← saisir(0, 100) si a<n alors
´ecrire(“trop petit”) sinon
´ecrire(“trop grand”) fin si
fin tant que
´ecrire(”gagn´e”) fin
Correction de Point avec s´ eparation de code
// abscisse du point int x ;
// deplacement du point int delta ;
// initilisation de l’abscisse et de l’\’ecran void setup() {
// mise en forme de l’ecran size(500, 200);
background(255);
smooth();
strokeWeight(20.0);
stroke(0, 100);
// initialisation de l’abscisse x = 0;
// initialisation du deplacement delta = 2;
}
S´ebastien Verel S´eparation de codes et m´ethodes
Correction de Point avec s´ eparation de code
// dessin et mouvement du point void draw() {
// efface l’ecran background(255);
// dessin du point point(x, height / 2);
// modification de l’abscisse x = x + delta;
// sortie de l’ecran verificationBorne();
}
Correction de Point avec s´ eparation de code
// Verifie que la balle est dans les bornes de l’espace void verificationBorne() {
if (x > width - 1) { x = width - 1;
delta = - delta ; }
if (x < 0) { x = 0;
delta = - delta;
} }
S´ebastien Verel S´eparation de codes et m´ethodes
