Structure générale d’un code (simplifiée)

images/whitebelt.png

Pour le moment nous avons entraperçu une structure générale simplifiée d’un code source java:

public class NomDeClasse {
   // DECLARATIONS DE MEMBRES
       // membres d'instance
      // champs
      // méthodes
       // membres de classe
      // champs
      // méthodes
   // DECLARATIONS DE CONSTRUCTEURS
      //constructeur(s)
}

L’ordre des déclarations de "premier niveau" ne dépend que des conventions adoptées par chaque équipe de programmation.

D’autre types définis par le programmeur (comme les enums) ont des règles légèrement différentes.

Dans les descriptions suivantes nous n’utilisons pas les descriptions standard B.N.F. Les éléments optionnels seront encadrés par des crochets "[ ]" . (Pour ceux qui se demandent ce que veut dire le sigle BNF: wikipedia: Backus Naur Form Le document de spécifications de Java comprend de nombreuses descriptions utilisant ce formalisme)

Déclarations des variables membres

   [ modificateurs ] Type nom ;
   // ou
   [ modificateurs ] Type nom [ = expression ] ;

(des déclarations comme : Type nom1, nom2, … sont aussi possibles). Pour le moment nous connaissons des modificateurs comme static et final mais il y en a d’autres comme public ou private.

Variables membres (champs). 

public class  Climatisation{
   double temperature ;
   int humidité ;
   long timestamp = System.currentTimeMillis() ;
}

Déclaration de méthodes

   [ modificateurs ] Type nomMethode ( [ paramètres ] ) {
      // bloc : liste d'instructions
      //  au moins une instruction return
   }
   //or
   [ modificateurs ] void nomMethode ( [ paramètres ] ) {
      // bloc : liste d'instructions
   }
  • paramètres est une liste de symboles (Type nomParm) séparés par une virgule.
  • quand le type du résultat n’est pas spécifié par le mot-clef void alors la méthode doit avoir au moins une instruction return.
  • dans le bloc de définition du code on peut déclarer des variables locales qui seront uniquement utilisées par les instructions de ce bloc.

Méthodes. 

public class CharPicker {
   java.util.Random luck = new java.util.Random() ;

   public char charIn(String aString) {
      // utilise des méthodes d'autres classes
      int length = aString.length() ; // variable locale
      int index = luck.nextInt(length) ;
      return aString.charAt(index) ;
   }

   // la méthode "magique" servant de point d'entrée
   // (en général dans un code à part!)
   public static void main(String[] args) {
      CharPicker pick = new CharPicker() ;
      System.out.println(pick.charIn(
        "superextracalifragilistiexperidelicieux")) ;
   }
}

Déclaration de constructeurs

   [ modificateurs ] NomDeLaClasse ( [ paramètres ] ) {
      // bloc instructions
      // 3 parties!  souvenez-vous en!
   }

Constructeur. 

public class  Climatisation{ // un objet "valeur"
   final double temperature ;
   final int humidité ;
   final long timestamp = System.currentTimeMillis() ;

   public Climatisation( double temp, int humd) {
      this.temperature = temp ;
      this.humidité = humd ;
   }
}

Il peut y avoir plusieurs manières de créer un objet d’un certain type donc il peut y avoir plusieurs constructeurs différents (avec des signatures différentes).

S’il y a des variables membres marqués final elles devront toutes être initialisées par tous les constructeurs de la classe.

Rappel: dès qu’un constructeur est défini les constructeur par défaut (sans paramètres) disparait et on ne peut plus l’utiliser (à moins qu’on rédéfinisse explicitement le code d’un constructeur sans paramètres).

Autre point : un constructeur n’est pas une méthode! (il n’est pas membre de la classe). Nous verrons plus loin que ceci a des conséquences.