Programmation en Java

François Sarradin

Java est un langage de programmation dont le style est proche du langage C++. Mais contrairement à ce dernier, les programmes Java sont indépendants des plate-formes, plus portables, plus sécurisés et plus dynamiques (dans le sens où la modification d'une partie d'un programme Java ne nécessite pas de recompiler tout le programme). De plus, la notion de pointeur est exclue du langage et Java gère automatiquement la mémoire : ainsi, les objets qui ne sont plus utilisés sont automatiquement détruits (pour ça, Java utilise un algorithme particulier appelé garbage collector) et les erreurs d'accès mémoire, qui entrainent parfois des plantages ou des trous de sécurité, sont quasiment inexistants.

1. Créer un programme Java

Les sources Java ont l'extension .java. Compilés avec la commande javac, ils créent des fichiers dont l'extension est .class. Pour interpréter un fichier .class, il suffit d'utiliser la commande java suivi du nom du fichier compilé sans l'extension. Par exemple :

/* nom du fichier : Hello.java */
public class Hello
{
    public static void main (String args[])
    {
        system.out.println ("Hello World!");
    }
}

Compilation : $ javac Hello.java
(la commande produit le fichier « Hello.class »)
Exécution : $ java Hello
(la commande affiche « Hello World! »)

En Java, tout les programmes sont représentés par une classe publique possédant la méthode main. Contrairement au langage C++, toutes les méthodes doivent être déclarées à l'intérieur de la classe même et dans un seul fichier. Enfin, il est impératif que le nom du fichier corresponde au nom de la classe qu'il contient.

2. Programmation objet avec Java

Le langage Java est un langage à objet. Pour Java, un objet est une structure de donnée caractérisée par un état et un comportement.

L'état est représenté par un ensemble d'attributs (ou variables) qui correspondent au données conservées par un objet à un moment précis.
Le comportement est représenté par un ensemble de méthodes (ou procédures) qui correspondent aux opérations qui peuvent être appliquées à l'objet.

Par exemple, le solde et le numéro sont des attributs d'un objet « compte bancaire », ajouter crédit et ajouter débit sont des méthodes pour ce même objet.

2.1. Classe

Les classes représentent des ensembles d'objets de même caractéristiques. Par exemple les objets compte n° XXX-ZZZ et compte n° AAA-FFF sont des objets de classe « compte bancaire ». D'un autre point de vue, les classes sont des « moules à objets » et définissent un ensemble de contraintes sur leurs états et leur comportement.

En Java, les classes sont introduites par le mot-clé class suivi du nom de la classe et de sa définition délimitée par des accolades. Par exemple :

public class CompteBancaire
{
    // Définition de la classe ...
}

Java introduit aussi la notion d'interface qui sont en quelque sorte des classes sans attributs et dans laquelle on ne définit que la signature des méthodes, c'est-à-dire des classes purement abstraites. Par exemple :

public interface CompteBancaire
{
    public void ajoutCredit (double somme);
    public void ajoutDebit  (double somme);
}

Les interfaces permettent d'imposer des contraintes au sein d'un projet informatique.

2.2. Héritage

Java (et la programmation objet en général) permet de réutiliser les méthodes et les attributs d'une classe par le concept d'héritage. Une classe qui hérite d'une autre est appelée classe fille ou classe dérivée. En Java, l'héritage est indiqué comme suit : class ClasseFille extends ClasseMere { ... }

En Java, les classes ne peuvent hériter que d'une seule classe. Par défaut, la classe dérivée est Object. Pour hériter d'une interface, il faut utiliser le mot-clé implements. Contrairement à l'héritage par classe, il est possile d'hériter de plusieurs interfaces.

2.3. Modifier

Il est possible de modifier les propriétés d'accès des attributs et des méthodes en utilisant des « modifieurs » :

public : l'élément est accessible à tous les éléments internes ou externes à la classe.
private : l'élément est accessible à tous les éléments internes à la classe courante seulement.
protected : l'élément est accessible à tous les éléments internes à la classe courante et aux classes dérivées.
final : l'élément ne peut être modifié, même par héritage.
static : l'élément est le même pour tous les objets de la classe courante. static permet de définir des attributs ou des méthodes de classe. Son exploitation ne nécessite pas de création d'objet (par exemple, Math.abs()).
abstract : l'élément n'est pas complet et la classe à laquelle il appartient ne pourra être instanciée et devra être dérivée.
synchronized : la méthode ou le bloc d'instruction ne peut pas être exécuté par deux threads en même temps.

Certains de ces « modifieurs » peuvent aussi s'appliquer aux classes ou aux interfaces. Dans ce cas, ils qualifient l'accès de ces éléments par rapport au fichier auquel ils appartiennent.

2.4. Instanciation

Pour créer un objet à partir d'une classe (i.e. pour instancier une classe), il faut utiliser l'instruction new suivi du nom de la classe : CompteBancaire cb1 = new CompteBancaire();

L'instruction new fait appel à une méthode particulière de la classe, appelé constructeur, qui ne renvoie aucune valeur et qui porte le nom de la classe. Le constructeur permet d'initialiser un objet lors de sa création. Sa définition dans la classe est facultative ; par défaut, Java propose son propre constructeur.

Par exemple :

CompteBancaire () { this (""); } // appelle CompteBancaire ("")
CompteBancaire (String numero) { solde = 0.0; this.numero = numero; }

this représente l'objet courant.
this (...) permet d'appeler un autre constructeur définit dans la classe courante.
super fait référence à la classe héritée.
super (...) permet d'appeler un constructeur de la classe héritée.

3. Contraintes et conventions

Quelques conventions doivent être suivies pour écrire convenablement des programmes Java et ainsi éviter des erreurs :

Le nom du fichier Java doit correspondre au nom de la première classe publique du fichier.
Lors de l'exécution, Java va chercher la méthode main. Tous les fichiers Java exécutables doivent contenir cette méthode et sa déclaration est la suivante :
```
public static void main (String args[])
{
    /* ... */
}
```
Contrairement au langage C++, toutes les méthodes doivent être déclarées à l'intérieur de la classe même et dans un seul fichier.
Si possible, mettez les premières lettres de chaque mot qui composent le nom de la classe en majuscule et évitez le caractère '_' (par exemple, Personne, CompteBancaire, ClassNotFoundException).
Pour les noms de méthodes la remarque la même que la précédente, sauf que la première lettre doit être en minuscule (par exemple, dateDeNaissance, obtenirSolde, lastIndexOf).
Le nom des attributs s'écrit entièrement en miniuscule et les mots qui le composent sont séparés par des caractères '_' (par exemple, nom_prenom, solde, coord_x).
Le nom des constantes s'écrivent comme le nom des attributs mais entièrement en majuscule.

4. Exemple

/*
 * CompteBancaire.java - exemple de représentation de compte
 *                       bancaire en Java
 */

public class CompteBancaire
{
    /* déclaration des attributs */
    protected float solde;
    protected String numero;

    /* constructeur */
    public CompteBancaire (String numero)
    {
        this.numero = numero;
        this.solde = 0.0;
    }

    public void credit (float somme)
    {
        solde += somme;
    }

    public void debit (float somme)
    {
        solde -= somme;
    }

    public float getSolde ()
    {
        return solde;
    }

    /*
     * la méthode toString () provient de la classe Object et
     * est utilisée par le système Java pour représenter un
     * objet sous forme de chaîne de caractère.
     * Cette méthode est très utile pour afficher simplement
     * un objet avec l'instruction System.out.println ().
     */
    public String toString ()
    {
        return "solde du compte n°" + numero + " : " + solde;
    }
}

/* ---- End ------------------------------------------- */

/*
 * CBApplication.java - exemple d'utilisation de la classe
 *                      CompteBancaire
 */

public class CBApplication
{
    public static void main (String args[])
    {
        CompteBancaire cb = new CompteBancaire ("XXX-ZZZ");
        
        System.out.println (cb);
        cb.credit (100.0);
        System.out.println (cb);
        cb.debit (50.0);
        System.out.println (cb);
    }
}

/* ---- End ------------------------------------------- */

5. Exercices

Réaliser un programme Java qui calcule le factoriel d'un nombre.
Réaliser un programme Java qui calcule un nombre au hasard et qui demande à l'utilisateur de le trouver. On utilisera la classe MathRandom.
Utilisation :
```
int i;
Object rand_gen = MathRandom.random ();
i = rand_gen.nextInt (100); // génère une valeur entre 0 et 100
```

Réaliser des classes Java qui permettent de gérer des piles génériques et dynamiques. Ces classes sont nommées EmptyStack et StackNode, elles implémentent l'interface Stack données plus loin, et représentent respectivement la pile vide et un nœud de la pile.
Utilisation :

Stack st1 = new EmptyStack ();
System.out.println (st1.length ());        // affiche "0"
st1 = new StackNode (new String ("abc"), st1);
System.out.println (st1.getObject ());     // affiche "abc"
System.out.println (st1.length ());        // affiche "1"
...
Stack st2 = new StackNode (new String ("abc"),
                new StackNode (new String ("def"),
                    new EmptyStack ()));
System.out.println (st2.length ());        // affiche "2"

La signature du constructeur de la classe StackNode est public StackNode (Object, Stack). L'interface Stack est donnée ci-dessous :

public interface Stack
{
    public Object getObject ();
    public Stack getNext ();
    public int length ();
}