Introduction à la programmation(420-PK2-SL)

cours 12

Gestion des applications

Technologie de l’information

(LEA.BW)

Plan Aujourd’hui (25/2/2011)

Retour sur les boucles imbriquées Les sous-programmes Laboratoire sur les sous-programmes

Prochain cours (25/2/2011) Laboratoire sur les sous-programmes

La semaine prochaine (3/3/2011) Les tableaux Laboratoire sur les tableaux

Retour sur les boucles imbriquées Coordonnée cartésienne

Parcours de tous les points La première boucle parcourt l’ordonnée (axe en y) La deuxième boucle parcourt l’abscisse (axe en x)

public class boucles_imbriquees{ static final int MAX_Y=20; static final int MAX_X=10; public static void main(String args[]){ for(int y=0;y<=MAX_Y;y++){ for(int x=0;x<=MAX_X;x++){ System.out.println("[" + x + "," + y +"]"); } } }}

Les sous-programmes Les procédures et les fonctions sont des sous-

programmes qui se démarrent à partir d’un programme (exemple : pow, rand, nextLine, nextInt,...)

Une fonction renvoie une valeur Le résultat de la fonction

Une procédure ne renvoie rien (void) Les sous-programmes peuvent nécessiter des

valeurs qu’il faut fournir à l’appel : paramètre effectif

Les sous-programmes Pour utiliser un sous-programme, on doit

connaître Son nom Le type et la signification de la valeur de retour

(dans le cas de fonction) Le nombre, le type et la signification des

paramètres effectifs Le traitement qui sera effectué

Pour obtenir ces informations API JAVA

http://download.oracle.com/javase/1.5.0/docs/api/

Les sous-programmes La définition formelle est l’en-tête du sous-

programme et défini Le nom du sous-programme Le type de la valeur de retour du sous-programme Les paramètres formels nécessaires à l’exécution du

sous-programme public static int plus_grand(int a, int b){ int resultat; if(a>b){ resultat=a; }else{ resultat=b; } return resultat; }

Les sous-programmes L’implémentation définit l’action du sous-

programme Ensemble d’instruction Bloc délimité par des accolades

public static int plus_grand(int a, int b){ int resultat; if(a>b){ resultat=a; }else{ resultat=b; } return resultat; }

Les sous-programmesimport java.util.Scanner;public class connaitre_plus_grand{ public static void main(String args[]){ Scanner clavier = new Scanner(System.in); int nombre1; int nombre2; int le_plus_grand; System.out.println("Entrez un entier:"); nombre1 = clavier.nextInt(); System.out.println("Entrez un entier:"); nombre2 = clavier.nextInt(); clavier.close(); le_plus_grand = plus_grand(nombre1,nombre2); System.out.println("Le plus grand est " + le_plus_grand); }

public static int plus_grand(int a, int b){ int resultat; if(a>b){ resultat=a; }else{ resultat=b; } return resultat; }}

Les sous-programmes L’implémentatio

n définit le code qui sera exécuté par le sous-programme lors de l’appel.

import java.util.Scanner;public class connaitre_plus_grand{ public static void main(String args[]){ Scanner clavier = new Scanner(System.in); int nombre1; int nombre2; int le_plus_grand; System.out.println("Entrez un entier:"); nombre1 = clavier.nextInt(); System.out.println("Entrez un entier:"); nombre2 = clavier.nextInt(); clavier.close(); le_plus_grand = plus_grand(nombre1,nombre2); System.out.println("Le plus grand est " + le_plus_grand); }

public static int plus_grand(int a, int b){ int resultat; if(a>b){ resultat=a; }else{ resultat=b; } return resultat; }}

Les sous-programmes L’appel effectif

démarre l’exécution d’un sous-programme Invocation par le nom Envoie des paramètres

(valeurs) Il récupère la valeur

de retour dans le cas des fonctions

import java.util.Scanner;public class connaitre_plus_grand{ public static void main(String args[]){ Scanner clavier = new Scanner(System.in); int nombre1; int nombre2; int le_plus_grand; System.out.println("Entrez un entier:"); nombre1 = clavier.nextInt(); System.out.println("Entrez un entier:"); nombre2 = clavier.nextInt(); clavier.close(); le_plus_grand = plus_grand(nombre1,nombre2); System.out.println("Le plus grand est " + le_plus_grand); }

public static int plus_grand(int a, int b){ int resultat; if(a>b){ resultat=a; }else{ resultat=b; } return resultat; }}

Les sous-programmes Fonction

Ensemble d’instruction renvoyant une valeur

Procédure Ensemble d’instruction ne renvoyant pas de valeur

public static double carre(double x){ return x*x;}

public static void afficher_n_allo(int n){ for (int i=1; i<=n;i++){ System.out.println(“allo”); }}

Les sous-programmes Valeur de retour

L’instruction return permet de renvoyer le résultat d’une fonction

La valeur renvoyée doit obligatoirement être du même type que ou il sera utilisé. Si le sous-programme retourne un entier, il doit être

stocké dans un int ou il peut être utilisé dans un calcul ou il peut être affiché.

Exemple return 10; // int return x; // type de x return x > y; // booléen

Les sous-programmes On appelle

paramètres formels, la liste des paramètres apparaissant dans l’en-tête d’un sous-programme

import java.util.Scanner;public class connaitre_plus_grand{ public static void main(String args[]){ Scanner clavier = new Scanner(System.in); int nombre1; int nombre2; int le_plus_grand; System.out.println("Entrez un entier:"); nombre1 = clavier.nextInt(); System.out.println("Entrez un entier:"); nombre2 = clavier.nextInt(); clavier.close(); le_plus_grand = plus_grand(nombre1,nombre2); System.out.println("Le plus grand est " + le_plus_grand); }

public static int plus_grand(int a, int b){ int resultat; if(a>b){ resultat=a; }else{ resultat=b; } return resultat; }}

Les sous-programmes On appelle

paramètres effectifs ou paramètres actuels ou argument les valeurs fournies à un sous-programme lors de l’appel

Les paramètres formels sont initialisés par la valeur des paramètres effectifs lors de l’appel du sous-programme

import java.util.Scanner;public class connaitre_plus_grand{ public static void main(String args[]){ Scanner clavier = new Scanner(System.in); int nombre1; int nombre2; int le_plus_grand; System.out.println("Entrez un entier:"); nombre1 = clavier.nextInt(); System.out.println("Entrez un entier:"); nombre2 = clavier.nextInt(); clavier.close(); le_plus_grand = plus_grand(nombre1,nombre2); System.out.println("Le plus grand est " + le_plus_grand); }

public static int plus_grand(int a, int b){ int resultat; if(a>b){ resultat=a; }else{ resultat=b; } return resultat; }}

Les sous-programmes Passage de paramètres par copie

Les paramètres effectifs sont copiés dans les paramètres formels au moment de l’appel

Les paramètres effectifs passés par copie ne sont pas touchés par une modification faite aux paramètres formels dans un sous-programme

Exemple Si dans votre programme principal (main) vous avez

une variable x, et que vous appelez un sous-programme en lui passant x. La valeur du x qui est dans le programme principal ne sera pas modifiée même si le sous-programme effectue des opérations sur la variable x.

C’est normal, car lorsqu’on passe un paramètre la valeur est copiée en mémoire.

passage_par_copie.java

Les sous-programmes Norme

Un sous-programme se doit d’avoir un commentaire d’en-tête qui donne les informations suivantes (avec éclipse la tâche sera automatisée) La description du travail effectué La description de chaque paramètre formel La description de la valeur retournée

Il doit y avoir un seul return par sous-programme Limiter la taille des sous-programmes, ils ne devraient

jamais faire bien plus de 50 lignes de code. Aucune lecture/écriture dans une fonction de calcul

La fonction pow de nous oblige pas à taper les valeurs au clavier vous devriez TOUJOURS faire de même.

Comme dans l’exemple, le sous-programme plus_grand ne demande pas à l’utilisateur les informations.

Les sous-programmes Exemple

Version 1./**PLUS GRAND*retourne le plus grand de deux entiers (premier et deuxième) reçus en paramètres*/public static int plus_grand(int premier, int deuxieme){ if (premier>deuxieme) return premier; else return deuxieme;}

Les sous-programmes Exemple

Version 2./**PLUS GRAND*retourne le plus grand de deux entiers (premier et deuxième) reçus en *paramètres*/public static int plus_grand(int premier, int deuxieme){ int resultat = premier; if (premier<deuxieme) resultat = deuxieme;

return resultat;}

Les sous-programmes/**PLUS GRAND TROIS*retourne le plus grand de trois entiers (premier, deuxième et troisième) *reçus en paramètres*/public static int plus_grand_trois(int premier, int deuxieme, int troisieme){ return plus_grand(premier,plus_grand(deuxieme,troisieme);}

***Lorsqu’une fonction existe, on peut la réutiliser à volonté, même dans d’autres fonctions

Les sous-programmes Avantages

Réutilisation de code On écrit le code une seule fois et on l’utilise à volonté Évite de reproduire des erreurs Lors de la maintenance des programmes un seul endroit

à modifier Permets de généraliser des situations grâce aux

paramètres Lisibilité du code

Un code est plus facile à lire s’il est divisé en sous-programmes. Même si le sous-programme n’est appelé qu’une seule fois dans le projet

Partionnement du travail Division des tâches dans une équipe

Laboratoire sur les sous-programmes Exercice1

Écrivez un sous-programme afficher_date qui reçoit en paramètre trois entiers représentant un jour, un mois et une année. Le sous-programme affiche le jour suivi du mois sous forme littérale et l’année sous forme d’entier. Par exemple si la procédure reçoit 28 2 1999, elle affiche 28 février 1999. 

Écrivez un programme principal qui utilise votre procédure pour afficher 28 février 2000. Vous n’avez pas à solliciter l’utilisateur pour l’instant.

Vous ne devez pas faire de vérification à ce stade

Laboratoire sur les sous-programmes Exercice 2

Ajoutez , à l’exercice 1, un sous-programme annee_valide qui retourne un entier lu au clavier plus grand qu’un nombre reçu en paramètre. Par exemple, vous passer en paramètre le nombre

1900 et le sous-programme demande des années tant que le nombres lu est plus petit que 1900.

Comme pour l’exercice 1, vous pouvez ajouté un appel dans votre programme principal pour tester votre sous-programme.

Laboratoire sur les sous-programmes Exercice 3

Ajoutez , à l’exercice 2, un sous-programme mois_valide qui retourne un entier lu au clavier et qui est entre 1 et 12. Tant que le nombre lu est invalide, la fonction le redemande.

Comme pour les autres exercices, vous pouvez ajouté un appel dans votre programme principal pour tester votre sous-programme.

Laboratoire sur les sous-programmes Exercice 4

Ajoutez, à l’exercice 3, un sous-programme est_bissextile qui reçoit une année et qui retourne TRUE(1) si l’année est bissextile et FALSE(0) sinon.

Comme pour les autres exercices, vous pouvez ajouté un appel dans votre programme principal pour tester votre sous-programme.

Laboratoire sur les sous-programmes Exercice 5

Ajoutez , à l’exercice 4, un sous-programme nbr_jour_maximum qui reçoit deux entiers. Le premier représente un mois et le second une année. La fonction retourne 28, 29, 30 ou 31 selon les valeurs reçues. Par exemple, nbr_jour_maximum(2,2000) retournera 29.

Comme pour les autres exercices, vous pouvez ajouté un appel dans votre programme principal pour tester votre sous-programme.

Laboratoires sur les sous-programmes Exercice 6

Ajoutez , à l’exercice 5, un sous-programme jour_valide qui retourne un entier lu au clavier et qui est entre deux valeurs reçues en paramètres. Tant que le nombre lu est invalide, la fonction le redemande.

Ex d’appel : jour_valide(1,29) //retourne un nombre lu entre 1 et 29

Comme pour les autres exercices, vous pouvez ajouté un appel dans votre programme principal pour tester votre sous-programme.

Laboratoire sur les sous-programmes Exercice 7

Modifiez le main(String args[]) pour obtenir un programme qui valide une date. Le programme commence par demander une année supérieure à 1900. Tant que l’année est invalide, le programme la redemande. Par la suite, le programme demande un mois valide entre un et 12. Lorsque le mois est valide, le programme demande une journée valide. Lorsque la journée entrée est valide selon le mois et l’année entrés, le programme affiche la date sous forme littérale (2 février 2000).