Exemple et Conseils


L'objectif de la programmation n'est pas seulement de faire des programmes qui marchent.

En réalité un programme n'est jamais terminé. Vous réaliserez avec le temps qu'il y a toujours des améliorations à apporter. Il faut donc pouvoir le modifier facilement, sachant que le développeur qui sera chargé de la mise à jour de votre programme ne sera pas forcément vous même. Cela a deux conséquences:

  1. Votre code doit être lisible, c'est à dire qu'en le lisant on devine facilement ce qu'il fait.
  2. D'autre part, il doit être facilement modifiable.

Dans cette partie du cours, je vous donne à travers un exemple quelques conseils permettant de rendre un programme plus lisible et plus facile à modifier.

Mise à part la lisibilité et la facilité de modification, il existe d'autres critères importants en programmation que nous n'aborderons pas ici:



Exemple de programme et conseil

Nous allons donner ici quelques conseils de programmation, à travers un exemple de projet (si vous avez téléchargé les exemples de ce cours, cet exemple se trouve dans le dossier Exemple-Java-Premieres-Notions\Peinture).

Cahier des charges

La réalisation d'un projet informatique démarre en général avec un cahier des charges. C'est en gros une description de ce que devrait faire le logiciel.

Voici, le cahier des charges de notre exemple:

On souhaiterait écrire un programme qui calcul la surface à peindre dans une pièce rectangulaire possédant des portes et des fenêtres.

Pour simplifier, on supposera que les murs ont 2m50 de hauteur et que toutes les fenêtres ont la même dimension (1.4 × 1.2) et de même pour les portes (0.9 × 2.1).

Déclaration des constantes

Introduisons une constante pour chaque donnée fixe du problème:

final double LARGEUR_FENETRE = 1.4, HAUTEUR_FENETRE = 1.2,
                 LARGEUR_PORTE = 0.9, HAUTEUR_PORTE = 2.1,
                 HAUTEUR_MUR = 2.5;

On pourrait se passer de ces déclarations et mettre directement les valeurs 1.4, 1.2, ... etc dans les calculs, mais on obtiendrait ainsi un code moins lisible et plus difficile à mettre à jour.

S'il faut corriger la hauteur des portes par exemple, il suffit de changer la valeur de la constante et cette modification sera automatiquement répercuté dans tout le code (dans tous les calculs où la hauteur des portes intervient).

Essayez de procéder de cette manière dès que vous avez des valeurs fixées. Déclarez des constantes au lieu d'écrire les valeurs dans les instructions.
Conception de l'interface graphique

La surface à peindre dépendra donc de la taille de la pièce ainsi que du nombre de portes et de fenêtres. Ce seront les données du programme. On en déduit l'interface graphique suivante:

Peinture.jpg, 21kB

Les champs de texte sont nommées CT_Largeur (largeur de la pièce), CT_Longueur (longueur de la pièce), CT_NF (nombre de fenêtres), CT_NP (nombre de portes) et CT_SP (Surface à peindre).

Les noms des champs de texte sont toutes préfixées par CT_. Cette manière de procéder permet d'éviter des conflit avec des noms de variables.

En programmation, un même nom ne peut désigner qu'une seule chose. Vous ne pouvez pas, par exemple, nommer un champ de texte Largeur et utiliser par ailleur une variable de même nom.

Je vous propose de préfixer les noms des champ de texte par CT_, ceux des zones de texte par ZT_ et ceux des boutons par BT_.

Vous pouvez bien sur avoir vos propres conventions. L'essentiel est d'en avoir une.
Lecture et déclaration des données

Associons une variable à chaque donnée: LargeurPiece, LongueurPiece, NFenetre et NPorte. D'où les déclarations:

double LargeurPiece, LongueurPiece; 
int NFenetre, NPorte;
Je n'ai pas besoin de vous expliquez ici la signification de chaque variable, car les noms choisis permettent de deviner la fonction de chacune d'entre elles. Pour obtenir un code lisible, il est recommandé de procéder de cette manière: utilisez des noms de variables parlant.

Cette remarque est évidemment également valable pour les noms de constantes et de manière générale, pour n'importe quel nom utilisé dans un programme.

Nous pouvons à présent écrire les instructions de lecture de données dans la procédure évènementielle du bouton Calculer:

procedure TForm1.BT_CalculClick(Sender: TObject);
begin
  // Lecture des données
     LargeurPiece = es.LireDouble(CT_Largeur);
     LongueurPiece = es.LireDouble(CT_Longueur);
     NFenetre = es.LireEntier (CT_NF);
     NPorte = es.LireEntier (CT_NP);
end;  
Traitement, résultats intermédiaires et finaux

Il nous faut maintenant réfléchir à la manière de calculer la surface à peindre. Pour simplifier le problème, nous allons découper le traitement en plusieurs étapes:

  1. Calcul de la surface des murs.
  2. Calcul de la surface des fenêtres.
  3. Calcul de la surface des portes.
  4. Calcul de la surface à peindre.

Le résultat de chaque étape sera sauvegardé dans une variable: SurfaceDesMurs, SurfaceDesFenetres, SurfaceDesPortes, SurfacePeinture.

Essayez également de procéder de cette manière lorsque vous avez un calcul compliqué. Découpez le calcul en plusieurs parties et sauvegardez le résultat de chacun de ces calculs dans une variable. A la fin, écrivez le calcul du résultat final en utilisant les résultats des calculs intermédiaires. Cette manière de programmer simplifie la résolution du problème et rend le programme plus lisible.

Il nous faut d'abord déclarer les nouvelles variables:

// Les résultats finaux ou intermédiaires
    
double SurfaceDesMurs, SurfaceDesPortes,
           SurfaceDesFenetres, SurfacePeinture;
Vous pouvez également procéder de cette manière. Il est en général difficile de prévoir dès le début toutes les variables que l'on aura besoin d'utiliser dans un programme. Ajoutez vos déclarations de variable au fur et à mesure des besoins.

Ecrivons à présent les quatre étapes de calcul:

Calcul de la surface des quatre murs:

 SurfaceDesMurs =  
 2 * (LargeurPiece * HAUTEUR_MUR + 
      LongueurPiece * HAUTEUR_MUR);

ou bien de manière plus concise, mais moins lisible:

 SurfaceDesMurs =  
   2 * (LargeurPiece + LongueurPiece) * HAUTEUR_MUR; 

Cette deuxième solution est également plus rapide à l'exécution, car elle ne demande que trois opérations (deux multiplications et une addition), alors que la précédente en demande quatre.

Calcul de la surface des fenêtres:

SurfaceDesFenetres = 
  NFenetre * LARGEUR_FENETRE * HAUTEUR_FENETRE;

Calcul de la surface des portes:

SurfaceDesPortes = 
NPorte * LARGEUR_PORTE * HAUTEUR_PORTE;

Calcul de la surface à peindre:

 SurfacePeinture = 
   SurfaceDesMurs  - SurfaceDesFenetres - SurfaceDesPortes;
Le code de la procédure en entier

Pour conclure, voici le code de la procédure évènementielle du bouton calculer:

 private void BT_CalculerActionPerformed
    (java.awt.event.ActionEvent evt) {  
                                              
// Lecture des données
     LargeurPiece = es.LireDouble(CT_Largeur);
     LongueurPiece = es.LireDouble(CT_Longueur);
     NFenetre = es.LireEntier (CT_NF);
     NPorte = es.LireEntier (CT_NP);

 // Calcul de la surface des murs
     SurfaceDesMurs =  
             2 * (LargeurPiece * HAUTEUR_MUR + 
                  LongueurPiece * HAUTEUR_MUR);
     
 // Calcul de la surface des fenetres
     
     SurfaceDesFenetres = 
       NFenetre * LARGEUR_FENETRE * HAUTEUR_FENETRE;
     
 // Calcul de la surface des portes
     SurfaceDesPortes = 
     NPorte * LARGEUR_PORTE * HAUTEUR_PORTE;
     
  // Calcul de la surface à peindre
     SurfacePeinture = 
     SurfaceDesMurs  - SurfaceDesFenetres - SurfaceDesPortes;

  // Affichage du résultat
     es.Afficher(SurfacePeinture,CT_SP);  
     
}              

Le code de cette procédure est bien séparé en trois parties: lecture des données, traitement des données, puis affichage des résultats. Essayez également de procéder de cette manière.

Ecrivez votre code en séparant bien la lecture, le traitement et l'affichage.


Synthese

Voici un résumé de tous les conseils vus précédemment: