Formation JAVA les sous-programmes, tutoriel & guide de travaux pratiques en pdf.

Donner une expression

La fonction peut etre definie par une expression dont le cal cul donne la valeur de la fonction en tout point de son domaine de definition. Pour cela, il faut ch oisir un nom, disons x, pour d´esigner un element quelconque du domaine. Ce nom est appel variable en mathematiques.
Par exemple on peut d´efinir la fonction f(x)=3*x+2 Dans cette fonction, x est la variable. C’est un nom que l’on donne pour d´esigner un el´ement quelc onque de l’ensemble A. L’expression est 3*x2+. Cette expression contient la variable, des constantes (2 et 3) et des op´erations (+ et *). Ces op´erations sont elles-memes des fonctions, d´efinies avan t f.
Le nom de la variable n’a pas d’importance. Par exemple, les deux d´efinitions suivantes d´efinissent une seule et mˆeme fonction : f(x)=x+3 et f(y)=y+3.
Calcul du resultat´ de l’application
Pour calculer la valeur d’une fonction f d´efinie par une expression pour une valeur donn´ee de l’ensemble de d´efinition A, il faut remplacer dans l’expres sion la variable par cette valeur. Cela donne une expression dans laquelle il n’y a plus d’inconnue. On peut r´ealiser le calcul pour obtenir une valeur de l’ensemble B.
Par exemple, pour calculer la valeur de f d´efinie par f(x)=3*x+2 pour la valeur 5, on rem-place x par 5 dans l’expression 3*x+2. Cela donne l’expression 3*5+2 dans laquelle il n’y a pas d’inconnue et qu’on peut calculer pour obtenir le r´esultat 17. On en conclut que +f(5)=17+.
Par rapport a` la d´efinition au moyen d’un graphe, la d´efinit ion de fonction par une expression a l’avantage de permettre de d´efinir des fonctions dont le gra phe est infini. Par exemple, la fonction f(x)=3*x+2 est d´efinie pour tout l’ensemble des entiers relatifs, qui e st un ensemble infini. Il y a donc une infinit´e de couples dans le graphe de cette fonction .
L’ordre des calculs n’est pas important, c’est a` dire que le r´esultat obtenu a` la fin est le mˆeme quel que soit l’ordre de r´ealisation du calcul. Il existe d’ailleurs un certains nombres de lois d´efinissant l’´equivalence d’expressions, permettant de r´ealiser le s calculs plus simplement (factorisation, asso-ciativit´e, commutativit´e).

Utiliser une construction par cas

Une fonction peut aussi ne pas etreˆ d´efinie de la mˆeme fac¸o n suivant les valeurs de la variable. On utilise diff´erentes expressions pour diff´erents sous-e nsemble de l’ensemble de d´efinition A. On parle de fonction d´efinie par morceau.
Voici quelques fonctions d´efinies a` l’aide de constructio ns par cas, ecrites´ de diff´erentes mani`eres.
1. abs(x) = si x ≤ 0 alors x sinon (- x)
2.par_morceaux
(x) = x + 1 si x ≤ 1
x + 4 si x > 1 et x ≤ 100
x + 2 si x > 100
continue (x) = sin(x) / x si x = 0
1 sinon
Pour qu’une telle d´efinition soit valide, il faut que les dif f´erents cas soient mutuellement exclusifs, c’est a` dire que pour une valeur donn´ee, il n’y ait qu’une d´efinition.
Calcul du resultat´ de l’application
Pour calculer le r´esultat de l’application d’une fonction d´efinie par morceau pour une valeur v donn´ee, il faut d’abord d´eterminer quel cas s’applique a` cette valeur puis effectuer le calcul de l’ex-pression donn´ee pour ce cas.

Utiliser la recursion

Les moyens d´ej`a vus ne sont pas suffisants pour d´ecrire par exemple la fonction factorielle de N dans N. La suite des valeurs de factorielle est souvent d´ecrite comme suit :
0!=1
n! = 1 * 2 * 3 * … * (n-1) * n
L’´ecriture ci-dessus, mˆeme si elle est evocatrice,´ n’es t en rien effective. Il est impossible d’´ecrire un algorithme contenant des points de suspension ! Pour d´efi nir une fonction calculant effectivement la factorielle d’un entier, il faut autoriser l’emploi du nom de la fonction en cours de d´efinition dans l’expression qui la d´efinit. Une telle d´efinition sera dite r´ecursive. Nous avons d´ej`a rencontr´ des d´efinitions r´ecursives dans les descriptions de syntaxes . Voici une d´efinition effective de la fonction factorielle : fact (n) = si n=0 ou n=1 alors 1 sinon n * fact (n-1) Suivons le calcul de fact(3) en utilisant le symbole >> pour abr´eger la phrase “se simplifie en”. fact(3) >> 3 * fact(2) >> 3 * 2 * fact(1) >> 3 * 2 * 1 >> 6 Le calcul a pu etreˆ men´ a` bien parce que le calcul de fact(1) est fait directem ent, sans appel de la fonction fact.
Pour etreˆ correcte, toute d´efinition r´ecursive de foncti on, disons f, doit utiliser au moins une construction par cas avec au moins un cas dans lequel l’expression ne comporte pas la fonction f, de fac¸on a` permettre l’arrˆet des calculs. Ce cas est appel e´ cas de base de la r´ecursion.
Un autre exemple bien classique de fonction r´ecursive est la fonction de Fibonnacci, d´efinie par :
fib (n) = 1 si n =0 ou n=1
fib( n -1) + fib(n-2) sinon
Un autre exemple tout aussi c´el`ebre est celui de la fonctio n d’Ackerman d´efinie sur N × N par :
Ack(m, p) = p+1 si m=0
Ack (m-1,1) si p = 0
Ack(m-1, Ack(m,p-1)) sinon
Le lecteur est invit´e a` calculer les valeurs Ack(m,p), pou r les premi`eres valeurs de m et p.

Fonction dans un programme

Il arrive que l’on fasse des calculs dans un programme. On peut vouloir exprimer ces calculs sous forme de fonction pour deux raisons :
1. eviter´ les r´ep´etitions. Si un mˆeme calcul apparaˆıt ` a de multiples reprises dans un programme, en d´efinissant une fonction, on n’´ecrit ce calcul qu’une fo is, lorsque l’on d´ecrit la fonction. Ensuite, chaque calcul consiste a` utiliser cette fonction .
2. rendre le programme plus clair, plus lisible, en donnant un nom au calcul.
En java, il existe quelques fonctions pr´ed´efinies appel´ es op´erateurs. Ce sont les fonctions les plus courantes utilis´ees par chaque type de donn´ee. Pour les ty pes num´eriques, ce sont les quatre op´erations arithm´etiques usuelles, pour le type boolean, les connecteurs logiques, et chaque type primitif poss`ede ainsi quelques fonctions.
Il est possible d’´ecrire des fonctions dans un programme en utilisant la construction Java qui s’appelle methode´. Voyons un exemple simple : la fonction qui calcule la valeur absolue d’un nombre.
Si l’on cherche a` caract´eriser math´ematiquement cette f onction, on dira que c’est une fonction dont le domaine de d´efinition est l’ensemble des entiers rel atifs et les valeurs appartiennent a` l’en-semble des entiers naturels (une valeur absolue est toujours positive ou nulle). Puis, on donnera une d´efinition par cas :
abs(x) = x si x ≥ 0
abs(x) = −x si x < 0
Voyons maintenant comment on peut d´ecrire la fonction en Java. Nous avons d´ej`a vu au chapitre
5 un programme qui calcule la valeur absolue, sans utiliser de fonction. Nous le rappelons ici, avant
de voir le programme avec fonction.
Listing 7.1 – (lien vers le code brut)
1 p u b l i c c l a s s V a l A b s {
2 p u b l i c s t a t i c v o i d m a i n ( S t r i n g a r g s [ ] ) {
3 i n t x , a b s ;
4 T e r m i n a l . e c r i r e S t r i n g ( ” D o n n e z u n e n t i e r : ” ) ;
5 x = T e r m i n a l . l i r e I n t ( ) ;
6 i f ( x > 0 ) {
7 a b s = x ;
8 } e l s e i f ( x < 0 ) {
9 a b s = −x ;
10 } e l s e {
11 a b s = 0 ;
12 }
13 T e r m i n a l . e c r i r e S t r i n g l n ( ” La v a l e u r a b s o l u e e s t ” + a b s ) ;
14 }
15 }
Avec une fonction, le programme peut s’´ecrire comme suit.
Listing 7.2 – (lien vers le code brut)
1 p u b l i c c l a s s V a l A b s F u n c {
2 s t a t i c i n t v a l e u r A b s o l u e ( i n t n ) {
3 i n t r e s ;
4 i f ( n > 0 ) {
5 r e s = n ;
6 } e l s e i f ( n < 0 ) {
7 r e s = −n ;
8 } e l s e {
9 r e s = 0 ;
10 }
11 r e t u r n r e s ;
12 }
13 p u b l i c s t a t i c v o i d m a i n ( S t r i n g a r g s [ ] ) {
14 i n t x , a b s ;
15 T e r m i n a l . e c r i r e S t r i n g ( ” D o n n e z u n e n t i e r : ” ) ;
16 x = T e r m i n a l . l i r e I n t ( ) ;
17 T e r m i n a l . e c r i r e S t r i n g l n ( ” La v a l e u r a b s o l u e e s t ” + v a l e u r A b s o l u e ( x ) ) ;
18 }
19 }
Dans ce programme, il y a d’abord la d´efinition d’une m´ethod e appel´ee valeurAbsolue, puis utilisation de cette m´ethode dans le corps du programme (m´ethode main).
Voyons de plus pr`es la d´efinition. Elle comprend une ligne d ‘entˆete suivie d’un bloc (rappel : un bloc est une s´equence d’instructions entre accolades). La ligne d’entˆete,
static int valeurAbsolue(int x), comprend plusieurs informations :
– le mot-cl´e static, n´ecessaire, qu’on n’expliquera pas dans ce chapitre. Son roleˆ sera d´etaill´ plus tard dans le cours.
– le type int : c’est le type du resultat´ du calcul.
– le nom valeurAbsolue : c’est le nom de la m´ethode, qui est au libre choix du programmeur, comme un nom de variable.
– entre parenth`eses, deux informations : le type ( int) et le nom n du param`etre de la fonction. Il s’agit de la valeur dont on cherche la valeur absolue.
Le bloc qui suit la ligne d’entˆete est un bloc d’instructions tout a` fait classique, sauf qu’il utilise une nouvelle instruction appel´ee return. Cette instruction a pour effet de terminer l’ex´ecution de la m´ethode. Elle est suivie du r´esultat renvoy´ par la m´eth ode, c’est a` dire le r´esultat de la fonction. Dans notre exemple, on a calcul´e la valeur absolue de n et mis le r´esultat dans une variable locale res. Cette variable est locale au bloc.
A l’int´erieur du bloc de d´efinition d’une fonction, on a le d roit d’utiliser le nom du param`etre d´efini dans l’entˆete ( n apparaˆıt plusieurs fois dans la m´ethode).
En ce qui concerne l’utilisation de la m´ethode, la terminologie propose deux variantes : on peut parler d’appel de la m´ethode ou d’envoi de message. On voit l’utilisation de la m´ethode valeurAbsolue dans la ligne :
Terminal.ecrireStringln(« La valeur absolue est  » + valeurAbsolue(x));
L’appel de m´ethode proprement dit est : valeurAbsolue(x), c’est a` dire une expression com-pos´ee du nom de la fonction suivie de la valeur de son param`e tre entre parenth`eses. Il s’agit de calculer la valeur absolue du contenu de la variable x.

Notion de parametre

Dans une fonction, on veut exprimer un calcul qui d´epend d’une ou plusieurs valeurs susceptibles de varier dans un domaine. Ces valeurs, en math´ematiques sont appel´ees les variables de la fonction. On evitera´ d’utiliser cette terminologie puisqu’en programmation, on utilise le mot variable pour autre chose. On parle de parametres` de la fonction.
Une fonction est un calcul dans lequel il y a des inconnues. Tant que ces inconnues restent incon-nues, on ne peut pas effectuer le calcul et connaˆıtre son r´e sultat.
Une fonction est une moulinette qui prend une ou plusieurs choses en entr´ee et ressort une pur´ee en sortie. Une pur´ee, pas deux. Par exemple, supposons qu’on mette des carottes et des patates dans la moulinette. Il en ressort une pur´ee carotte-patate et non deux pur´ees, une de carotte et une de patates.
Les inconnues, les carottes et les patates, ce sont les param`etres de la fonction. On donne un nom a` ces param`etres.
Par exemple, quand on d´ecrit : f(x)=3*x+2, x est un nom qu’on donne a` une inconnue. Tant qu’on ne sait pas ce que vaut x, le calcul reste impossible. Le nom qu’on donne est arbitraire. Si on ecrit´ : f(y)=3*y+2, c’est toujours la mˆeme fonction.
En Java, en plus du nom, il faut donner un type aux param`etres, ce qui permet de v´erifier que le calcul est possible. Par exemple, pour la fonction f, x peut etreˆ du type int.
L’application, l’ex´ecution, l’appel de la fonction pourra se faire en donnant une valeur a` x et cette valeur devra etreˆ du bon type.
Il faut egalement´ donner le type du r´esultat, le type de la p ur´ee produite. En touillant de l’int avec les touillettes multiplication et addition, on obtient un int. Le type doit etreˆ coh´erent avec la valeur calcul´ee.
Dans le corps de la fonction, c’est a` dire dans le bloc qui suit l’entˆete, on peut utiliser le nom des param`etres pour d´enoter une valeur inconnue au moment ou` l’on ecrit´ la fonction. Cette valeur sera connue au moment de l’utilisation de la fonction, au moment de l’appel.
Nous sommes habitu´es a` manipuler des fonctions math´emat iques, c’est a` dire des fonctions num´eriques ayant des param`etres et r´esultats entiers ou r´eels. En in formatique, on peut utiliser des fonctions pour tous les types possibles.
Par exemple, on peut ecrire´ des fonctions int´eressantes u tilisant des caracteres. Nous illustrons cela avec une fonction qui calcule si un caractere est une lettre en majuscule ou non. Pour comprendre comment il fonctionne, il faut savoir que Java utilise un codage appel´ Unicode ou` toutes les lettres majuscules (sauf celles qui ont des accents, mais generalement, on n’utilise pas les majuscules ac-centuees) sont contigues. Cela signifie que, dans l’ordre du type char, entre deux majuscules, il n’y a que des majuscules.