public class Cours2 {

  /*
   * Déclaration (définition n'est pas un terme officiel de Java) d'une variable
   * statique accessible via le symbole PI (variable de type double et
   * initialisée à la valeur 3.14).
   * Durée de vie de la variable : (simplification) durée de vie du programme.
   * Visibilité de la variable : tout le programme.
   * Zone de stockage : la zone statique.
   * Note : le nombre de ces variables peut-être déterminé à la compilation.
   */
  public static double PI = 3.14;

  /*
   * Déclaration d'une fonction des entiers vers l'ensemble vide. La fonction
   * est nommée symboliquement affiche.
   * Visibilité du symbole : tout le programme
   * La fonction utilise un paramètre de symbole z typé int. Cette variable
   * correspond à une entrée, elle est créée à chaque appel de la fonction et
   * est initialisée à la valeur correspondante de l'appel.
   * Durée de vie de z : durée de l'appel
   * Visibilité de z : la fonction elle-même pas plus.
   * Zone de stockage : la pile
   */
  public static void affiche(int z) {
    /* Ces isntructions sont des instructions d'appels à des fonctions
     * définies par ailleurs et qui sont capables d'afficher à l'écran
     * la représentation de valeurs de différents types. Pour le
     * premier appel c'est une String qui est affichée, dans le second cas
     * c'est un double.
     */
    System.out.println("Je suis dans affiche z="+z);
    System.out.println(PI);
  }

  /*
   * Déclaration d'une fonction des entiers vers les entiers. La fonction
   * utilise un paramètre de symbole i type int, mais aussi une variable locale
   * de symbole m type int. Techniquement, la variable i est bien une variable
   * locale mais elle est différente de l'autre (m) par son mode
   * d'initialisation. Le paramètre est initialisé par l'appel, alors que la
   * variable locale est intialisée explicitement par une instruction
   * d'affectation.
   * Durée de vie de i et z : durée de l'appel
   * Visibilité de z : la fonction elle-même.
   * Zone de stockage : la pile.
   */
  public static int ajouteUn(int i) {
    int m = i+1;
    /* Ceci est une instrution d'appel. Cette instruction
     * a pour effet de transmettre à la fonction et pour l'initialisation de
     * son paramètre correspondant la VALEUR de la variable m à l'instant
     * de l'exécution de cette instruction.
     */
    affiche(m);
    /* Cette instruction à pour effet de terminer l'appel courant et de
     * renvoyer une valeur à l'appelant. Ici c'est la VALEUR de m qui
     * est transmise à l'appelant.
     */
    return m;
  }

  /*
   * Déclaration d'une fonction des références de tableaux d'entiers
   * unidimensionnels vers l'ensemble vide. La fonction possède un paramètre
   * de symbole args typé String[], mais aussi deux variables locales i et j
   * toutes deux typées int.
   * Durée de vie de i et j : durée de l'appel
   * Visibilité de i et j : la fonction elle-même
   * Zone de stockage : la pile.
   */
  public static void main(String []args) {
    int i = 4;
    /* ajouteUn(i) est une instruction d'appel de fonction. Cette instruction
     * a pour effet de transmettre à la fonction et pour l'initialisation de
     * son paramètre correspondant la VALEUR de la variable i à l'instant
     * de l'exécution de cette instruction, soit dans cet exemple la valeur 4.
     * En retour la fonction renvoie une valeur (ici 5) qui est alors
     * utilisée pour terminer l'initialisation de la variable locale j.
     */
    int j = ajouteUn(i);
    System.out.println(i+"+1="+j);
    /* ajouteUn(123) est une instruction d'appel de fonction. On transmet
     * la valeur 123 qui est utilisée par la fonction pour initialiser son
     * paramètre correespondant. Après son calcul la fonction a renvoyé une
     * valeur qui est alors employée par la fonction println() pour
     * l'afficher à l'écran.
     */
    System.out.println(ajouteUn(123));
    System.out.println(PI);
  }
}