Morceaux de Java au fil des TP

Introduction

1  Un langage plutôt classe

• Les valeurs de bases ou scalaires, c'est à dire des entiers, des booléens etc. (voir section 2.4).
• Les objets.

1. Des variables, ou champs, qui contiennent tout simplement des trucs, que l'on désigne par objet.nom.
2. Des méthodes, qui sont plus ou moins des fonctions à n arguments, que l'on appelle par objet.nom(arg₁,... ,arg_n).

1.1  Programme de classe

class Simple {
  static String msg = "coucou !" ;

  public static void main (String []) // déclaration de méthode
  {
    System.out.println(msg) ;
  }
}

1.2  Complément : La méthode main

  public static void main (String [] arg)

  public static  int main (String [] arg)

class Echo {
  public static void main (String [] arg) {
    for (int i = 0 ; i < arg.length ; i++) {
      System.out.println(arg[i]);
    }
  }
}

# java Echo coucou foo bar
coucou
foo
bar

1.3  Collaboration de classe

class Message {
  static String coucou = "coucou !" ;
}

class Simple {
  public static void main (String []) // déclaration de méthode
  {
    System.out.println(Message.coucou) ;
  }
}

1.4  Méfiance de classe

    static void init (int size) // initialisation de la table d'association
    static void set (String key, int v) // création ou mise à jour d'une entrée
    static int get (String key) // récupérer une valeur

class Counter {
/*************************************/
/*   Données et méthodes privées     */
/*************************************/

/* Deux tableaux pour la table de hachage */
    private static int [] count = null; // rien au de'part
    private static String [] name = null; // non plus
/* Taille de la table */
    private static int size = 0;

    // Fonction de hachage, qui transforme s en un entier
    private static int hash (String s) {
       ...
    }

/*************************************/
/*   Le reste est accessible         */
/*************************************/

    static void set (String key, int v) {
       ...
    }

    static int get (String key) {
       ...
    }

    static void init (int size) {
        count = new int [size];  // initialisation du tableau des compteurs
        name = new String [size]; // initialisation du tableau des chaînes
        Counter.size = size;     // Jeu subtil sur le nommage des variables
    }
}

• Chaque classe propose un service, qui sera maintenu même si la réalisation de ce service change (en clair, on peut changer la partie privée d'une classe indépendamment de l'usage qui est fait, car on est positivement certain que personne n'a accès aux données et méthodes privées).
• La structure des programmes est plus claire car, pour comprendre comment les diverses classes interagissent, il suffit de comprendre les méthodes (et variables) exportées (i.e., non-privées) des classes. En fait il suffit normalement de comprendre les déclarations des méthodes exportées, déclarations souvent assorties d'un commentaire judicieux. Les documentations de la librairie Java et de la MacLib fonctionnent selon ce principe.

1.5  Reproduction de classe par héritage

class Foo extends Bar {
  ...
}

• En se donnant de nouvelles méthodes et de nouvelles variables.
• En redéfinissant les méthodes (et variables) de la classe dont elle hérite. On parle alors d'overriding ou de redéfinition de méthode.

2  Constructions de base

2.1  Types

class MalType {

// la methode incr prend un entier i et renvoie i+1
   static int incr (int i) {
        return (i+1) ;
   }
 
   static void mauvais() {
     System.out.println(incr(true)) ; // Mauvais type
     System.out.println(incr()) ;     // Oubli d'argument
   }
}

# javac MalType.java
MalType.java:9: Incompatible type for method. Can't convert boolean to int.
     System.out.println(incr(true)) ; // Mauvais type
                             ^
MalType.java:10: No method matching incr() found in class MalType.
     System.out.println(incr()) ;     // Oubli d'argument
                            ^
2 errors

  System.out.println ("booléen :" + (10 < 11) + "entier : " + (314*413)) ;

2.2  Déclarations

  modifiers type name ;

  modifiers type name = expression ;

  static int i = 0;
  static String message = "coucou" ;
  static String [] jours =
    {"dimanche", "lundi", "mardi", "mercredi",
    "jeudi", "vendredi", "samedi"} ;

  modifiers type name (args)

2.3  Principales instructions

Constantes

Soit 1 (entier), true (booléen), "coucou !" (chaîne), etc. Une constante amusante est null, qui est un objet sans champs ni méthodes.

Usage de variable

Soit ``i'', où i est une variable déclarée par ailleurs. En fait, si la variable i est déclarée dans la classe Classe, alors on y accède normalement par ``Classe.i'', si la variable variable i est un champ de l'objet objet, alors on y accède par ``objet.i''. Heureusement pour nous, on peut utiliser la notation abrégée ``i'' à l'intérieur de la classe Classe et de l'objet objet. Ce qui fait que dans la pratique, il y a pas mal d'implicite dans les usages de variables.

Appel de méthode

C'est comme les variables :

statique

Soit Classe.f(i) où f est une méthode de la classe Classe. par ailleurs, si Classe.g ne prend pas d'argument, on écrit Classe.g().

dynamique

Si objet est un objet possédant la méthode f, alors on invoque cette méthode par ``objet.f(...)''.

Notez bien que les mêmes notations abrégées que pour les variables s'appliquent à l'intérieur des classes et des objets. La notation abrégée est parfois source de surprises et ont doit de temps en temps revenir à la notation complète, au moins dans sa tête, pour comprendre ce qui se passe.

Variable this

C'est carrément spécial et peut être ignoré en première lecture, à l'intérieur des méthodes d'un objet, this est cet objet lui-même. De part la notation abrégée qui interprète ``variable'' comme ``this.variable en l'absence de liaison locale de la variable variable on a généralement pas besoin d'expliciter this.

Usage des opérateurs

Par exemple i+1 (addition) ou i == 1 || i == 2 (opérateur égalité et opérateur ou booléen).

Accès dans les tableaux

Par exemple t[i], où t est un tableau défini par ailleurs.

Affectation

Par exemple i = 1, l'expression à droite de = est calculée et le résultat est rangé dans la variable donnée à gauche de =. En fait on peut trouver autre chose qu'une variable à gauche de =, on peut trouver tout ce qui désigne une case de mémoire, par exemple, un élément de tableau t[i].

Le résultat de cette ``expression'' est la valeur affectée. Ce qui permet des trucs du genre i = j = 0, pour initialiser i et j à zéro. Cela se comprend si on lit cette expression comme i = (j = 0).

Expression parenthésée

Si e est une expression, alors (e) est aussi une expression. Cela permet essentiellement de contourner les priorités relatives des opérateurs, mais aussi de rendre un source plus clair. Par exemple, on peut écrire (i == 1) || (i == 2), c'est peut-être plus lisible que i == 1 || i == 2.

Incrément, décrément

Soit i variable de type entier. Alors l'expression i++ range i+1 dans i et renvoie l'ancienne valeur de i. L'expression i-- fait la même chose avec i-1. Enfin l'expression ++i (resp. --i) est similaire, mais elle renvoie la valeur incrémentée (resp. décrémentée) de i en résultat.

Affectations particulières

La construction i op= expression est sensiblement équivalente à i = i op expression. Par exemple:

  i *= 2

range deux fois le contenu de i dans i et renvoie donc ce contenu doublé. Les finauds noteront que ++i est aussi i += 1.

Expressions suivies de ;

Évidemment cette construction n'est utile que si e fait des effets de bords (c'est à dire fait autre chose que rendre son résultat). C'est bien sûr le cas d'une affectation par exemple.

Séquence

On peut grouper plusieurs instructions en une séquence d'instruction, les instructions s'exécutent dans l'ordre.

  i = i + 1;
  i = i + 1;

Déclarations

Une déclaration de variable (suivie de ``;'') est une instruction qui réserve de la place pour la variable déclarée et l'initialise éventuellement:

  int i = 0;

Il ne faut pas confondre affectation et déclaration, dans le premier cas, on modifie le contenu d'une variable qui existe déjà, dans le second on crée une nouvelle variable.

Bloc

On peut mettre une séquence d'instructions dans un bloc {...}. La portée des déclaration internes au bloc s'éteint à la sortie du bloc. Par exemple, le programme suivant:

  int i = 0 ;
  {
    int i = 1; // Déclaration d'un nouvel i
    System.out.println("i=" + i);
  }
  System.out.println("i=" + i);

affiche une première ligne i=1 puis une seconde i=0. Il faut bien comprendre que d'un affichage à l'autre l'usage de variable ``i'' ne fait pas référence à la même variable. Lorsque l'on veut savoir à quelle déclaration correspond un usage, la règle est de remonter le source du regard vers le haut, jusqu'à trouver la bonne déclaration.

Attention, seule la portée des variables est limitée par les blocs, en revanche l'effet des instruction passe allègrement les frontières de blocs. Par exemple, le programme suivant :

  int i = 0 ;
  {
    i = 1; // Affectation de i
    System.out.println("i=" + i);
  }
  System.out.println("i=" + i);

affiche deux lignes i=1.

Retour de méthode

On peut dans le corps d'une méthode retourner à tout moment par l'instruction return expression;, où expression est une expression dont le type est celui des valeurs retournées par la méthode.

Par exemple, la méthode double qui double son argument entier s'écrit :

  int double (int i) {
    return i+i ;
  }

Si la méthode ne renvoie rien, alors return n'a pas d'argument :

  void rien () {
    return ;
  }

À noter que, si la dernière instruction d'une méthode est return ; (sans argument), alors on peut l'omettre. De sorte que la méthode rien s'écrit aussi :

  void rien () { }

Conditionnelle

C'est l'instruction if:

  if (i % 2 == 0) { // opérateur modulo
    System.out.println("C'est pair") ;
  } else {
    System.out.println("C'est impair") ;
  }

Boucle while

C'est assez tradi également. Voici les entiers de zéro à neuf:

  int i = 0 ;
  while (i < 10) {
    System.out.println(i) ;
    i = i+1 ;
  }

Soit while (expression) bloc, on exécute expression, qui est une expression booléenne, si le résultat est false c'est fini, sinon on exécute bloc et on recommence.

Boucle do

C'est la même chose mais on teste la condition à la fin du tour de boucle, conclusion : on passe au moins une fois dans la boucle :

  i = 0 ;
  do {
    System.out.println(i) ;
    i = i+1 ;
  } while (i < 10)

(Les entiers de zéro à neuf).

Boucle for

C'est celle de C. Elle est un rien complexe.

  for (int i=0 ; i < 10 ; i = i+1)
    System.out.println(i);

C'est à dire que la syntaxe générale est

  for (einit ; econd ;  enext)
    bloc

Et que c'est quasiment la même chose que d'écrire :

  {einit ;
    while (econd) {
      bloc
      enext;
    }
  }

Gestion du contrôle

Certaines instructions permettent de ``sauter'' quelquepart de l'intérieur des boucles. Ce sont des formes polies de goto. Il s'agit de break, qui fait sortir de la boucle, et de continue qui commence l'itération suivante en sautant par dessus ce qui reste de l'itération en cours.

Ainsi on peu ecrire, pour rechercher si l'entier foo est présent dans le tableau t.

   boolean trouve = false ;

   for (int i = 0 ; i < t.length ; i++) {
     if (t[i] == foo) {
       trouve = true ;
       break ;
     }
   }
   // trouve == true ssi foo est dans t

Ou encore si on veut cette fois compter les occurences de foo dans t :

  int count = 0 ;

   for (int i = 0 ; i < t.length ; i++) {
     if (t[i] != foo) {
       contine ;
     }
     count++ ;
   }

Noter que dans les deux cas on fait des choses un peu compliquées. Dans le premier cas, on pourrait faire une méthode et utiliser return, ou une boucle while sur trouve. Dans le second cas, on pourrait écrire le test d'égalité. Bon, c'est pour expliquer car, dans certaines situations, ces instructions sont pratiques.

2.4  Types scalaires

2.4.1  Booléens

  boolean b1 = 1 < 2 ; // vrai
  boolean b2 = 1 != 1 ; // faux

  if (0 <= i && i <= 9) ...

  ((0 <= i && i < max) && a[i] < m)

2.4.2  Entiers

2.4.3  Caractères

  char jMajuscule = 'j' - 'a' + 'A';

  int i ;
  if ('0' <= c && c <= '9')
    i := c - '0';
  else
     // Erreur

  for (int i = 0 ; i < 10 ; i++)
    System.out.print('a');
  System.out.println();

  for (int i = 32 ; i < 128 ; i++)
    System.out.print((char)i);
  System.out.println();

for (char c = ' ' ; c <= '~' ; c++)
      System.out.print(c);
    System.out.println()

2.5  Passage par valeur

  static void dedans(int i) {
    i = i+2 ;
    System.out.println("i=" + i)
  }

  static void dehors(int i) {
     System.out.println("i=" + i) ;
     dedans(i) ;
     System.out.println("i=" + i) ;
   }

  static void dedans(int j) { // Ca change ici
    j = j+2 ;
    System.out.println("j=" + j)
  }

  static void dehors(int i) {
     System.out.println("i=" + i) ;
     dedans(i) ;
     System.out.println("i=" + i) ;
   }

  // Affichage d'un tableau (d'entiers) passé en argument
  static void affiche(int[] t) {
    for (int i = 0 ; i < t.length ; i++)
      System.out.print ("t[" + i + "] = " + t[i] + " ") ;
    System.out.println ("") ; // sauter une ligne
  }

// trois façons d'ajouter deux
  static void dedans (int[] t) {
    t[0] = t[0] + 2;
    t[1] += 2;
    t[2]++ ; t[2]++ ;
  }

  static void dehors () {
    int[] a = {1,2,3} ; // declaration et initialisation d'un tableau
    affiche (a) ;
    dedans (a) ;
    affiche (a) ;    
  }

1 2 3 
3 4 5 

3  Cet obscur objet

3.1  Utilisation des objets

Point p = new Point () ;

Point p = new Point (100,100) ;

if (p.h == p.v)
  System.out.println("Le point est sur le diagonale");

3.2  Fabrication des objets, que des champs

class IntPair {
  int x ;
  int y ;

  IntPair (int x0, int y0) {
    x = x0 ;
    y = y0 ;
  }
}

  IntPair p1 = new IntPair (0, 1) ;
  IntPair p2 = new IntPair (2, 3) ;

  System.out.println(p1.x + ", " + p2.y)  

class IntList {
  int cont ;
  IntList rest ;

  IntList (int cont, IntList rest) {
    this.cont = cont ;
    this.rest = rest ;
  }
}

  IntList l = new IntList (1, new IntList (2, new IntList (3,null))) ;

  static void print (IntList l) {
 
  while (l != null) {
    System.out.println(l.cont) ;
    l = l.rest ;
  }

3.3  Fabrication des objets, avec méthode

class IntStack {
  final static int MAX=64 ;
  private int [] t ;
  private int sp ;

  IntStack () {
    t = new int [MAX] ;
    sp = 0 ;
  }

 private void error (String msg) {
    System.err.println (msg) ;
    System.exit (2) ;
  }

  boolean empty () {
    return sp == 0 ;
  }

  int pop () {
    if (empty ())
      error ("Pop sur pile vide") ;
   return t[--sp] ;
  }

  void push (int i) {
    if (sp >= MAX)
      error ("Push sur pile pleine") ;
   t[sp++] = i ;
  }

  public String toString () {
    StringBuffer r = new StringBuffer () ;

    r.append ("{") ;
    for (int i = 0 ; i < sp-1 ; i++) {
      r.append(t[i]) ;
      r.append(", ") ;
    }
    if (sp > 0)
      r.append(t[sp-1]);
    r.append ("}") ;
    return r.toString () ;
  }
}

• Le mot-clef private (cf. la section 1.4) est largement utilisé pour restreindre à la classe ce qui ne regarde pas le monde extérieur.
• La méthode toString (qui doit être publique, voir la section 1.4) permettra d'afficher les piles par System.out.print, etc. Le compilateur interprétant plus ou moins ``System.out.print(o)'' comme ``System.out.print(o.toString ())''.
• Le code de toString utilise la classe StringBuffer (voir section 6.4), essentiellement pour éviter les recopies de chaînes que la concaténation ``+'' entraîne.

4  Exception

int depile() {
  if (vide())
    throw new Error ("Pile vide") ;
  ...
}

int depileZero (Pile p) {
  try {
   return p.depile () ;
  } catch (Error e) {
    System.err.println ("Erreur réparée : " + e.getMessage ()) ;
    return 0 ;
  }
}

public static void main (String [] arg) {
  try {
     ... 
  } catch (Error e) {
    System.err.println("Cher utilisateur, je suis au regret de devoir vous quitter") ;
    System.exit(2) ;
  }
}

public int read() throws IOException

int eat_space_read() throws IOException {
  int c ;

  do {
    c = read () ;
    if (c != ' ')
      return c ;
  } while (true) ;
}

5  Entrées-sorties

Reader entree =  new InputStreamReader(System.in) ;

• Si un caractère est lu, il est renvoyé comme un entier.
• Si on est à la fin de l'entrée, -1 est renvoyé (la fin de l'entrée est par vous signalée par ``Control-d'' au clavier et est la fin de fichier si il y a eu redirection).
• En cas d'erreur l'exception IOException est levée. Ces erreurs sont du genre de celles détectées au niveau du système d'exploitation, comme la panne d'un disque (rare !), ou un delai abusif de transmission par le réseau (plus fréquent). Bref en gros, pour une raison ou une autre, la lecture est jugée impossible.

import java.io.*; // La classe Reader est dans le package java.io

class Cat {

  public static void main(String [] args) {
    Reader entree =  new InputStreamReader(System.in) ;

    try {
      for (;;) {// Boucle infinie, on sort par break
        int c = entree.read ();
        if (c == -1)
          break;
        else
          System.out.print ((char)c);
      }
      entree.close();
    } catch (IOException e) { // En cas de malaise
      System.err.print("Malaise : ") ;  
      System.err.println(e.getMessage()) ;
      System.exit(-1) ; // Terminer le programme sur erreur
    }      
  }
}

• Il y a un try... catch, car les méthodes read et close peuvent lever l'exception IOException. À la fin du traitement de l'exception, on utilise System.exit qui arrête le programme d'un coup.
• Pour afficher c comme un caractère, il faut le changer en caractère, par ``(char)c''.
• Enfin, il est de bon ton de fermer les flots dont on a plus besoin par la méthode ``close''. Cela permet au système Java de récupérer les ressources par eux mobilisées. (Ici c'est inutile car le programme termine immédiatement après.)
• En fait et à ignorer en première lecture, il vaut mieux, pour des raisons d'efficacité, éviter la lecture sur le disque à chaque appel de read, pour ce faire, on intercalera un tampon mémoire, à l'aide de la classe BufferedReader.

6  Quelques fonctions (méthodes) de librairie

6.1  Les entiers

• parseInt

    public static int parseInt(String s) throws NumberFormatException
  

  Si la chaîne s contient la représentation décimale d'un entier, alors parseInt renvoie cet entier. Si parseInt ne pervient pas à lire un entier dans s, alors l'exception NumberFormatException est levée.

6.2  Un peu de maths

• abs

  public static int abs(int a)
  

  Retourne la valeur absolue de l'entier a. C'est une méthode statique, de sorte que l'on obtient la valeur absolue de l'entier i par ``Math.abs(i)''.
• max, min

  public static int max(int a, int b)
  public static int min(int a, int b)
  

  Retourne le plus grand (le plus petit) des deux entiers a et b.
• random

  public static synchronized double random()
  

  Renvoie un double (flottant double précision) pseudo-aléatoire entre 0.0 et 1.0. Pour obtenir un entier aléatoire entre zéro et MAX : (int)(Math.random() * MAX).
  
  
• cos, sin

  public static native double cos(double a)
  public static native double sin(double a)
  

  Fonctions trigonométrique. Attention, les angles sont exprimés en radians. D'où la définition de constante suivante.
  
  
• PI

  public static final double PI
  

  Approximation de Pi en flottant double précision. Le mot-clé final indique une constante (valeur non modifiable).
  
  
• round

  public static int round(float a)
  public static long round(double a)
  

  Arrondi des flottants vers les entiers, notez que l'entier renvoyé est un long (entier sur 64 bits) dans le cas des flottants double précision et un int (entier normal, sur 32 bits) dans le cas des flottants simple précision. Snif.

6.3  Les chaînes

• length

    public int length()
  

  Renvoie la longueur de la chaîne. C'est une méthode dynamique, de sorte que la longueur de la chaîne s s'obtient par ``s.length()''.
  
  
• charAt

    public char charAt(int index)
  

  Renvoie le caractère d'indice index. Les indices commencent à zéro.
  
  
• equals

    public boolean equals(Object obj)
  

  Compare la chaîne et un objet quelconque. Renvoie true en cas d'égalité et false autrement.
  
  
• compareTo

    public int compareTo(String anotherString)
  

  Compare la chaîne avec une autre selon l'ordre lexicographique (l'ordre du dictionnaire). L'appel ``s₁.compareTo(s₂)'' renvoie un entier r avec :
  • r < 0, si s₁ précède s₂ dans le dictionnaire.
  • r = 0, si les deux chaînes sont les mêmes.
  • r > 0, si s₁ suit s₂ dans le dictionnaire.
  
  
  
• toUpperCase, toLowerCase

  public String toUpperCase()
  public String toLowerCase()
  

  Cette methode dynamique rend une version majusculée (resp. minusculée) de la chaîne. Par exemple "COUCOU".toLowerCase{} est la chaîne "coucou".

6.4  Les tampons de caractères

• Le constructeur StringBuffer().

  public StringBuffer()
  

  Crée un nouveau tampon de capacité initiale par défaut (16 caractères).
  
  
• append(String), append(int), ... append(Object).

  public synchronized StringBuffer append(String str)
  public StringBuffer append(int i)
  public synchronized StringBuffer append(Object obj)
  

  Cette méthode est abondamment surchargée (i.e. le choix de la méthode effectivement appelée dépend du type de l'argument). Toutes ces méthodes ajoutent la représentation sous forme de chaîne de leur argument à la fin du tampon (dont la capacité est augmenté silencieusement si nécessaire). Dans le cas de l'argument objet quelconque (le dernier), c'est la chaîne obtenue par ``obj.toString ()'' qui est ajoutée au tampon. Les autres méthodes sont là, soit pour des raisons d'efficacité (cas de String), soit parce que l'argument est de type scalaire (cas de int).
  
  
• toString()

  public String toString()
  

  Copie le contenu du tampon dans une nouvelle chaîne. La chaîne renvoyée ne bougera plus par la suite, même si on ajoute d'autres caractères au tampon (ce qui me semble un comportement sain et cohérent). L'existence même de cette méthode pose un amusant problème : t étant un StringBuffer, que se passe-t-il si on fait ``t.append(t)'' ? (La réponse est finalement peu excitante.)

6.5  Classe Reader

import java.io.* ;

• read

  public int read() throws IOException
  

  Cette méthode dynamique renvoie un entier qui est le caractère en attente dans le flot d'entrée, ou -1, si le flot est terminé. En outre et comme annoncé par sa déclaration elle peut lever l'exeception IOException en cas d'erreur (possible dès que l'on s'interesse au fichiers). Le traitement des exceptions en Java oblige soit à attraper l'exception (par try...catch), soit à déclarer que la méthode qui invoque read peut lever l'exception (par throws). Voir la section 5, pour un exemple de la première situation, et une explication un peu plus détaillée à la section 4.
  
  
• close

  public void close() throws IOException
  

  Ferme le flot d'entrée. Cette opération libère les ressources mobilisées lors de la création d'un flot d'entrée (numéros divers liées au système de fichiers, tampons internes). Si on ne ferme pas les flots dont on ne sert plus, on risque de ne pas pouvoir en ouvrir d'autres, en raison de l'épuisement de ces ressources.

6.6  Classe BufferedReader

• BufferedReader.

  public BufferedReader(Reader in)
  

  Crée un flot d'entrée tamponné, à partir d'un lecteur quelconque. On peut créer un tel lecteur quelconque à partir d'un fichier de nom ``nom'' comme un objet de la classe FileReader. De sorte que l'on récupère un flot d'entrée tamponné ouvert en lecture sur un fichier par :

  BufferedReader entree = new BufferedReader (new FileReader(nom));
  

  On peut aussi créer un lecteur quelquonque à partir de l'entrée standard ``System.in'' comme un objet de la classe InputStreamReader. Soit en passant sur les détails :

  BufferedReader entree = new BufferedReader (new InputStreamReader(System.in));
  

  Farbriquer un BufferedReader à partir d'un StringReader ne présente aucun intérêt, mais c'est possible...

6.7  Les tableaux

6.7.1  Les types

  int [] ti ;        // tableau d'entiers
  String [] ts ;     // tableau de chaînes
  String [] [] tts ; // tableau de tableaux de chaînes

6.7.2  Valeurs tableaux

• La constante null avec laquelle on ne peut rien faire est aussi un tableau dont on ne peut rien faire.
  
  
• L'appel de constructeur : ``new type [taille]'', où type est le type des éléments du tableau et taille la taille du tableau. Par exemple, pour déclarer et initialiser un tableau t de seize entiers, on écrira :

    static int [] ti = new int [16];
    static String [] ts = new String [16];
    static String [] [] tts = new String [16][16] ; // 16 x 16 chaînes.
  

  Par défaut, les éléments du tableau vaudront un scalaire particulier dans le cas des tableaux de scalaires (zéro pour un tableau d'entiers, false pour un tableau de booléens) et null dans dans le cas des tableaux d'objets, cas qui comprend entre autres les tableaux de chaînes.
  
  
• Un tableau explicite, sous la forme ``{e₁, e₂,... e_n}'', où les e_i sont des expressions du type des éléments du tableau. Par exemple, pour déclarer et initialiser le tableau ti des seize premiers entiers, on écrira :

    int [] ti = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16} ;
  

  Dans le cas des tableaux de tableaux, on écrira :

    int [] [] tti = {{1,2}, {3}};
  

  C'est à dire que tti[0] est le tableau {1,2} et tti[1] est le tableau {3}.

6.7.3  Opérations sur les tableaux

• Acceder à un élément : ``t[e_i]'', où t est le tableau et e_i une expression de type entier. Attention, les indices commencent à zéro.
• Trouver la longueur d'un tableau : c'est une syntaxe objet, tout se passe comme si la longueur était le champ length du tableau, soit t.length.

7  La MacLib

7.1  Objets graphiques

7.1.1  La classe Point

• Les champs h et v. Chaque objet point possède (entre autres) ce deux champs qui donnent ses coordonnées.
  
  
• Les constructeurs Point() et Point(int, int).

  public Point()
  public Point(int h, int v)
  

  La construction new Point () renvoie un point situé à l'origine des coordonnées, tandis que new Point(i, j) renvoie un point situé en (i, j).
  
  
• toString()

  public String toString()
  

  Cette méthode (dynamique) donc invoquée par p.toString() renvoie une chaîne qui décrit le point p. Sa présence permet d'afficher des points par System.out.println, c'est utile pour la mise au point (ahah).

Point p1 = ... ;
Point p2 = ... ;
Point p3 = ... ;
Point [] triangle = {p1, p2, p3} ;

7.1.2  La classe Rect

• Les constructeurs Rect(), Rect(int, int, int, int) et Rect(Point, Point).

  public Rect()
  public Rect(int left, int top, int right, int bottom)
  public Rect(Point p1, Point p2)
  

  La construction new Rect () renvoie un rectangle de taille zéro et situé à l'origine des coordonnées, Le constructeur qui prend quatre entiers crée un rectangle défini par ses points nord-ouest et sub-est. Le dernier constructeur est plus flexible, il renvoie le plus petit rectange qui contient les deux points passés en arguments.
  
  
• setRect

    public void setRect(Rect r,int left, int top, int right, int bottom)
  

  Met à jour le rectangle r en en faisant le rectangle compris entre les coordonées horizontales left et right, et les coordonées verticales top et bottom. Normalement on a left est inférieur ou égal à right et top est inférieur ou égal à bottom.
  
  Remarquons que les deux codes ``Rect r = new Rect () ; setRect(r,a,b,c,d);'' et ``Rect r = new Rect (a,b,c,d);'' sont équivalents.

7.2  Méthodes de la MacLib

• initQuickDraw

  public static void InitQuickDraw()
  

  Démarre la session (c'est à dire procède aux initialisations nécessaires et affiche la fenêtre graphique).
  
  
• moveTo

  public static void lineTo(int h, int v)
  

  Pose le crayson au point de coordonnées (h, v).
  
  
• lineTo

  public static void lineTo(int h, int v)
  

  Trace un segment de droite de la position courante au point de coordonnées (h, v). Le crayon est en (h, v) après le tracé.
  
  
• foreColor, backColor.

  public static void foreColor(int color)
  public static void backColor(int color)
  

  Change la couleur de ce qui sera dessiné (respectivement effacé) par la suite. L'argument est une couleur représentée par un entier. La MacLib fournit un certain nombre de ces couleurs, sous forme des variables (constantes) blackColor, whiteColor, redColor, greenColor, blueColor, cyanColor, magentaColor, et yellowColor. Il y a d'autres façons de spécifier les couleurs dans la MacLib, mais nous nous en tiendrons à celle-ci, si vous voulez bien.
  
  
• frameRect, paintRect, eraseRect.

  public static void frameRect(Rect r)
  public static void paintRect(Rect r)
  public static void eraseRect(Rect r)
  

  Dessine le tour, paint l'intérieur ou efface le rectangle passé en argument.
  
  
• framePolygon, paintPolygon, erasePolygon.

  public static void framePolygon(Point points[], int pCount)
  public static void paintPolygon(Point points[], int pCount)
  public static void erasePolygon(Point points[], int pCount)
  

  Dessine le tour, paint l'intérieur ou efface le polygone passé en argument. Le polygone est donné par le tableau de points points accompagné du nombre pCount des points à considérer en tant que sommets.

8  Quelques exemples tordus et trucs

8.1  Portée des variables

class Counter {

    private static int [] count = null; // rien au de'part
    private static String [] name = null; // non plus
    private static int size = 0;

     ...

    static void init (int size) {
        count = new int [size];
        name = new String [size];
        Counter.size = size; // Oups !!!
    }
}

    static void init (int x) {
        count = new int [size];
        name = new String [size];
        size = x;
    }

class IntList {
  int cont ;
  IntList rest ;

  IntList (int cont, IntList rest) {
    this.cont = cont ;
    this.rest = rest ;
  }
}

8.2  Sur les caractères

• Pour savoir si un caractère c est un chiffre :

    '0' <= c && c <= '9'
  

• Pour récupérer la valeur d'un chiffre :

    int i = c - '0' ;
  

Index

Ce document a été traduit de L^AT_EX par H^EV^EA.