découper un probléme en sous-problémes

la fonction qui résoud un sous-probléme

Source de Prog25.java

class Prog25 { public static void main(String args[]) { int h, m, s, duree; System.out.println("Saisie d'un horaire"); System.out.println("Donnez les heures"); h = Clavier.lireInt(); System.out.println ("Donnez les minutes"); m = Clavier.lireInt(); System.out.println("Donnez les secondes"); s = Clavier.lireInt(); duree = conversionHMS2S(h, m, s); System.out.println("Cet horaire dure " + duree + " secondes."); } /** Les données h, m, s représentent un horaire : h heures, m minutes, s secondes. La fonction calcule la durée en secondes que représente cet horaire. Préconditions : h >= 0, 0 <= m <= 59, 0 <= s <= 59. */ static int conversionHMS2S( int h, int m, int s) { int duree; duree = 3600 * h + 60 * m + s; return duree; } }

• La résolution d'un problème doit être découpée en sous-problèmes plus petits. La résolution de chacun des problèmes "plus petits" est souvent plus simple.
• La fonction résout un problème et plus précisément à partir de données, calcule un résultat.
• les lignes du programme :
  • /** délimite un commentaire de documentation JAVA */
    documentation qui peut être mise en forme par l'utilitaire javadoc
  • la méthode main appelle la méthode conversionHMS2S en lui donnant des données
  • la méthode conversionHMS2S fait des calculs à partir des données fournies puis termine en fournissant un résultat.
  • la méthode main récupère le résultat et poursuit son exécution
  • Il n'y a pas de confusion entre les variables "durée" car elles sont dan des blocs distintcs.

en JAVA, fonction = méthode static

• /** commentaire sur le probléme résolu Préconditions sur les paramètres, si nécessaire */ static typeDuRésultat NomDeLaMéthode (liste des paramètres) { déclarations de variables (locales à cette méthode) instructions de résolution du probléme retourne valeurRésultat; //au moins 1 fois }

• La première partie qui décrit les caractéristiques d'utilisation de la méthode est appelée l'en-tête de la méthode( ou fonction).
  • La liste de paramètres spécifie pour chaque paramètre (donnée) son type.
  • Le type (des données ou du résultat) peut être réel, entier, chaîne de caractères, ou autre.
  • Le commentaire précise ce que résoud la méthode, le rôle des données et en particulier s'il y a des préconditions sur les données.
    Ce commentaire est indispensable pour pouvoir re-utiliser cette méthode, que ce soit par le programmeur plusieurs mois après l'avoir écrit ou par un autre programmeur.
• La seconde partie, celle entre les accolades est le corps de la méthode, qui spécifie l'enchaînement des instructions nécessaire au calcul du résultat de la méthode.
  • l'instruction return termine l'exécution de la méthode et envoie le résultat spécifié à la méthode appelante.
• la méthode est static car elle s'applique en dehors des objets !
• Lorsqu'une méthode en appelle une autre :
  nous les nommons l'appelante et l'appelée
  • les valeurs des expressions données en appel sont fournies aux paramètres de la méthode appelée
  • l'exécution de la méthode appelante est suspendue et ses variables "sont conservées"
  • la méthode appelée s'exécute avec ses variables paramêtres et ses variables locales (celles do bloc corps de fonctions)
  • lorsque qu'une instruction return est rencontrée, la méthode appelée se termine et la valeur précisée dans le return est fournie en résulatat à l'appelante.
  • la méthode appelante reprend son exécution en récupérant la valeur résultat.

regrouper les outils similaires

une "bibliothèque de fontions"

Source de ManipsHeure.java

/** classe de manipulation des heures */ class ManipsHeure { /** Les données h, m, s représentent un horaire : h heures, m minutes, s secondes. La fonction calcule la durée en secondes que représente cet horaire. Préconditions : h >= 0, 0 <= m <= 59, 0 <= s <= 59. */ static int conversionHMS2S( int h, int m, int s) { int duree; duree = 3600 * h + 60 * m + s; return duree; } /** retourne une chaine de caractère contenant l'horaire auquel correspond la durée donnée en paramètre Le format de la chaine résultat est h ... min ... s Préconditions : durée >= 0. */ static String duree2ChaineHMS(int duree) { int heures, minutes, secondes; heures = duree/3600; minutes = duree/60 - 60 * heures; secondes = duree%60 ; return heures+"h"+minutes+"m"+secondes+"s"; } }

• les lignes de la classe :
  • La classe regroupe 2 méthodes static (fonctions) de résolution de probléme d'horaire.
• Une résolution particulière peut être utilisée dans la résolution de divers problèmes.
  Il est intéressant, en conséquence, d'écrire une seule fois cette résolution et de pouvoir y faire appel autant de fois que nécessaire dans d'autres résolutions.
• La bibliothèque regroupe plusieurs fonctions de résolution de problèmes connexes qui seront facilement ré-utilisables.

la classe "bibliothèque"

• classe NomDeLaBibliothèque
{
plusieurs fonctions static (de la bibli....)
}
• Ainsi dans JAVA, on dispose d'une classe bibliothèque Math dans laquelle sont regroupées les fonctions de résolutions mathématiques : racine carrée sqrt, puissance power, logarithme log, cosinus cos, ....
• Pour exécuter ou compiler une classe utilisant les méthodes de la classe bibliothèque, il suffit de pouvoir "accéder" au fichier NomDeLaBibliothèque.class
  • Pour les débutants, dans le même répertoire !
  • le chemin d'accès à la classe bibliothèque doit figurer dans le "classpath" et les imports;
  • CLASSPATH est une variable du système qui spécifie les chemins des répertoires des classes visibles
  • en Linux :
    

    $ echo $CLASSPATH /home/df/mesClasses/:/home/df/essai/ CLASSPATH=.:$CLASSPATH $ echo $CLASSPATH .:/home/df/mesClasses/:/home/df/essai/

  • en WinDaube :
    

    $ echo %CLASSPATH% D:\df\mesClasses\;D:\df\essai\ set CLASSPATH=.;%CLASSPATH% $ echo %CLASSPATH% .:D:\df\mesClasses\;D:\df\essai\

  • CLASSPATH
    • D'abord, on visualise les chemins actuels de classes
    • donc lors d'une compilation ou exécution, sont visibles seulement les classes du répertoire mesClasses et du répertoire essai
    • puis on ajoute le répertoire courant (.) dans le classpath
    • On peut spécifier le classpath à la compilation et à l'exécution en ajoutant l'option -classpath liste_des_chemins
    • le débutant aura le classpath avec seulement le répertoire courant .

Programme principal

Source de Prog26.java

class Prog26 { public static void main(String args[]) { int h, m, s, duree; String hor; System.out.println("Saisie d'un horaire"); System.out.println("Donnez les heures"); h = Clavier.lireInt(); System.out.println("Donnez les minutes"); m = Clavier.lireInt(); System.out.println(" Donnez les secondes"); s = Clavier.lireInt(); duree = ManipsHeure.conversionHMS2S(h,m,s); System.out.println(" Cet horaire dure" + duree + " secondes."); hor = ManipsHeure.duree2ChaineHMS(duree); System.out.println(" L'horaire de départ est" + hor); } }

• les lignes du programme :
  • le programme appelle les méthodes de la classe ManipsHeure.
  • Pour ce faire, il doit préfixer le nom de la méthode par le nom de sa classe.
• compilation : la vérité
  Source de Prog61.java

  class Prog60 { public static void main(String args[]) { // identique au Prog26 ci-dessus int h, m, s, duree; ... System.out.println("Saisie d'un horaire"); System.out.println("Donnez les heures"); .... duree = ......conversionHMS(h,m,s); ... } }

• La compilation de ce programme produit un fichier Prog60.class

paramètres et résultats : mécanisme

• Source de Prog27.java

  class Prog27 { public static void main(String args[]) { int i=21, j=100; double d; System.out.println("i = "+i+", j = "+j); d = calcul(i); System.out.println("i = "+i+", d = "+d); echangeEntiers (i,j); System.out.println("apres l'echange : i = " +i+", j = "+j); } static double calcul(int donnee) { System.out.println("méthode calcul : donnee = " +donnee); donnee = donnee +1; return Math.sqrt(donnee); } static void echangeEntiers (int x, int y) { int z; z = x; x = y; y = z; } }

• EXECUTION

  i = 21, j = 100 méthode calcul : donnee = 21 i = 21, d = 4.69041575982343 apres l'echange : i = 21, j = 100

• les lignes du programme :
  • c'est bien la valeur de i qui est passée et non i, puisque donnee est incrémentée dans la méthode appelée et pas i de la méthode appelante!
  • selon le même raisonnement, les valeurs sont échangées de la méthode appelée ne modifient pas les varaibles de la méthode appelante!
  • la méthode echangeEntiers ne renvoyant pas de résultat est qualifiée de void
• Source de Prog28.java

  class Prog28 { public static void main(String args[]) { int[] tab; tab = tableau0123(); System.out.println("tableau avant :"); affichetableau(tab); echangeElementTableauEntiers(tab,0,2); System.out.println("tableau apres :"); affichetableau(tab); } static void echangeElementTableauEntiers (int []t, int posX, int posY) { int z; z = t[posX]; t[posX] = t[posY]; t[posY] = z; } static int[] tableau0123 () { int[] t = {0,1,2,3}; return t; } static void affichetableau(int []t) { for (int i=0; i<t.length ; i++) System.out.print(t[i]+" "); System.out.println(); } }

• EXECUTION

  tableau avant : 0 1 2 3 tableau apres : 2 1 0 3

• les lignes du programme :
  • la méthode tableau0123 n'a pas de données, uniquement un résultat
  • l'échange içi fonctionne : le tableau passé en paramètre a son contenu changé par la méthode appelée et ceci est effectif dans le tableau donné dans la méthode appelante.
    Un tableau est un type référence : c'est la valeur référence qui est passée, pas de contenu.
  • Même technique pour la méthode tableau0123 qui fournit la référence du tableau à la méthode appelante.
• mécanisme de passage des paramètres et résultat
  • L'échange de valeurs (données, résultat) entre les méthodes exécutées se fait par les paramètres (dans le sens "données") et l'instruction retourne (dans le sens "résultat").
  • Ce sont les valeurs qui sont passées en paramètre, de même pour le résultat.
  • Chaque méthode s'exécute avec ses variables (locales) et paramètres.
    La fin de la méthode entraîne la disparition des varaibles locales et paramètres ainsi que leurs valeurs.
  • L'exécution de l'une (celle appelée) se déroule pendant que l'exécution de l'autre (celle appelante) est suspendue.
• type simple et type référence :
  • Pour les types simples, une variable posséde une valeur
  • Pour les types références : tableaux et objet comme String, la variable a comme valeur un référence (une adresse mémoire) sur le contenu
    

exercices

• Fabriquer une bibliothèque DateFormatEntier qui manipule les dates au "format entier de date". Elle comportera des méthodes :
  • validate qui retourne vrai si l'entier donné est une date au format souhaité (avec le pb du maximun des jours de mois à 30, 31 voire 28 ou 29 )
  • getJour qui retourne le numéro entier de jour de la date si elle est au "format entier de date", sinon retourne -1
  • getMois et getAnnee du même genre,
  • formaterString(date, separateur) qui retourne la date sous forme d'une chaine de caractères : jour separateur mois separateur annee
    et qui retourne la chaine vide si date n'est pas au format
    separateur est une chaine
  • enLettres retourne la date sous forme d'une chaine de caractères :
    jour mois_en_toute_lettre annee
    et retourne la chaine vide si date n'est pas au format
  • Correction
  • écrire un programme qui teste cette bibliothèque :
    • saisie d'un entier,
    • afficher si c'est un format entier de date
    • si oui, l'afficher sous la forme 03/11/2003 et sous la forme 3 novembre 2003
    • Correction