Partie C : Classes et objets

Objectif

Être capable d’implémenter une application comportant plusieurs classes, y compris des classes abstraites, reliées par héritage, ainsi que des interfaces, et des itérateurs, en maîtrisant l’implémentation et le comportement des constructeurs, de méthodes redéfinies avec liaisons dynamiques. Être capable de prévoir le comportement d’un tel programme, y compris les objets et données créés dans la mémoire de l’ordinateur (pile, tas, zone des données statiques).

Prérequis

Parties A et B

C1 : Exemple introductif

On appelle classe dérivée d’une classe S toute classe D qui hérite de S dans le sens suivant :

• Toutes les variables de classe et attributs de S appartiennent implicitement à D.

• Toutes les méthodes de S appartiennent à D, mais peuvent être redéfinies dans D.

• D peut posséder des variables d’instance, de classe, des méthodes d’instance, de classe, spécifiques qui n’appartiennent pas à S.

Les redéfinitions d’attributs, variables de classe, méthodes de classes ne seront pas abordées.

Nous allons découvrir ces notions avec un exemple qui commence par la définition d’une classe Personne, qui représente un individu, et d’une classe Document, qui représente un document ayant un nom et un ou plusieurs auteurs (qui sont des instances de Personne).

Pour l’instant il n’y a pas d’héritage, mais seulement un lien de composition entre Document et Personne.

public class Personne
{
    private String nom;
    private Date dateNaiss;

    public Personne(String nom)
    {
        // DateNaiss est initialisé implicitement à null
        this.nom=nom;
    }

    public Personne(String nom, Date naiss)
    {
        this(nom); // Appel du constructeur à 1 paramètre
        this.dateNaiss =  naiss;
    }

    public String toString()
    {
        String s = nom;
        if(dateNaiss!=null)
        {
            s = s + "né le " + dateNaiss;
        }
        return s;
    }
}

public class Document
{
    private String nom;
    private Personne[] auteurs;

    public Document(String n, Personne[] a)
    {
        this.nom=n; auteurs = a;
    }

    public int nbAuteurs()
    {
        return auteurs.length;
    }

    public String toString()
    {
        String da;
        if(nbAuteurs()==0) da="inconnu";
        else
        {
            da="";
            for (int i = 0; i < nbAuteurs(); i++)
                da = da + auteurs[i] + " ";
        }
        return nom + "\nAuteur(s) : "+da;
    }
}

Les deux classes peuvent être représentées par ce schéma appelé diagramme de classes.

La notion de composition correspond à l’auxiliaire avoir : un document a un ou plusieurs auteurs. A présent nous allons introduire une classe Livre qui représente un cas particulier de document : un livre est un document. Cet auxiliaire être traduit la notion d’héritage.

public class Livre extends Document
{
    private long isbn;
    private int annee;

    public Livre(String nom, Personne[] aut, long isbn, int apub)
    {
        super(nom, aut); // Appel du constructeur de Document
        this.isbn=isbn;
        annee=apub;
    }

    public long getIsbn()
    {
        return isbn;
    }

    public String toString()
    {
        String s = "Livre : "+super.toString(); // Appel toString de document
        return s+"\nISBN : "+isbn+" ("+annee+")";
    }
}

Le mot-clé extends traduit l’héritage. La classe Livre est dérivée de Document. Document est la superclasse de Livre.

Le code de tout constructeur de la classe dérivée doit commencer par l’appel d’un constructeur de sa superclasse à l’aide du mot clé super.

La méthode toString existe déjà dans la superclasse et elle est ici redéfinie. La méthode toString de la superclasse est appelée depuis la classe dérivée grâce à la syntaxe super.toString().

Voici le diagramme de classe complet. Toute instance de Livre est une instance de Document. Toute instance de Document a des auteurs qui sont des instances de Personne. Donc, évidemment, toute instance de Livre a des auteurs…

Il y a quelques règles à connaitre en matière d’héritage et de constructeurs :

1. Si une classe n’a pas de constructeur explicite alors Java lui ajoute un constructeur implicite qui appelle le constructeur par défaut de sa superclasse, et initialise ses variables d’instance avec des valeurs par défaut.
2. Si une classe a au moins un constructeur explicite alors Java ne produit pas de constructeur par défaut implicite pour cette classe, mais on peut bien sûr lui donner un constructeur par défaut explicite.
3. Si le code d’un constructeur explicite d’une classe dérivée ne commence pas par super(…) alors ce constructeur appelle implicitement le constructeur par défaut de sa superclasse. Et si la superclasse n’a pas de constructeur par défaut, le programme ne compile pas !
4. Si le code d’un constructeur explicite d’une classe dérivée appelle explicitement un constructeur de sa superclasse, son code doit commencer par super(…).

Pour mémoire, rappelons le sens de quelques termes importants.

• implicite : produit automatiquement pas le compilateur, non visible dans le code.
• explicite : écrit par le programmeur.
• constructeur par défaut : sans paramètres.
• valeur par défaut : placée automatiquement dans une variable qui n’est pas initialisée explicitement.

Exercices de découverte

C-dec-10

Complétez ces lignes de code permettant de créer une instance de Document représentant un document ayant un seul auteur nommé N. Wirth et ayant pour titre "Algorithm + Data Structure = Program", puis d’afficher la description de ce document produite par la méthode toString.

Personne[] aut = {/* création d'une instance de Personne */};
Document doc = new /* À compléter */;
System.out.println(/* À compléter */);

L’instance de Personne doit être créée avec le constructeur à un paramètre, qui ne nécessite pas la date de naissance.

Vous pouvez utiliser un ordinateur pour rechercher la bonne syntaxe par essai et erreurs.

Personne[] aut = {new Personne("N. Wirth")};
Document doc = new Document("Algorithm + Data Structure = Program", aut);
System.out.println(doc);

C-dec-11

Complétez cette ligne de code permettant de créer une instance de Livre représentant un document ayant un seul auteur nommé N. Wirth et ayant pour titre "Algorithm + Data Structure = Program", un numéro isbn égal à 130224189, ayant été publié en 1976.

Personne[] aut = {new Personne("N. Wirth")};
Livre w = new Livre (// À compléter //);

Livre w = new Livre
        ("Algorithm + Data Structure = Program",
          aut,  130224189, 1976
        );

C2 : Héritage et types

En Java, chaque variable et chaque paramètre a un type. Nous avons vu qu’il existe des types primitifs : int, boolean, double, long. Chaque nom de classe représente aussi un type. Mais du fait de l’héritage, une instance de classe peut avoir plusieurs types !

Voici un premier exemple d’utilisation de notre classe Livre…

Livre w = new Livre(
        "Patience dans l'azur",
        new Personne[]{new Personne("Hubert Reeves")},
        2020099179, 1981);

System.out.println(w.toString());
System.out.println(w.getIsbn());

…qui produit l’affichage :

Livre : Patience dans l'azur
Auteur(s) : Hubert Reeves 
ISBN : 2020099179 (1981)
2020099179

Maintenant, il est aussi possible d’écrire…

Document w = new Livre(
        "Patience dans l'azur",
        new Personne[]{new Personne("Hubert Reeves")},
        2020099179, 1981);

System.out.println(w.toString());

…car toute instance de Livre est aussi par héritage une instance de Document. Mais… Il n’est plus possible d’appeler la méthode getIsbn.

System.out.println(w.getIsbn()); // Ne compile pas

Parce que c’est une méthode de Livre qui n’existe pas dans Document, et que la variable w est de type Document. Pas de problème avec la méthode toString qui est redéfinie dans la classe Livre mais existe dans Document et, cerise sur le gâteau, c’est la méthode toString de Livre qui sera exécutée et non celle de Document.

Ce petit miracle s’appelle la liaison dynamique et nous y reviendrons plus tard. Observons ce qui se produit en mémoire.

Exercices de découverte

C-dec-20

Donnez les lignes de code permettant, après la déclaration précédente,

• d’afficher le nombre d’auteurs du livre,
• d’afficher le numéro isbn du livre,
• d’afficher la description de ce document produite par la méthode toString de la classe Livre.

System.out.println(w.nbAuteurs());
System.out.println(w.getIsbn());
System.out.println(w.toString());

C-dec-21

On écrit les lignes suivantes.

Personne[] aut = {new Personne("N. Wirth")};
Livre w = new Livre
        ("Algorithm + Data Structure = Program",
          aut,  130224189, 1976
        );
Document d = w;                      // ligne A
System.out.println(d);               // ligne B
System.out.println(d.nbAuteurs());   // ligne C
System.out.println(d.getIsbn());     // ligne D

Toutes les lignes passent à la compilation sauf la dernière, qui comporte une erreur. Expliquez pourquoi.

C-dec-21

Quand on exécute le code de l’exercice précédent (en supprimant la dernière ligne puisqu’elle est incorrecte), on obtient l’affichage suivant :

Livre : Algorithm + Data Structure = Program
Auteur(s) : N. Wirth 
ISBN : 130224189 (1976)
1

Bien que la variable d soit de type Document, c’est la méthode toString de la classe Livre qui a été exécutée. Tentez de trouver une explication.

C3 : Compléments sur l’héritage et la structuration des programmes

Notion de package

Un package regroupe un ensemble de classes. Le fichier dans lequel est définie une classe d’un package p doit comporter, au début, la déclaration :

package p;

Si une classe C utilise une classe U située dans un package q différent de celui où elle se trouve, une des déclarations suivantes doit apparaître avant la définition de C :

import q.U; // Importe la classe U du package q
import q.*; // Importe toutes les classes du package q

Droits d’accès

Jusqu’à maintenant, nous avons utilisé deux droits d’accès : public et private. Il en existe deux autres : protected et « par défaut ». Ce dernier s’applique lorsque le droit d’accès à un élément n’est pas précisé.

• public : L’élément est accessible depuis toutes les classes du programme.
• private : L’élément est accessible seulement depuis la classe où il est défini ou déclaré.
• protected : L’élément est accessible depuis les classes dérivées de la classe où il est défini et déclaré et depuis toutes les classes du même package.
• par défaut : L’élément est accessible seulement depuis les classes du package de la classe où il est défini ou déclaré.

Les classes ont elles-mêmes des droits d’accès. Une classe directement définie dans un fichier source .java, comme nous l’avons fait jusqu’à présent, peut avoir le droit public ou « par défaut ». Une classe public est utilisable dans tout le programme où elle est définie, une classe avec droit d’accès par défaut n’est utilisable que depuis le package où elle est définie.

Hiérarchie de classe

Une classe déclarée final ne peut avoir de classe dérivée. Mais en dehors de cette restriction, toute classe dérivée peut elle-même avoir des classes dérivées. D’ailleurs toutes les classes descendent d’une classe définie par Java nommée Object. Par contre Java ne permet pas l’héritage multiple : chaque classe (excepté Object) a une seule superclasse.

Or il se trouve que la classe Object possède nativement certaines méthodes, dont notamment la méthode toString. On peut donc utiliser cette méthode héritée depuis n’importe quelle classe, même si elle n’y est pas redéfinie.

Exercices de découverte

C-dec-30

On ajoute la méthode suivante à la classe Document.

private void test()
{
    System.out.println("Exécution de test dans la classe Document");
}

On ajoute la méthode suivante à la classe Livre.

public void test()
{
    System.out.println("Exécution de test dans la classe Livre");
}

Le programme compile. Que peut-on en déduire en matière de possibilité de redéfinition d’une méthode private dans une classe dérivée ?

C-dec-31

On ajoute la méthode suivante à la classe Document.

public void test()
{
    System.out.println("Exécution de test dans la classe Document");
}

On ajoute la méthode suivante à la classe Livre.

private void test()
{
    System.out.println("Exécution de test dans la classe Livre");
}

Le compilateur indique une erreur. Que peut-on en déduire ?

C-dec-32

On ajoute la méthode suivante à la classe Document.

private void test()
{
    System.out.println("Exécution de test dans la classe Document");
}

On ajoute la méthode suivante à la classe Livre.

private void test()
{
    super.test();
    System.out.println("Exécution de test dans la classe Livre");
}

Le programme va-t-il compiler sans erreur ? Si oui, que se produira-t-il à l’exécution de test avec une instance de Livre ? Si non, expliquez l’erreur.

C4 : Interface

Une interface contient des signatures de méthodes et des commentaires expliquant ce que sont censées faire ces méthodes.

Par exemple, l’interface List<T> est implémentée par les classes ArrayList<T> et LinkedList<T>.

Autre exemple : il existe une interface prédéfinie Comparable<T> dans laquelle est déclarée une méthode int compareTo(T e) permettant de comparer deux objets de type T (l’objet courant et l’objet e) en respectant une relation d’ordre sur les objets de type T. Cette méthode doit retourner un entier négatif si this < e, un entier positif si this > e, et en cas d’égalité elle doit retourner 0.

Une interface définit un type. Par exemple, on peut déclarer une variable de type List.

Une interface ne contient pas de code et ne possède pas de constructeur.

Une classe peut implémenter une ou plusieurs interfaces. Elle doit alors implémenter toutes les méthodes déclarées dans cette interface (en respectant les spécifications données dans les commentaires de l’interface).

Voici un exemple d’utilisation de l’interface Comparable. Cette interface est déjà prédéfinie dans le langage Java, sous la forme suivante :

public interface Comparable<T>
{
	public int compareTo(T e);
}

Pour rendre une classe comparable, on fait en sorte qu’elle implémente cette interface :

public class Date implements Comparable<Date>
{
    // ...
	
    public int compareTo(Date d)
    {
        if(d.annee!=annee) 
            return this.annee-d.annee;

        else if(d.mois!=mois) 
            return this.mois-d.mois;

        else 
            return this.jour-d.jour;
    }
}

A présent, nous pouvons créer une liste de dates et utiliser la méthode statique sort de la classe prédéfinie Collections pour trier cette liste sans avoir à coder un algorithme de tri.

    public static void test()
    {
        List<Date> w = new ArrayList<>();
        w.add(new Date(25,1,1962));
        w.add(new Date(26,1,1962));
        w.add(new Date(25,2,1961));

        Collections.sort(w);

        System.out.println(w);
    }

L’affichage produit par l’exécution nous permet de vérifier que le tri a bien été exécuté.

[25/2/1961, 25/1/1962, 26/1/1962]

L’appel Collections.sort(w) fonctionne si et seulement si w désigne une instance d’une classe qui implémente l’interface List représentant une liste dont les éléments sont des instances d’une classe qui implémente l’interface Comparable. C’est un peu compliqué, mais très puissant puisque cela évite d’avoir à programmer une méthode de tri lorsque les conditions sont réunies.

Exercices de découverte

C-dec-40

Relisez le code de la classe Personne. Si on décide que cette classe doit implémenter l’interface Comparable, que doit-on ajouter à cette classe ? À quoi cela pourrait servir ? Proposez un exemple d’utilisation.

C5 : Classes et méthodes abstraites

Jusqu’à maintenant, nous avons parlé de classes, dans lesquelles toute méthode non héritée doit être implémentée (codée), et d’interfaces, dans lesquelles des méthodes sont déclarées, mais pas implémentées.

Une classe abstraite est une sorte d’intermédiaire entre ces deux concepts : certaines méthodes peuvent être implémentées alors que d’autres, appelées méthodes abstraites, sont juste déclarées. Une classe abstraite peut comporter des variables d’instances et des variables de classe.

Une classe abstraite ne peut pas être instanciée.

Une classe abstraite n’a d’intérêt que si elle a au moins une classe dérivée « concrète », qui implémente ses méthodes abstraites.

Fait remarquable : Une méthode concrète peut très bien appeler une méthode abstraite ! Le code exécuté est celui de l’implémentation de cette méthode dans une classe dérivée qui est déterminée lors de l’exécution du programme. On parle alors de liaison dynamique.

Pour bien comprendre le principe de la liaison dynamique, nous allons développer un exemple dans lequel une classe abstraite Animal a deux classes dérivées concrètes : Chat et Elephant.

La classe abstraite Animal a une variable d’instance nom et un constructeur qui initialise cette variable. Elle a une méthode abstraite reactionDanger et une méthode concrète dangerDetecte qui appelle la méthode abstraite reactionDanger.

La méthode abstraite reactionDanger devra être implantée dans les classes Chat et Elephant.

public abstract class Animal
{
    private String nom;

    public Animal(String nom)
    {
        this.nom = nom;
    }

    public abstract void reactionDanger(); // Méthode abstraite

    public void dangerDetecte() // Méthode concrète
    {
        System.out.println(nom + " a détecté un danger.");
        reactionDanger(); // Appel d'une méthode abstraite
    }
}

On voit dans cet exemple que la méthode concrète dangerDetecte de la classe Animal appelle une méthode abstraite reactionDanger de cette même classe. Lors de l’exécution, c’est une implémentation concrète de reactionDanger définie dans une classe dérivée qui sera appelée. C’est typiquement un cas de liaison dynamique.

Voici deux exemples de classes qui dérivent de la classe abstraite Animal.

public class Chat extends Animal
{
    public Chat(String n)
    {
        super("Le chat "+n);
    }

    public void reactionDanger()
    {
        System.out.println("Il miaule et prend la fuite");
    }
}

public class Elephant extends Animal
{
    public Elephant(String n)
    {
        super("L’éléphant "+n);
    }

    public void reactionDanger()
    {
        System.out.println("Il barrit et il charge !");
    }
}

Voici un exemple d’utilisation des classes que nous venons de définir.

Animal felix = new Chat("Felix");        // ligne A
Animal jumbo = new Elephant("Jumbo");    // ligne B
felix.dangerDetecte();                   // ligne C
jumbo.dangerDetecte();                   // ligne D

L’exécution de la ligne C produit l’affichage "Le chat Felix a détecté un danger. Il miaule et prend la fuite. "

L’exécution de la ligne D produit l’affichage "L’éléphant Jumbo a détecté un danger. Il barrit et il charge ! "

Dans les deux cas, la méthode appelée, dangerDetecte, est héritée de la superclasse Animal et appelle la méthode reactionDanger, abstraite dans la classe Animal, mais implémentée dans les classes Chat et Elephant.

Les classes abstraites permettent notamment d’éviter la duplication de code : on y implémente des algorithmes qui sont utilisés ou utilisables par plusieurs classes dérivées concrètes.

Par exemple, la classe abstraite AbstractList<T> de Java a parmi ses classes dérivées les classes ArrayList<T> et (indirectement) LinkedList<T>. Elle implante des algorithmes qui sont les mêmes pour ces deux classes, comme par exemple la méthode…

public boolean addAll(int i, Collection<? extends T> c) 

…qui insère dans la liste courante, à partir de la position i, tous les éléments de c. Cette méthode addAll utilise la méthode…

public void add(int i, T e) 

…qui devra être implémentée dans toute classe concrète dérivant de AbstractList.

Voici une vue partielle de la hiérarchie des classe java dédiées à la représentation des listes.

C-dec-50

Que se passe-t-il si on écrit, par exemple dans une méthode main, la ligne suivante ?

Animal w = new Animal("Flipper le dauphin");

C-dec-51

On ajoute une méthode enrouleTrompe à la classe Elephant.

public void enrouleTrompe() {...}

Que se passe-t-il si on écrit, par exemple dans une méthode main, les lignes suivantes ?

Animal jumbo = new Elephant("Jumbo");
jumbo.enrouleTrompe();

C6 : Les itérateurs

Un itérateur est un objet (!) permettant de parcourir facilement tous les objets d’une collection, et en particulier d’une liste. En Java, toute classe implémentant l’interface prédéfinie Iterable<T> permet d’utiliser des itérateurs. C’est le cas notamment des classes ArrayList et LinkedList, mais aussi des tableaux.

L’interface Iterable<T> est indissociable d’une autre interface prédéfinie nommée Iterator<T>.

public interface Iterator<T>
{
    boolean hasNext(); // vrai s'il y a un élément suivant
    T next();          // élément suivant
    void remove();     // suppression de l’élément suivant
}

public interface Iterable<T>
{
    Iterator<T> iterator()
    // ...
}

Pour comprendre l’intérêt et la manière d’utiliser ces concepts, considérons l’exemple d’une instance de ArrayList<Integer>.

ArrayList<Integer> w = new ArrayList<>();

w.add(15); w.add(12); w.add(33);

Iterator<Integer> scan = w.iterator(); // ligne A

while(scan.hasNext())
{
    System.out.println(scan.next());
}

En ligne A, La méthode iterator retourne un itérateur, c’est à dire une instance d’une classe qui implémente l’interface Iterator.

Dans la boucle while, Les méthodes hasNext et next de l’itérateur permettent de parcourir la liste et de récupérer ses éléments.

Cette boucle peut être réécrite avec une syntaxe plus lisible qui masque l’utilisation d’un itérateur et qui est la manière la plus courante de procéder.

  for(int x : w)
  {
      System.out.println(x);
  }

C-dec-60

Soit une classe C représentant une collection d’objets (liste, ensemble…). Soit w une instance de C. À quelle condition peut-on utiliser la syntaxe suivante :

for(x : w) {...}

C7 : Classes internes

Les compétences relatives aux notions introduites ici ne seront pas évaluée et sont présentées à titre informatif.

Les classes internes anonymes

Il arrive parfois qu’on ait besoin de créer une classe qui dérive d’une classe existante ou qui implémente une interface, et que l’on ait besoin que d’une seule instance de cette classe. Puisqu’une seule instance est requise, il n’est pas nécessaire de donner un nom à la classe et il est possible de créer la classe et son unique instance en une seule ligne de programme. Voici un exemple dont l’unique intérêt est la simplicité.

abstract class Oiseau
{
    abstract void voler();
}

public class Main
{
    public static void main(String[] args)
    {
        Oiseau bird = new Oiseau()
        {
            void voler()
            {
                System.out.println("Flap flap");
            }
        };

        bird.voler();
    } 
}

La classe Oiseau est abstraite donc on ne peut pas créer directement avec new une instance de cette classe.

La variable bird de ma méthode main reçoit une référence d’une instance d’une classe dérivée de Oiseau, qui n’a pas de nom et dans laquelle la méthode voler est implémentée. Cette classe dérivée n’aura qu’une seule instance.

Les classes internes statiques

On peut définir une ou plusieurs classes dans une classe comme dans l’exemple suivant :

public class Test
{
    public static abstract class Animal
    {
        private String nom;

        public Animal(String nom) {this.nom = nom;}
        public abstract void reactionDanger();

        public void dangerDetecte()
        {
            System.out.println(nom + " a detecte un danger.");
            reactionDanger();
        }
    }

    public static class Chat extends Animal
    {
        public Chat(String n) {super("Le chat "+n);}

        public void reactionDanger()
        {
            System.out.println("Il miaule et prend la fuite");
        }
    }
}

Pour instancier la classe Chat en dehors de la classe Test, on doit utiliser la syntaxe illustrée par cet exemple.

   Test.Animal felix = new Test.Chat("Felix");
   felix.reactionDanger();

Les classes membres

Le principe est le même que pour les classes internes statiques, mais chaque instance de la classe interne est liée à une instance de la classe enveloppante, et à accès aux variables d’instance de la classe enveloppante. Dans cet exemple, la classe Liste représente une liste chaînée dont les éléments de type double, sont contenus dans des maillons, qui sont des instances d’une classe interne Maillon.

public class Liste
{
    Maillon deb;

    private class Maillon
    {
        Maillon suiv;
        double val;

        Maillon(double val)
        {
           this.val=val;
           suiv=deb;
           deb=this;
        }
    }
  
    public void ajoute(double x)
    {
        Maillon m = new Maillon(x);
    }

    public void print()
    {
        Maillon cur=deb;
        while(cur!=null)
        {
            System.out.println(cur.val);
            cur = cur.suiv;
        }
    }
}

Le constructeur de Maillon a accès aux attributs de la classe Liste.

La méthode ajoute ajoute un élément en début de liste. La méthode print affiche les éléments de la liste.

La classe Maillon étant private, elle ne peut être exploitée que dans la classe Liste.

Exercices d’assimilation

C-ass-00

Réalisez une classe Video qui représente un cas particulier de Document. Les instances de Video représentent des vidéos qui, en plus de tous les attributs d’un document, ont une durée. Cette durée doit être l’un des paramètres du constructeur de la classe Video. La classe Video doit redéfinir la méthode toString de sorte que cette méthode retourne la description retournée par la méthode toString de Document, complétée avec la durée. La classe Video doit être dotée en outre d’une méthode getDuree qui retourne la durée de la vidéo représentée par l’instance courante.

public class Video extends Document
 {
   private double duree;
 
   public Video(String n, Personne[] a, double duree)
   {
 			// À compléter
   }
 
   public double getDuree()
   {
  		// À compléter
   }
 
   public String toString()
   {
      // À compléter
   }
 }

public Video(String n, Personne[] a, double duree)
 {
   super(n, a);
   this.duree = duree;
 }

public double getDuree()
 {
   return this.duree;
 }
 
 public String toString()
 {
   return super.toString() + " durée : " + this.duree;
 }

C-ass-01

Réalisez une classe Roman qui représente un cas particulier de Livre. Les instances de Roman représentent des romans qui, en plus de tous les attributs d’un livre, ont un genre, représenté par une chaîne de caractère. Ce genre doit être l’un des paramètres du constructeur de la classe Roman. La classe Roman doit redéfinir la méthode toString de sorte que cette méthode retourne la description retournée par la méthode toString de Livre, complétée avec le genre.

public class Roman extends Livre
 {
   private String genre;
 
   public Roman(String nom, Personne[] aut, long isbn, int apub, String genre)
   {
       // À compléter
   }
 
   public String toString()
   {
       // À compléter
   }
 }

public Roman(String nom, Personne[] aut, long isbn, int apub, String genre)
 {
   super(nom, aut, isbn, apub);
   this.genre = genre;
 }

public String toString()
 {
   return super.toString() + " genre : " + this.genre;
 }

C-ass-02

Exercice créé par Marie-Laure Mugnier, Université de Montpellier

Les Pokémons sont des gentils animaux qui sont passionnés par la programmation objet en général et par le polymorphisme en particulier. Il existe quatre grandes catégories de Pokémons :

– Les Pokémons sportifs : Ces Pokémons sont caractérisés par un nom, un poids (en kg), un nombre de pattes, une taille (en mètres) et une fréquence cardiaque mesurée en nombre de pulsations à la minute. Ces Pokémons se déplacent sur la terre à une certaine vitesse que l’on peut calculer grâce à la formule suivante : vitesse = nombre de pattes * taille * 3.

– Les Pokémons casaniers : Ces Pokémons sont caractérisés par un nom, un poids (en kg), un nombre de pattes, une taille (en mètres) et le nombre d’heures par jour où ils regardent la télévision. Ces Pokémons se déplacent également sur la terre à une certaine vitesse que l’on peut calculer grâce à la formule suivante : vitesse = nombre de pattes * taille * 3.

– Les Pokémons des mers : Ces Pokémons sont caractérisés par un nom, un poids (en kg) et un nombre de nageoires. Ces Pokémons ne se déplacent que dans la mer à une vitesse que l’on peut calculer grâce à la formule suivante : vitesse = poids / 25 * nombre de nageoires.

– Les Pokémons de croisière : Ces Pokémons sont caractérisés par un nom, un poids (en kg) et un nombre de nageoires. Ces Pokémons ne se déplacent que dans la mer à une vitesse que l’on peut calculer grâce à la formule suivante : vitesse =(poids / 25 * nombre de nageoires) / 2.

Pour chacune de ces quatre catégories de Pokémons, on désire disposer d’une méthode toString qui retourne (dans une chaine de caractères) les caractéristiques du Pokémon.

Programmez ces classes en Java. Les attributs sont privés. Pour éviter de devoir créer autant de fichiers que de classes, vous pouvez ne déclarer qu’une classe "public", celle qui contient la méthode main de l’application.

Le but est de minimiser les duplications de code en utilisant le polymorphisme (méthodes abstraites, redéfinition, héritage, liaison dynamique).

Voici un exemple de méthode main permettant de tester votre solution.

public static void main(String[] args)
 {
   Pokemon p1 = new PokSportif("Tim", 1.2, 4, 0.3, 70);
   System.out.println(p1.toString());
 
   Pokemon p2 = new PokMaison("Tom", 1.8, 4, 0.5, 5);
   System.out.println(p2.toString());
 
   Pokemon p3 = new PokMer("Tum", 2.4, 2);
   System.out.println(p3.toString());
 
   Pokemon p4 = new PokMer("Tem", 3.3, 2);
   System.out.println(p4.toString());
 }

L’affichage attendu lors de l’exécution de la méthode de test est le suivant.

Tim : Pokemon sportif de fréquence cardiaque 70
4 pattes, taille = 0.3 m
vitesse : 3.59, poids : 1.2

Tom : Pokemon domestique regardant la télé 5 heures par jour
4 pattes, taille = 0.5 m
vitesse : 6.0, poids : 1.8

Tum : Pokemon de mer
2 nageoires
vitesse : 0.19, poids : 2.4

Tem : Pokemon de mer
2 nageoires
vitesse : 0.26, poids : 3.3

abstract class Pokemon
{
   String nom;
   double poids;
 
   public Pokemon(String nom, double poids)
   {
     this.nom = nom;
     this.poids = poids;
   }
 
   public abstract double vitesse();
 
   public abstract String description();
 
   public String toString()
   {
     return nom + " : " + description() + "\nvitesse : " 
            + vitesse() + ", poids : " + poids;
   }
}

abstract static class PokTer extends Pokemon
{
   private int pattes;
   private double taille;
 
   public PokTer(String nom, double poids, int nb_pattes, double taille)
   {
     super(nom, poids);
     this.pattes = nb_pattes;
     this.taille = taille;
   }
 
   public double vitesse()
   {
     return pattes * taille * 3;
   }
 
   public String description()
   {
     return pattes + " pattes, taille = " + taille + " m";
   }
}

static class PokSportif extends PokTer
{
   private int frequence;

   public PokSportif(String nom, double poids, int nb_pattes, double taille, int frequ)
   {
     super(nom, poids, nb_pattes, taille);
     this.frequence = frequ;
   }

   public String description()
   {
     return "Pokemon sportif de fréquence cardiaque " + frequence + "\n"
         \+ super.description();
   }
}

static class PokMaison extends PokTer
 {
   private int htv;
 
   public PokMaison(String nom, double poids, int nb_pattes, double taille, int htv)
   {
     super(nom, poids, nb_pattes, taille);
     this.htv = htv;
   }
 
   public String description()
   {
     return "Pokemon domestique regardant la télé " + htv + 
            " heures par jour\n" + super.description();
   }
 }

static class PokAqua extends Pokemon
 {
   private int nageoires;

   public PokAqua(String nom, double poids, int nageoires)
   {
      super(nom, poids);
      this.nageoires = nageoires;
   }

   public double vitesse()
   {
     return *round*((poids / 25) * nageoires);
   }

   public String description()
   {
     return nageoires + " nageoires";
   }
 }

static class PokMer extends PokAqua
{
   public PokMer(String nom, double poids, int nageoires)
   {
     super(nom, poids, nageoires);
   }

   public String description()
   {
     return "Pokemon de mer\n » + super.description();
   }
}

static class PokCrois extends PokAqua
{
   public PokCrois(String nom, double poids, int nageoires)
   {
     super(nom, poids, nageoires);
   }

   public double vitesse()
   {
     return super.vitesse() / 2.0;
   }

   public String description()
   {
     return "Pokemon de mer\n" + super.description();
   }
}

Exercices de consolidation

C-cons-00

Vous devez développer une petite hiérarchie de classes permettant de représenter des ensembles d’entiers de différentes manières.

L’interface IntSet déclare trois méthodes permettant respectivement d’ajouter un élément dans l’ensemble courant, de tester si un entier appartient l’ensemble courant, et de tester si l’ensemble courant est inclus dans un autre ensemble désigné en paramètre. Cette interface dérive de Iterator<Integer> pour que toutes les classes implémentant cette interface dispose d’itérateurs permettant d’énumérer leurs éléments.

La classe abstraite AintSet permet l’implémentation de la méthode subsetOf qui utilise les méthodes abstraites isIn et iterator.

Quant aux deux classes BoolIntSet et ListIntSet, elles implémentent deux représentations différentes d’un ensemble d’entiers : une représentation par un ArrayList d’entiers et une représentation par tableau de Booléens.

public interface IntSet extends Iterable<Integer>
{
   public void add(int e);
   public boolean isIn(int e);
   public boolean subsetOf(IntSet s);
}

public abstract class AintSet implements IntSet
{
   public boolean subsetOf(IntSet s)
   {
       Iterator<Integer> iter = iterator();
       while(iter.hasNext())
       {
         int e = iter.next();
         if(!s.isIn(e))
         {
             return false;
         }
       }
       return true;
   }
}

public class ListIntSet extends AintSet
{
   private ArrayList<Integer> data;
  
   class IterIntSet implements Iterator<Integer>
   {
     private int cursor;
 
     public IterIntSet(){this.cursor = 0;}
 
     public boolean hasNext()
     {
       if(cursor<data.size()) return true;
       else return false;
     }
 
     public Integer next()
     {
       this.cursor++;
       return data.get(cursor-1);
     }
   }

  // À compléter
}

public ListIntSet() {this.data = new ArrayList<>();}
 
public void add(int e) {this.data.add(e);}

public Iterator<Integer> iterator(){return new IterIntSet();}

public boolean isIn(int e)
{
   for(int x : this.data)
   {
     if( x== e) return true;
   }
   return false;
}

public class BoolIntSet extends AintSet
{
   private boolean[] data;
  
   // Implémenter l'itérateur comme classe membre lui permet
   // l'accès à l'attribut privé data
   class IterIntSet implements Iterator<Integer>
   {
       private int cursor;

       public IterIntSet() {this.cursor = -1;}

       public boolean hasNext()
       {
           cursor++;
           while(cursor<data.length)
           {
               if(data[cursor]) return true;
               else cursor++;
           }
           return false;
       }

       public Integer next() {return cursor;}
   }
 
   public BoolIntSet() {this.data = new boolean[256];}
 
   public void add(int e) {this.data[e] = true;}
 
   public boolean isIn(int e){return this.data[e];}
 
   public Iterator<Integer> iterator(){return new IterIntSet();}
}

Partie B

Classes et objets

Objectif

Être capable d’implémenter une classe comportant des attributs (variable d’instance), des méthodes d’instance, des constructeurs, exploitant des données représentées par des types primitifs, des tableaux, des chaînes, des listes de type ArrayList, et des classes enveloppes (telles que Integer, Double…). Être capable d’utiliser une telle classe en maîtrisant les effets de bord induits par les attributs modifiables. Être capable de réaliser une application utilisant plusieurs classes par composition (sans héritage) et de prévoir le comportement d’un tel programme, y compris les objets et données créés dans la mémoire de l’ordinateur (pile, tas, zone des données statiques).

Prérequis

Partie A

B1 : Exemple introductif

Présentation

Nous allons maintenant aborder la « vraie » programmation orientée objet, c’est à dire la création d’instances de classes, donc d’objets, et l’utilisation de méthodes d’instances pour agir sur ces objets.

Voici un exemple introductif avec une classe Date qui modélise une date constituée d’un jour, d’un mois et d’une année. Java dispose déjà d’une classe Date, mais on peut utiliser un même nom pour des classes différentes, à condition qu’elles soient dans des packages différents.

public class Date
 {
   private int jour;
   private int mois;
   private int annee;

   public Date()
   {
     this.jour=1; this.mois=1; this.annee=1900;
   }

   public Date(int jour, int mois, int annee)
   {
     this.jour=jour; this.mois=mois; this.annee=annee;
   }

   public String toString()
   {
     return this.jour + "/" + this.mois + "/" + this.annee;
   }
 }

Détaillons les différents éléments de cette classe. Voici la déclaration de trois attributs aussi appelés variables d’instance.

private int jour;
private int mois;
private int annee;

Ces trois attributs sont privés. Ils ne sont accessibles que depuis les méthodes de la classe Date. Chaque instance de la classe, c’est-à-dire chaque objet créé d’après cette classe, dispose de ses propres exemplaires de ces attributs.

Ensuite nous avons la définition d’un premier constructeur.

public Date()
 {
   this.jour=1; this.mois=1; this.annee=1900;
 }

Un tel constructeur sans paramètre est appelé constructeur pas défaut. Comme tout constructeur, son rôle est d’initialiser une instance de la classe lors de sa construction lancée par l’opérateur new.

Voici maintenant un deuxième constructeur qui accepte 3 paramètres.

public Date(int jour, int mois, int annee)
 {
   this.jour=jour; this.mois=mois; this.annee=annee;
 }

Comme dans le constructeur par défaut, les attributs initialisés sont préfixés par this, qui est la référence de l’objet en cours de construction. Dans le premier constructeur, ce préfixe est facultatif. Mais ici il permet de distinguer les attributs des paramètres de mêmes noms. Si on écrivait…

public Date(int jour, int mois, int annee)
 {
   jour=jour; mois=mois; annee=annee;
 }

… ce constructeur n’aurait strictement aucun effet sur les attributs de la classe, ni sur autre chose d’ailleurs puis qu’il recopierait le contenu du paramètre jour dans lui-même, et pareillement pour mois et annee.

Nous avons ensuite une méthode d’instance.

public String toString()
 {
   return this.jour + "/" + this.mois + "/" + this.annee;
 }

Cette méthode n’a aucun paramètre et retourne une chaîne de caractère qui décrit l’objet courant, c’est-à-dire l’objet via lequel elle est appelée. Ici, le préfixe this est facultatif, mais il a le mérite de bien mettre en évidence les attributs.

Maintenant que nous avons une classe, nous pouvons l’utiliser pour créer des instances et les utiliser. Voici un exemple simple.

public class Main
 {
   public static void main(String[] args)
   {
     Date d1 = new Date(11,9,2017);
     Date d2 = new Date();
 
     System.out.println(d1.toString());
     System.out.println(d2.toString());
   }
 }

Les deux premières lignes de la méthode main font respectivement appel aux deux constructeurs de la classe Date.

    Date d1 = new Date(11,9,2017);
    Date d2 = new Date();

Les références des objets créés sont placées dans deux variables de méthode. Voici ce qui se passe en mémoire.

Les deux lignes suivantes appellent la méthode toString avec chacune des deux instances et affiche les chaînes retournées.

    System.out.println(d1.toString());
    System.out.println(d2.toString());

Le résultat est l’affichage suivant…

1/9/2017
1/1/1900

Quelques précisions

Constructeur par défaut

Lorsqu’on ne définit aucun constructeur dans une classe, Java crée un constructeur par défaut qui initialise chaque variable d’instance avec une valeur par défaut : 0 pour un entier, 0.0 pour un flottant, null pour une référence… Dès lors qu’on définit un constructeur avec paramètre(s), aucun constructeur par défaut n’est produit de manière automatique. Si on en veut un, il faut le définir. Dans notre exemple, le constructeur par défaut ne sert pas à grand-chose d’autre qu’illustrer le concept.

Destruction d’une instance

Toute instance est détruite automatiquement par la machine virtuelle dès lors qu’aucune variable ne contient sa référence. Le programmeur n’a donc pas à se soucier du recyclage de la mémoire.

Éditer et compiler ses programmes

Dans une application qui contient plusieurs classes, les bytecodes de ces classes sont regroupés dans un fichier ayant l’extension «.jar». On peut les produire en ligne de commande, via une console ou avec un script, mais Il existe des logiciels appelés IDE qui facilitent l’édition, la compilation et la mise au point des programmes, comme par exemple : NetBeans, Eclipse, IntelliJ IDEA, BlueJ (à vocation pédagogique !)… Je vous conseille d’en utiliser un.

Exercices de découverte

B-dec-10

Quels éléments syntaxiques (notation) permettent de savoir si une variable est une variable de méthode, une variable d’instance (aussi appelée attribut) ou une variable de classe dans un code Java ?

B-dec-11

Quels éléments syntaxiques (notation) permettent de savoir si une méthode est une méthode de classe ou une méthode d’instance ?

B-dec-12

On considère la classe Date définie précédemment et la classe Main suivante.

public class Main
{
    public static void main(String[] args)
    {
        Date d = new Date();
        d.annee = 1905;
        System.out.println(d.toString());
    }
}

Il y a une erreur. Trouvez là sans utiliser d’IDE ni de compilateur Java.

B-dec-13

Ajoutez dans la classe Date un constructeur acceptant un seul paramètre de type int et qui permet de créer une instance de Date représentant le premier janvier de l’année passée en paramètre.

public Date(int annee)
{
    this.jour = 1; this.mois = 1; this.annee = annee;
}

B2 : Accesseurs et bonnes pratiques

A l’instar de ce qui est fait dans notre classe Date, le fait de rendre private les variables d’instance est considéré comme une bonne pratique en programmation objet. Plutôt que de permettre aux « utilisateurs » de la classe d’accéder directement à ces variables, on préfère mettre à sa disposition des méthodes publiques appelées accesseurs.

Voici les accesseurs de la classe Date qui ont été produits automatiquement par mon IDE.

 int getJour()
 {
   return jour;
 }
 
 public int getAnnee()
 {
   return annee;
 }
 
 public int getMois()
 {
   return mois;
 }
 
 public void setAnnee(int annee)
 {
   this.annee = annee;
 }
 
 public void setMois(int mois)
 {
   this.mois = mois;
 }
 
 public void setJour(int jour)
 {
   this.jour = jour;
 }

Avec cette approche, on pourrait changer la représentation en mémoire d’une date, par exemple en utilisant un seul entier qui combinerait le jour, le mois et l’année avec une formule du genre (d = année x 10000 + mois x 100 + jours) sans avoir à changer quoi que ce soit dans les méthodes utilisant la classe Date. Il suffirait de modifier le code des accesseurs pour que tout fonctionne correctement.

Par exemple getMois() retournerait (d/100)%10000 et setMois(int m) effectuerait l’opération d = getAnnee()*10000 + m*100 + getJour().

Exercices de découverte

B-dec-20

Réalisez une méthode d’accès setDate permettant de modifier simultanément le jour, le mois et l’année de l’instance courante de la classe Date. Cette méthode doit avoir trois paramètre nommés jour, mois et annee.

public void setDate(int jour, int mois, int annee)
 {
   this.jour = jour; this.mois = mois; this.annee = annee;
 }

B-dec-21

Donnez les lignes de code permettant de créer une instance de Date avec le constructeur par défaut de la classe Date, puis de modifier cette instance à l’aide de la méthode setDate de façon à ce que la date représentée soit le 12/10/2005.

Date d = new Date();
d.setDate(12, 10, 2005);

B3 : Composition de classes

On parle de composition de classes lorsqu’une classe a des attributs ayant pour types d’autres classes. Par exemple on peut définir une classe Periode dont les attributs désignent deux instances de Date et une instance de String.

public class Periode
 {
   private Date debut;
   private Date fin;
   private String nom;
 

  // À compléter
 }

Chacun des deux attributs debut et fin peut contenir une référence d’une instance de Date. Ces instances ont vocation à représenter le début et la fin d’une période constituée d’une ou plusieurs journées. Le troisième attribut est de type String. Il a vocation à contenir la référence d’une instance de String, c’est-à-dire une chaîne de caractères qui donne un nom à la période représentée.

On peut ajouter dans notre classe le constructeur suivant…

public Periode(Date deb, Date fin, String nom)
 {
   this.debut = deb;
   this.fin = fin;
   this.nom = nom;
 }

…puis la méthode toString suivante…

public String toString()
 {
   return "[ " + nom + " " + debut + " - " + fin + " ]";
 }

…et une méthode permettant de tester la classe…

public static void test()
 {
   Date d1 = new Date(4, 9, 2018);
   Date d2 = new Date(19, 9, 2018);
   Periode p = new Periode(d1, d2, "Vacances");
   System.out.println(p.toString());
 }

Notez bien que test est une méthode de classe qui ne nécessite pas d’objet de type Periode pour être appelée, et qui créée elle-même un objet de ce type. Pour appeler cette méthode test, par exemple depuis une méthode main, on écrit simplement…

Periode.test();

L’affichage obtenu est…

[ Vacances 4/9/2018 - 19/9/2018 ]

Voici ce qui se passe dans la mémoire…

Exercices de découverte

B-dec-30

On considère deux variantes d’un constructeur de la classe Periode. En pratique, il faudra en choisir une car on ne peut implémenter dans une même classe deux constructeurs ayant exactement les mêmes paramètres.

/// Version 1
public Periode(Periode m)
{
    this.debut = m.debut;
    this.fin = m.fin;
    this.nom = m.nom;
}

/// Version 2
public Periode(Periode m)
{
    this.debut = new Date(m.debut.getJour(), m.debut.getMois(), m.debut.getAnnee());
    this.fin = new Date(m.fin.getJour(), m.fin.getMois(), m.fin.getAnnee());
    this.nom = m.nom;
}

On considère les lignes de code suivantes.

Date d1 = new Date(4, 9, 2018);
Date d2 = new Date(19, 9, 2018);
Periode p = new Periode(d1, d2, "Vacances");
Periode q = new Periode(p);
d1.setJour(5);
System.out.println(p.toString());
System.out.println(q.toString());

Donnez les affichages obtenus dans le cas où la version 1 du constructeur à 1 paramètre est utilisée et dans le cas où la version 2 est utilisée.

[Vacances 5/9/2018 - 19/9/2018]
[Vacances 5/9/2018 - 19/9/2018]

[Vacances 5/9/2018 - 19/9/2018]
[Vacances 4/9/2018 - 19/9/2018]

B4 : Composition par tableaux

Dans cet exemple, nous créons une classe Memo qui contient plusieurs dates stockées dans un tableau. Cette classe a surtout une vocation pédagogique : montrer comment gérer un tableau référencé par une variable d’instance et comment les instances de la classe concernée sont représentées en mémoire.

public class Memo
 {
   private Date[] tab;
   private int nDates;


   // À compléter
 }

Une instance de cette classe représente une liste de dates, chacune représentée par une instance de Date. Un tableau est utilisé à cette fin, dans un but plus pédagogique que pratique. Examinons d’abord le constructeur de la classe…

public Memo(int n)
 {
   tab = new Date[n]; nDates=0;
 }

Ce constructeur accepte en paramètre la capacité du mémo, c’est-à-dire le nombre maximum de dates qu’il va pouvoir contenir. Cela correspond à la taille du tableau désigné par l’attribut tab. L’attribut nDate indique le nombre de dates effectivement stockées dans le mémo. Cet attribut est donc initialisé à 0, puisqu’à sa création le mémo est vide. Incidemment, chaque cellule du tableau créé contient la référence null.

Pour ajouter une date à une instance de Memo, on adjoint à la classe une méthode add définie de la manière suivante…

public void add(Date d)
{
   if(nDates >= tab.length)
   {
     System.out.println("Tableau plein !");
   }
   else
   {
     tab[nDates] = d; nDates++;
   }
}

On passe en argument à add la référence d’une instance de Date à ajouter au mémo. Mais comme le tableau de stockage a une taille limitée, déterminée à sa création, on vérifie qu’il reste encore de la place en comparant le nombre de dates enregistrées avec la longueur (tab.length) du tableau de stockage.

Dans le cas où il reste de la place, la référence de l’instance de Date à ajouter est placée dans la première cellule libre du tableau, qui a pour indice la valeur de l’attribut nDate. Cette valeur est ensuite augmentée de 1 pour refléter le nouveau nombre de dates stockées dans le mémo.

Ajoutons à notre classe Memo une méthode d’affichage…

public void print()
{
   for(int i=0; i<nDates; i++)
   {
     System.out.println(tab[i].toString());
   }
}

Puis testons ce que nous avons programmé avec la méthode suivante, qui peut se trouver dans la classe Memo ou ailleurs.

public static void test()
{
   Memo m = new Memo(5);
   m.add(new Date(12,10,2017));
   m.add(new Date(14,12,2017));
   m.print();
}

Voici la situation en mémoire à la fin de l’exécution de cette méthode.

Exercices de découverte

B-dec-40

Réalisez une méthode d’instance read de la classe Memo permettant de récupérer la référence de la date située à une position donnée en argument dans l’instance courante de Memo. Si m désigne une instance de Memoet i est un entier positif ou nul alors l’appel m.read(i) doit retourner…

• la référence de la date située en position i dans le mémo s’il contient au moins i+1 dates,
• la valeur null dans le cas contraire.

Les positions sont numérotées à partir de 0 comme il est d’usage en programmation.

public Date read(int i)
{
    if(i >= nDates) return null;
    else return this.tab[i];
}

B-dec-41

Réalisez un constructeur de la classe Memo permettant de créer un mémo contenant exactement deux dates.

public Memo(Date d1, Date d2)
{
    // À compléter
}

public Memo(Date d1, Date d2)
{
    tab = new Date[2]; nDates=2;
    tab[0] = d1;
    tab[1] = d2;
}

B5 : La classe standard ArrayList

Comme nous l’avons vu dans l’exemple de la classe memo, l’utilisation d’un tableau comporte une limitation assez embêtante : sa taille doit être fixée une fois pour toute lors de sa création. Pour éviter ce problème, on peut utiliser une classe nommée ArrayList permettant de faire des listes extensibles.

Cette classe est générique, dans le sens où elle peut être paramétrée par un type. ArrayList<T> représente une liste de références d’instances de T. Une telle liste est plus souple d’utilisation qu’un tableau car sa capacité n’est pas limitée (du moins elle n’est limitée que par les ressources mémoire allouées à la machine virtuelle java).

Exemple introductif

Examinons un exemple. Je veux créer une liste de dates (techniquement, d’instances de la classe Date). J’écris simplement…

ArrayList<Date> t = new ArrayList<>();

Une liste vide est créée dans le tas et sa référence est placée dans w. Cette liste à une capacité initiale de 10 emplacements (valeur par défaut allouée par le compilateur), mais cette capacité sera automatiquement augmentée si on y place plus de 10 éléments.

J’ajoute deux dates à ma liste…

t.add(new Date(1,1,1901));
t.add(new Date(2,2,1902));

Examinons ce qui s’est passé dans la mémoire.

La représentation d’une instance d’ArrayList a été simplifiée (tout comme celle des instances de String que nous avons eu l’occasion de voir précédemment). En réalité, une instance d’ArrayList comporte plusieurs attributs dont un désigne un tableau qui pourra être remplacé par un autre de taille différente à chaque fois que c’est nécessaire. Mais puisque cette classe a été créée pour nous simplifier la vie, autant en simplifier la représentation.

Précisions sur la classe ArrayList<T>

L’essentiel à savoir concernant la classe ArrayList<T>, c’est que :

• toute instance w contient w.size() éléments,
• tout élément est soit une référence de type T, soit null.
• la position de chaque élément est désignée par un indice,
• le premier élément a pour indice 0.

Voici quelques méthodes de la classe ArrayList. Il y en a beaucoup d’autres, que vous pourrez trouver dans la documentation officielle à l’URL https://docs.oracle.com/javase/8/docs/api/

• int size() : retourne le nombre d’éléments stockés.
• boolean add(T e) : ajoute l’élément e en fin de liste. La valeur de retour est toujours true. Elle peut être ignorée.
• void add(int i, T e) : ajoute l’élément e en position i et décale (si applicable) les éléments suivants d’une position. La plus grande valeur autorisée pour i est size().
• T get(int i) : retourne l’élément situé en position i. La plus grande valeur autorisée pour i est size()-1.
• T remove(int i) : retire l’élément situé en position i et le retourne. Les éléments suivants (si applicable) sont décalés d’une position pour boucher le « trou ».
• int indexOf(Object e) : retourne l’indice de la position de la première occurrence de l’objet e dans la liste, ou -1 si cet objet n’est pas dans la liste. (Toute référence a le type Object par héritage.)
• T set(int i, T e) : remplace l’élément situé en position i par e.
• void clear(int i) : retire tous les éléments de la liste.

Un exemple d’utilisation

Soit une classe Personne qui représente une personne et dispose d’une méthode toString permettant d’afficher le nom et le prénom de la personne représentée.

public class Personne
{
  private String nom;
  private String prenom;
  
  public Personne(String nom, String prenom)
  {
    this.nom = nom; this.prenom = prenom;
  }
  
  publis String toString()
  {
    return nom + " " + prenom;
  }
}

Voici une classe Document dont chaque instance représente un document ayant un nom et des auteurs. Voici les attributs de la classe Document.

public class Document
 {
   private String nom;
   private ArrayList<Personne> auteurs;

   // À compléter
}

Pour initialiser ces attributs, il nous faut un constructeur. En voici un…

public Document(String n, Personne[] a)
{
   this.nom=n;
   auteurs = new ArrayList<Personne>();
   for(int i=0; i<a.length; i++)
   {
     auteurs.add(a[i]);
   }
}

Il permet de créer un document en une seule fois, à partir des données reçues en argument, à savoir la référence n d’une chaîne de caractères et un tableau a de références d’instances de la classe Personne. Cela suppose qu’au moment d’utiliser ce constructeur, on dispose de ces données qui ont été préalablement créées.

La première ligne…

  this.nom=n;

…place juste dans l’attribut nom la référence d’instance de String contenue dans n.

La ligne suivante…

  auteurs = new ArrayList<Personne>();

… appelle le constructeur par défaut de ArrayList<Personne> pour créer une liste vide à laquelle on pourra ajouter autant des références à des instances de Personne que désiré. L’opérateur new retourne la référence de la liste créée, qui est placée dans l’attribut auteurs.

Ensuite, une boucle for…

  for(int i=0; i<a.length; i++)
   {
     auteurs.add(a[i]);
   }

… parcourt le tableau passé en argument et ajoute chacune des références qu’il contient à la liste des auteurs du document en cours de construction.

Nous allons ajouter une méthode permettant de récupérer le nombre d’auteurs d’un document…

public int nbAuteurs()
 {
   return auteurs.size();
 }

… qui fait bêtement appel à une méthode de la classe ArrayList retournant le nombre d’éléments de l’instance d’ArrayList concernée.

La méthode suivante, toString, permet de créer une chaîne de caractères donnant une description de l’instance courante de Document.

public String toString()
{
   String da = "";
   for (int i = 0; i < nbAuteurs(); i++)
   {
     da = da + auteurs.get(i) + " ";
   }
   return nom + "\nAuteur(s) : " + da;
}

Notez au passage le moyen utilisé pour récupérer les informations sur les auteurs mérite quelques explications. La ligne…

da = da + auteurs.get(i) + " ";

…récupère la référence désignant l’élément situé en position i dans la liste. Jusque-là rien d’étonnant. Mais ensuite cet élément, qui est de type Personne (entendez par là qu’il s’agit d’une référence d’une instance de Personne), est ajouté à la chaîne en cours de construction grâce à l’opérateur +. Mais attendez, une instance de Personne n’est pas une chaîne de caractère ! Comment Java fait-il pour ajouter une instance de Personne à une chaine de caractères ?

En réalité, dans un tel contexte java remplace implicitement auteurs.get(i) par auteurs.get(i).toString(). C’est une sorte de notation raccourcie qui permet d’ajouter un objet à une chaîne, et qui fonctionne bien si l’objet en question dispose d’une méthode toString correctement programmée. Dans le cas contraire, c’est une chaîne représentant la référence de l’objet concerné qui est ajoutée à la chaîne.

Bon, notre classe Document n’offre pas encore beaucoup de possibilités, mais elle permet de créer et d’afficher des objets de type Document, à condition toutefois de programmer une classe Personne disposant à minima d’un constructeur et d’une méthode toString. Une personne pourrait par exemple être décrite par deux attributs de type String représentant son nom et son prénom.

La création d’une instance de Document peut alors prendre la forme suivante…

Personne auteur1 = new Personne("Brian","Kernighan");
Personne auteur2 = new Personne("Dennis","Ritchie");
Document doc = new Document("Le langage C",new Personne[]{auteur1, auteur2});

La syntaxe…

Personne[]{auteur1, auteur2}

…permet de créer un tableau d’instances de Personne et de l’initialiser en même temps.

Exercices de découverte

B-dec-50

Ajoutez à la classe Document un constructeur qui crée une instance représentant un document sans auteur (la liste d’auteurs est vide), mais ayant un nom.

public Document(String nom)
{
    // À compléter
}

public Document(String nom)
{
    this.nom = nom;
    this.auteurs = new ArrayList<Personne>();
}   

B-dec-51

Ajoutez à la classe Document une méthode addAuteur permettant d’ajouter un auteur au document courant.

public void addAuteur(Personne p)
{
     // À compléter
}

public void addAuteur(Personne p)
{
     this.auteurs.add(p);
}

B-dec-52

Ajoutez à la classe Document une autre méthode addAuteur permettant d’ajouter un auteur au document courant.

public void addAuteur(String nom, String Prenom)
{
     // À compléter
}

public void addAuteur(String nom, String Prenom)
{
     this.auteurs.add(new Personne(nom, prenom));
}

Exercices d’assimilation

B-ass-00

Réalisez une classe Compteur qui comporte un attribut (variable d’instance) cpt de type int, un constructeur par défaut qui initialise cette variable à 0, une méthode d’instance plusUn qui incrémente cette variable, et une méthode d’instance lecture qui retourne la valeur de la variable cpt.

Réalisez une méthode main située dans une classe Main qui crée une instance de Compteur, réalise trois incrémentations de cette instance et affiche sa valeur (i.e., la valeur de sa variable cpt).

public class Compteur
{
    private int cpt;

    public Compteur()
    {
        // À compléter
    }

    public void pluUn()
    {
        // À compléter
    }

    public int lecture()
    {
        // À compléter
    }

    public static void main(String[] args)
    {
        Compteur c = new Compteur();
        // À compléter
    }
}

public class Compteur
{
    private int cpt;

    public Compteur()
    {
        cpt = 0;
    }

    public void pluUn()
    {
        cpt = cpt + 1;
    }

    public int lecture()
    {
        return cpt;
    }

    public static void main(String[] args)
    {
        Compteur c = new Compteur();

        c.pluUn(); c.pluUn();; c.pluUn();
        System.out.println(c.lecture());
    }
}

B-ass-01

Réécrivez à la classe Memo (en vous limitant aux attributs, au constructeur à un paramètre et aux méthodes add et print) en remplaçant le tableau par un ArrayList.

public class MemoExt
{
    private ArrayList<Date> tab;

    public MemoExt()
    {
        tab = new // À compléter
    }

    public void add(Date d)
    {
        // À compléter
    }

    public void print()
    {
        for(int i=0; i<tab.size(); i++)
        {
            // À compléter
        }
    }
}

public class MemoExt
{
    private ArrayList<Date> tab;

    public MemoExt()
    {
        tab = new ArrayList<>();
    }

    public void add(Date d)
    {
        tab.add(d);
    }

    public void print()
    {
        for(int i=0; i<tab.size(); i++)
        {
            System.out.println(tab.get(i).toString());
        }
    }
}

B-ass-02

Réalisez une classe Point qui représente les coordonnées (x,y) d’un point dans un repère cartésien à 2 dimensions. Les coordonnées x et y sont représentées par des nombres en virgule flottantes de type double. La classe Point dispose d’un constructeur permettant de créer un point à partir de ses coordonnées, ainsi que d’une méthode toString, et deux accesseurs getX et getY permettant de récupérer les coordonnées. Elle possède aussi une méthode d’instance public double dist(Point p) qui calcule et retourne la distance entre le point courant et le point désigné par le paramètre p.

La méthode de classe prédéfinie double Math.sqrt(double x), qui retourne la racine carrée de x, vous sera utile.

public class Point
{
    private double x;
    private double y;

    public Point(double x, double y)
    {
        // À compléter
    }

    public double getX() {return x;}

    public double getY() {return y;}

    public String toString()
    {
        // À compléter
    }

    public double dist(Point p)
    {
        double dx = // À compléter
        double dy = // À compléter
        return Math.sqrt(dx*dx + dy*dy);
    }
}

public class Point
{
    private double x; private double y;

    public Point(double x, double y)
    {
        this.x = x; this.y = y;
    }

    public double getX() {return x;}

    public double getY() {return y;}

    public String toString()
    {
        return "(" + x + "," + y + ")";
    }

    public double dist(Point p)
    {
        double dx = this.x - p.x;
        double dy = this.y - p.y;
        return Math.sqrt(dx*dx + dy*dy);
    }
}

B-ass-03

Réalisez une classe Polygone qui représente un polygone sous la forme d’une liste de points. Cette classe dispose d’un constructeur à trois paramètres de type Point qui produit un triangle et un autre à 4 paramètres de type Point qui produit un quadrilatère. Elle dispose également d’une méthode d’instance perimetre qui retourne la somme des longueurs des côtés du polygone courant et d’une méthode toString qui produit une chaîne indiquant juste le nombre de cotés et le périmètre du polygone courant.

public class Polygone
{
    private ArrayList<Point>  liste;

    public Polygone()
    {
        // À compléter
    }

    public Polygone(Point a, Point b, Point c)
    {
        this(); // appelle le constructeur par défaut
        // À compléter
    }

    public Polygone(Point a, Point b, Point c, Point d)
    {
        this(a, b, c); // appelle le contsructeur de triangle
        // À compléter
    }

    public double perimetre()
    {
        // À compléter
    }

    public String toString()
    {
        // À compléter
    }
}

public Polygone()
{
    liste = new ArrayList<>();
}

public Polygone(Point a, Point b, Point c)
{
    this();
    liste.add(a); liste.add(b);  liste.add(c);
}

public Polygone(Point a, Point b, Point c, Point d)
{
    this(a, b, c); liste.add(d);
}

public double perimetre()
{
    double sum = 0.0;
    for(int i=1; i<liste.size(); i++)
    {
        sum = sum + // À compléter
    }
    sum = sum + // À compléter;
    return sum;
}

public class Polygone
{
    private ArrayList<Point>  liste;

    // Constructeurs (voir indice 1)

    public double perimetre()
    {
        double sum = 0.0;
        for(int i=1; i<liste.size(); i++)
        {
            sum = sum + liste.get(i-1).dist(liste.get(i));
        }
        sum = sum + liste.get(0).dist(liste.get(liste.size()-1));
        return sum;
    }

    public String toString()
    {
        String s = "Polygone de " + liste.size() + " sommets";
        return s + " de périmètre " + perimetre();
    }
}

B-ass-04

Cet exercice fait suite à l’exercice précédent. Vous devez ajouter à la classe Polygone une méthode de classe (static) triangle qui crée et retourne un polygone à trois sommets dont les coordonnées lui sont passées en argument. cette méthode aura donc 6 paramètres de type double.

Vous devez également réaliser une méthode main qui crée une instance de Polygone représentant un triangle en appelant la méthode triangle et qui affiche à l’écran la description de ce triangle obtenue par un appel de la méthode toString de la classe Polygone.

public static Polygone triangle(double x1, double y1, double x2, double y2, double x3, double y3)
{
    Point a = // À compléter
    Point b = // À compléter
    Point c = // À compléter
    return new // À compléter
}

public static void main(String[] args)
{
    Polygone p = // À compléter
    System.out.println(p);
}

public static Polygone triangle(double x1, double y1, double x2, double y2, double x3, double y3)
{
    Point a = new Point(x1, y1);
    Point b = new Point(x2, y2);
    Point c = new Point(x3, y3);
    return new Polygone(a, b, c);
}

public static void main(String[] args)
{
    Polygone p = Polygone.triangle(0.0, 0.0, 1.0, 0.0, 0.0, 1.0);
    System.out.println(p);
}

B6 : Objets modifiables et non modifiables

Nous revenons ici sur une notion que nous avons déjà abordée sans la nommer dans la partie A. On l’appelle effet de bord. Prenons un exemple avec la classe Date.

public static void effetDeBord()
 {
   Date d1 = new Date(11,11,1918);
   Date d2 = d1;
   d2.setAnnee(1919);
   System.out.println(d1);
 }

On définit deux variables d1 et d2. On place dans d2 le contenu de d1, puis on change l’année de d2 et on affiche d1. Résultat…

11/11/1919

La modification de la date désignée par d2 a changé aussi celle désignée par d1. Ce n’est pas étonnant quand on regarde la configuration des données en mémoire.

Les deux variables de méthode d1 et d2 contiennent la même référence, qui désigne la même instance de Date. Pour éviter un tel effet de bord, on peut par exemple doter la classe Date d’un constructeur en copie ou d’une méthode de clonage. Concentrons-nous sur la première solution.

public Date(Date d)
 {
   this.jour = d.jour;
   this.mois = d.mois;
   this.annee = d.annee;
 }

Voici comment utiliser ce constructeur pour dupliquer une instance de Date.

public static void pasDeffetDeBord()
 {
   Date d1 = new Date(11,11,1918);
   Date d2 = new Date(d1);
   d2.setAnnee(1919);
   System.out.println(d1);
 }

Cette fois-ci, la modification de la date désignée par d2 n’a pas d’effet sur celle désignées par d1. Voici la nouvelle configuration en mémoire.

Une autre manière de permettre la duplication d’instance de Date, applicable à toute classe, comme la technique du constructeur en copie, consiste à ajouter à la classe Date une méthode de clonage.

public Date clone()
 {
   return new Date(this.jour, this.mois, this.annee);
 }

Voici un exemple d’utilisation.

public static void pasDeffetDeBord2()
 {
   Date d1 = new Date(11,11,1918);
   Date d2 = d1.clone();
   d2.setAnnee(1919);
   System.out.println(d1);
}

Exercices de découverte

B-dec-60

Réalisez une méthode d’instance de la classe Date retournant la date située une année plus tard que la date courante, sans modifier la date courante.

    public Date plusUnAn()
    {
        Date cpy = new // À compléter
        // À compléter
        return cpy;
    }

    public Date plusUnAn()
    {
        Date cpy = new Date(this);
        cpy.setAnnee(getAnnee()+1);
        return cpy;
    }

    public Date plusUnAn()
    {
        Date cpy = new Date(this.getJour(), this.getMois(), this.getAnnee() + 1);
        return cpy;
    }

B-dec-61

Réalisez une variante de la première variante de la méthode d’instance plusUnAn qui utilise la méthode de clonage de la classe Date au lieu de son constructeur en copie.

    public Date plusUnAn()
    {
        Date cpy = clone(); // ou this.clone()
        cpy.setAnnee(getAnnee()+1);
        return cpy;
    }

B7 : Les constantes

Le mot final rend une variable non modifiable et la transforme donc en constante. Sauf que… Examinons un exemple.

On ne peut pas modifier les références représentées par jours et Armistice, mais cela n’empêche pas de modifier les objets désignés par ces références. Par exemple on peut écrire…

jours[6]="sun";
Armistice.setAnnee(1919);

Ce qui modifiera les objets concernés.

Exercices de découverte

B-dec-70

Pour afficher le nombre $\pi$, on peut écrire :

System.out.println(Math.PI);

Donnez la déclaration de la variable d’instance PI dans le classe Math.

public static final double PI = 3.141592653589793;

B8 : Les classes enveloppes

En java, les types primitifs ne sont pas des objets. Ils constituent une sorte d’entorse au paradigme de programmation objet. Mais il existe des classes enveloppes qui permettent d’encapsuler des données de types primitifs dans des objets : Integer, Double, Boolean… Ces types enveloppe peuvent être utiles pour utiliser des données primitives dans de situation où seuls des objets sont utilisables, comme dans des ArrayList. Voici un exemple.

Exercices de découverte

B-dec-80

Complétez cette illustration de la configuration en mémoire à l’issue de l’exécution des 4 premières lignes de code de l’exemple précédent.

B9 : Objets non modifiables

Les objets n’ayant que des attributs privés et ne disposant pas de méthodes permettant de modifier leurs attributs (ni les données accessibles par ces attributs) sont dits non modifiables, tout comme les classes qui définissent de tels objets.

Par exemple, les classes enveloppes sont non modifiables, ainsi que la classe String. L’intérêt de telles classes c’est qu’elles empêchent les effets de bord, mais en contrepartie d’une perte d’efficacité. On peut le voir en considérant deux classes permettant de représenter des chaînes : String, qui est non modifiable, et StringBuffer, qui est modifiable.

La méthode de classe suivante…

public static String makeString1(String s, int n)
 {
   String r = "";
   for(int i=0; i<n; i++)
   {
     r = r + s;
   }
   return r;
 }

…permet de construire une chaîne par n concaténations successives d’une chaîne s. Par exemple…

System.out.println(makeString1("abcdefgh",10));

… affiche…

abcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefghabcdefgh

Mais cette méthode n’est pas très efficace. Pour fabriquer la chaîne retournée, cette méthode crée successivement n nouvelles chaînes intermédiaires qui sont ensuite recyclées par le ramasse-miettes de la machine virtuelle. En effet, chaque concaténation réalisée par l’opérateur + ne modifie pas une chaîne existante (puisque les chaînes sont des objets non modifiables) mais en crée une nouvelle.

On peut réaliser la même chose en utilisant la classe modifiable StringBuffer qui dispose d’une méthode append permettant d’ajouter une chaîne à la fin de la chaîne courante sans en recréer une nouvelle.

public static String makeString2(String s, int n)
 {
   StringBuffer r = new StringBuffer();
   for(int i=0; i<n; i++)
   {
     r.append(s);
   }
   return r.toString();
 }

Lors de la création d’une instance de StringBuffer, une certaine ressource de mémoire est réservée pour le stockage de la chaîne courante. Cette quantité de mémoire est augmentée en fonction des besoins.

Exercices de découverte

B-dec-90

À quoi peut-on reconnaître une classe non modifiable en regardant son code ?

Exercices d’assimilation

B-ass-50

Réalisez un constructeur en copie pour la classe Memo (en version ArrayList comme demandé par l’exercice 2). Ce constructeur doit accepter en paramètre une instance de Memo déjà créée et faire en sorte que l’instance construite soit identique, mais que toute modification de la copie créée (ajout ou modification d’une date) n’affecte pas l’original et réciproquement.

public Memo(Memo m)
{
    this(); // Pour créer la liste vide
    for(int i=0; i<tab.size(); i++)
    {
        tab.add(// À compléter);
    }
}

public Memo(Memo m)
{
    this();
    for(int i=0; i<tab.size(); i++)
    {
        tab.add( new Date(// À compléter) );
    }
}

public Memo(Memo m)
{
    this();
    for(int i=0; i<tab.size(); i++)
    {
        tab.add( new Date(m.tab.get(i)) );
    }
}

public Memo(Memo m)
{
    this();
    for(Date e : tab)
    {
        tab.add( new Date(e) );
    }
}

B-ass-51

Ajoutez à la classe Polygone une méthode…

public Polygone ext(Point p)

…qui produit un nouveau polygone constitué des points du polygone courant plus le point désigné par le paramètre p. L’ancien et le nouveau polygone doivent exister indépendamment l’un de l’autre. Pour rendre le code plus lisible, vous devrez définir un constructeur en copie de la classe Polygone, qui doit appeler le constructeur par défaut de cette classe. Notez que la classe Point n’est pas modifiable.

public Polygone(Polygone m)
{
    this();
    for(Point p : m.liste)
    {
        liste.add(p);
    }
}

// Constructeur en copie donné dans l'indice 1

public Polygone ext(Point p)
{
    Polygone poly = new Polygone(this);
    poly.liste.add(p);
    return poly;
}

Exercices d’approfondissement

B-cons-00

Vous devez développer un programme permettant de simuler un système d’offres par soumissions cachetées pour l’achat d’objets identiques. Il y a N objets en vente. Il peut y avoir plus (ou moins, ou autant) d’acheteurs intéressés que d’objets en vente. Chaque acheteur peut faire une ou plusieurs offres qui ne sont pas connues par les autres acheteurs. Les N meilleures offres seront retenues.

Chaque offre est représentée par une instance de la classe Offre suivante.

public class Offre
{
    public int id;
    public double montant;

    public Offre(int id, double montant)
    {
        this.id = id; this.montant = montant;
    }

    public int getId() {return id;}

    public double getMontant() {return montant;}

    public String toString()
    {
        return "[ " + id + " : " + montant + "]";
    }
}

Les offres sont placées dans une instance de la classe PrioFile, que vous devez implémenter. Une telle instance est appelée file de priorité. Elle contient une liste d’offres. Pour créer une file de priorité, on écrit…

PrioFile file = new PrioFile(n);

…où nest le nombre d’objets en vente. La file de priorité créée comportera au plus n offres, chacune représentée par une instance de la classe Offre. Tant que la file contient moins de n offres, chaque nouvelle offre y est automatiquement ajoutée. Au delà, quand une nouvelle offre est proposée, elle n’est ajoutée que si son montant dépasse celui de l’offre la plus récente parmi celles ayant le plus petit montant.

Pour soumettre une offre, on écrit…

file.soumission(id, montant);

…où id est l’identifiant d’une acheteur potentiel et montant est le montant proposé.

La classe PrioFile dispose d’une méthode toString qui affiche la liste complète des offres retenues.

Partie A

Programmation procédurale en Java

Objectif

Savoir réaliser une application simple utilisant uniquement des méthodes statiques, des tableaux, des types scalaires, et des chaînes de caractères.

Prérequis

Une première expérience, même limitée, en programmation procédurale ou objet.

A1 : Un programme de découverte

Présentation

public class Decouverte
{
    public static void main(String[] args)
    {
        System.out.println("Bonjour");
    }
}

Tout programme est constitué de blocs qui s’imbriquent et / ou se succèdent. Ici nous avons deux blocs :

• La classe Decouvertedont le code source doit être placé dans un fichier nommé Decouverte.java. Pour l’instant, nous pouvons voir une classe comme un un bloc contenant des méthodes et des variables. Les variables contiennent des données et les méthodes réalisent des traitements.
• La méthode main est le point de départ de l’exécution de tout programme java.

Pour exécuter ce programme, vous pouvez utiliser un IDE (environnement intégré de développement) tel que NetBeans, IntelliJ IDEA, Eclipse… Mais vous devez aussi maîtriser la compilation et l’exécution d’un programme Java via une console. Cette démarche comporte en trois étapes.

1. Édition du programme avec l’éditeur de code source de votre choix.
2. Compilation du fichier source avec la ligne de commande javac Decouverte.java. Cela suppose qu’un environnement de développement appelé Java SDK soit installé sur votre machine et que les variables d’environnement soit configurées de manière à ce que l’exécutable javac, c’est à dire le compilateur java, soit accessible. Le résultat de la compilation est un fichier Decouverte.class.
3. Exécution du fichier résultant de la compilation par la ligne de commande java Decouverte.

Plusieurs mots-clés interviennent dans la définition de la méthode main.

public static void main(String[] args)
{
    ...
}

• public : Toutes les méthodes du badge A seront public. Nous introduirons plus tard d’autres options, à partir de la partie B.
• static : Toutes les méthodes de la partie A seront static. De telles méthodes sont aussi appelées méthodes de classe. Nous introduirons d’autres sortes de méthodes dans la partie B.
• void : Signifie que la méthode main ne retourne rien.
• main : La méthode principale d’un programme java porte toujours ce nom, tout comme elle est toujours public, static, et a toujours un paramètre de type String[].
• Le paramètre String[] args peut permettre à la méthode main de prendre en compte des arguments passés par la ligne de commande lors de l’appel du programme depuis la console. Dans notre exemple, cette possibilité n’est pas exploitée.

Exercices de découverte

A-dec-10

Répondez aux questions suivantes :

1. Quelle est la première méthode exécutée par un programme Java ?
2. Que retourne la méthode main?
3. Quel est le rôle de la méthode System.out.println?
4. Qu’est-ce que le SDK de Java ?
5. Quel est le nom du compilateur java ?

A2 : Un programme qui compte

Présentation

Voici notre deuxième programme. Autant que possible, testez sur machine les différents programmes qui seront présentés et tentez quelques modifications pour vérifier que vous êtes capable de prévoir leur effets. Le code des deux méthodes suivantes doit être placé dans la classe Decouverte.

    public static void compte(int k)
    {
        for(int i=0; i<k; i++)
        {
            System.out.println(i);
        }
    }

    public static void main(String[] args)
    {
        compte(10);
    }

La méthode main appelle la méthode compte en lui passant en argument la valeur 10. La méthode compte reçoit cette valeur dans la variable k qui est le paramètre de la méthode compte. Lors du début de l’exécution de compte, la variable k est initialisée avec la valeur 10.

Il y a dans le code de la méthode compte une autre variable nommée i, à laquelle l’instruction for donne successivement les valeurs de 0 à k. L’exécution de la méthode a donc pour effet l’affichage des valeurs 0 à 9, avec un passage à la ligne entre chaque valeur.

La méthode compte peut être réécrite en utilisant l’instruction while au lieu de for.

    public static void compte(int k)
    {
        int i = 0;
        while(i<k)
        {
            System.out.println(i); 
            i++;
        }
    }

Les variables k et i sont appelée variables de méthodes ou variables automatiques. Elles n’existent que pendant l’exécution de la méthode dans laquelle elle sont déclarée et seul cette méthode peut les utiliser. La variable k a un rôle particulier puisque c’est un paramètre de la méthode. Sa valeur initiale est déterminée lors de l’appel de la méthode.

Exercices de découverte

A-dec-20

Si on remplace System.out.println(i) par System.out.print(i + " ") dans la méthode compte, on obtient l’affichage 0 1 2 3 … k (les valeurs sont séparées par des espaces. Modifiez le programme pour obtenir l’affichage 0, 1, 2, 3, …, k (sans virgule après la dernière valeur affichée).

public static void compteBis(int k)
{
    for(int i=0; i<k; i++)
    {
        System.out.print(i);
        if(i < k-1) System.out.print(", ");
        else System.out.println();
    }
}

A-dec-21

Réalisez une méthode void compte(int a, int b) qui affiche tous les entiers compris entre a et binclus, séparés par des espaces. Par exemple, l’appel compte(3, 6) doit afficher 3 4 5 6.

public static void compte(int a, int b)
{
    for(int i=a; i<=b; i++)
    {
        System.out.print(i + " ");
    }
    System.out.println();
}

A-dec-22

Complétez le code ci-dessous pour qu’un appel de la méthode couples(a,b) aie pour effet l’affichage de tous les couples de valeurs comprises entre a et b inclus. Par exemple, l’exécution de couples(4,5) devra afficher :

(4, 4)
(4, 5)
(5, 4)
(5, 5)

    public static void couples(int a, int b)
    {
        for(---------------------------)
        {
            for(---------------------------)
            {
                System.out.println("( " + i + " , " + j + " )" );
            }
        }
    }

public static void couples(int a, int b)
{
    for(int i=a; i<=b; i++)
    {
        for(int j=a; j<=b; j++)
        {
            System.out.println("( " + i + " , " + j + " )" );
        }
    }
}

A3 : Utiliser des tableaux

Présentation

En java comme dans bien d’autres langages de programmation, un tableau est une collection de données de même type stockées de manière contigüe en mémoire dans des cellules désignées par des indices. Tous les exemples de code qui seront introduits sont supposés se trouver dans la classe Decouverte.

Voici un exemple de création d’un tableau de 10 entiers.

private static int[] tab = new int[10];

Il y a beaucoup de choses à dire et à comprendre à propos de cette ligne. Tout d’abord, elle ne se trouve pas dans la définition d’une méthode, mais directement dans une classe, en l’occurrence la classe Decouverte. Comme sa déclaration n’est pas dans une méthode, tab n’est pas une variable de méthode. Il s’agit d’une variable de classe comme nous l’indique le mot clé static. Ceci signifie que ce tableau existe pendant toute la durée de l’exécution du programme et pas seulement pendant la durée d’exécution d’une méthode particulière comme c’est le cas pour une variable de méthode. Le modificateur d’accès private indique que seule les méthodes de la classe Decouverte y ont accès.

Ensuite il faut comprendre que la ligne de code ci-dessus peut se décomposer en deux lignes ayant chacune un rôle différent.

private static int[] tab;
tab = new int[10];

La première ligne déclare une variable nommée tab de type int[]. Cette variable est située dans une zone mémoire dédiée aux variables de classe. Cette variable peut contenir la référence d’un objet de type int[]. Techniquement, une référence est une adresse mémoire à laquelle est situé un objet dans une zone mémoire appelée tas. La notion d’objet sera détaillée plus tard. La seule chose que nous devons savoir à ce sujet pour le moment est qu’en java, tout tableau est un objet.

La deuxième ligne crée un tableau d’entiers de 10 cellules, situé dans le tas. Chaque cellule contient la valeur 0. Voici la représentation graphique du résultat.

Nous allons maintenant réaliser une méthode permettant d’afficher le contenu d’un tableau d’entiers.

    public static void printTabInt(int[] t)
    {
        for(int i=0; i< t.length; i++)
        {
            System.out.print(t[i] + " ");
        }
        System.out.println();
    }

On voit que cette méthode a un paramètre t de type int[], c’est à dire une référence d’un tableau d’entiers. La notation t.length permet de récupérer la longueur du tableau t. La notation t[i] désigne la valeur située dans la cellule d’indice i du tableau t.

Voici un exemple d’appel de la méthode printTabInt depuis la méthode main.

    public static void main(String[] args)
    {
        tab[1] = 5; tab[3] = 7;
        printTabInt(tab);
    }

L’exécution de cette méthode a pour effet l’affichage 0 5 0 7 0 0 0 0 0 0.

Exercices de découverte

A-dec-30

Réalisez une méthode Rempli0123 qui accepte en paramètre la référence d’un tableau d’entiers et qui rempli ce tableau d’entiers avec les valeurs 0, 1, 2, etc. La valeur placée dans la dernière cellule devra donc être égale à la longueur du tableau moins 1.

public static void rempli0123(int[] t)
{
    for(int i=0; i< t.length; i++)
    {
        t[i] = i;
    }
}

Réalisez une méthode main qui teste la méthode Rempli0123 en remplissant le tableau désigné par la variable de classe tab que nous avons créé précédemment puis en affichant le contenu de ce tableau à l’aide de la méthode printTabInt.

public static void main(String[] args)
{
    rempli0123(tab); printTabInt(tab);
}

A4 : La pile et le tas

Présentation

Examinons la méthode suivante.

    public static int[] produitab(int a, int b)
    {
        int[] t = new int[b-a+1];
        for(int i=0; i< t.length; i++)
        {
            t[i] = a + i;
        }
        return t;
    }

Contrairement aux méthodes précédentes qui ne retournaient rien (void), celle-ci retourne la référence d’un tableau d’entiers (int[]) qui, incidemment, n’existe pas encore au moment de l’appel de la méthode. Examinons les différents blocs.

Le premier bloc est la ligne suivante.

				int[] t = new int[b-a+1];

Elle a pour effet de déclarer une variable de méthode t et d’y placer la référence d’un tableau d’entiers de taille b-a+1 qui, comme tout tableau est situé dans le tas. Le nombre de cellules de ce tableau, b-a+1, permet de stocker tous les entiers compris entre a et b. Essayez avec un exemple, par exemple a = 3 et b = 7, pour vous en convaincre.

Le deuxième bloc est la boucle suivante.

        for(int i=0; i< t.length; i++)
        {
            t[i] = a + i;
        }

Elle a pour effet de remplir le tableau précédemment créé. Voici par exemple l’état de la mémoire à la fin de son exécution pour des arguments 3 et 7 passés en paramètres de la méthode.

On y voit les 4 variables de méthodes, dont deux sont des paramètres, situées dans une mémoire appelée pile. Ces quatre variables n’existeront plus après l’exécution de la méthode (et seront recréées automatiquement à chaque nouvelle exécution). Par contre, le tableau, situé dans le tas, continuera d’exister tant que sa référence sera contenue dans au moins une variable.

Pour illustrer le cycle de vie du tableau, appelons la méthode main de la classe Decouverte suivante.

class Decouverte
{
    private static int[] tab = new int[10];
  
    public static void printTabInt(int[] t)
    {
        for(int i=0; i< t.length; i++)
        {
            System.out.print(t[i] + " ");
        }
        System.out.println();
    }
  
    public static int[] produitab(int a, int b)
    {
        int[] t = new int[b-a+1];
        for(int i=0; i< t.length; i++)
        {
            t[i] = a + i;
        }
        return t;
    }
  
    public static void main(String[] args)
    {
        tab = produitab(3,7);
        printTabInt(tab);
    }
}

Lors de l’exécution de main il se passe plusieurs choses très intéressantes et qu’il est important que vous preniez le temps de comprendre. L’initialisation des variables de classe se fait avant l’exécution de main. Donc dès le début de cette exécution tab désigne un tableau dont les 10 cellules contiennent 0.

L’appel produitab(3,7) crée un nouveau tableau dans le tas et en retourne la référence qui remplace celle précédemment contenue dans la variable de classe tab. Donc l’ancien tableau désigné par tab n’est plus pointé par aucune variable. Il sera automatiquement détruit par un dispositif de recyclage de la mémoire appelé ramasse miettes. L’appel à printTabInt affiche le contenu du nouveau tableau, qui sera lui même détruit à l’issue de l’exécution de main.

Exercices de découverte

A-dec-40

Dans l’exemple précédent, la variable de classe tab désigne initialement un tableau remplis de 0 qui ne sert à rien puisqu’il est détruit automatiquement par le ramasse miette sans jamais être utilisé. Quelle modification faut-il faire pour éviter la création de ce tableau inutile ?

public static int[] tab;

A-dec-41

Dans la classe Decouverte présentée précédemment, la variable de classe tab permet de récupérer le résultat de l’appel de la méthode produitab qui sera ensuite transmis à la méthode printTabInt. Mais il n’est pas nécessaire d’utiliser une variable de classe pour faire cela. Modifiez le code de la classe Decouverte de manière à ce que la variable tabsoit une variable de méthode de main. Dans cette nouvelle version, il ne doit plus y avoir de variable de classe.

class Decouverte
{ 
    public static void printTabInt(int[] t)
    {
        // Aucun changement
    }
  
    public static int[] produitab(int a, int b)
    {
        // Aucun changement
    }
  
    public static void main(String[] args)
    {
        int [] tab = produitab(3,7);
        printTabInt(tab);
    }
}

A-dec-42

Réécrivez la méthode mainde la classe Decouverte de manière à ce que son exécution ait le même effet que la version précédente, mais sans utiliser aucune variable (ni de méthode, ni de classe).

public static void main(String[] args)
{
    printTabInt(produitab(3,7));
}

A5 : Types primitifs et chaînes de caractères

Présentation

Dans exemple précédent, nous avons utilisé des valeur et variable de type int, qui représente des entiers relatifs. int est un type primitif, qui représente une donnée simple. On parle parfois de type scalaire. Voici quelques types primitifs de java.

• int : entiers signés entre $−2^{31}$ et $2^{31} − 1$.
• long : entiers signés entre $−2^{63}$ et $2^{63} − 1$.
• char : caractère imprimable
• byte : entier compris entre -128 et 127
• float : nombre en virgule flottante codé sur 4 octets
• double : nombre en virgule flottante codé sur 8 octets
• boolean : valeur Booléenne (true ou false)

Un autre type standard très utilisé est le type String qui permet la représentation des chaînes de caractères. Tout comme les tableaux, les chaînes de caractères sont des objets. Mais pour l’instant, nous les considérons comme de simples structures de données.

Voici quelques exemples de création de chaînes (on suppose que ces lignes de code sont situées dans une méthode) :

String s1 = "Tom";
String s2 = "Tim";
String s3 = s1;

Et voici l’état des lieux en mémoire après l’exécution de ces lignes.

Les chaînes de caractères sont des objets situés dans le tas. Ce sont des instances de la classe String. Généralement, tout objet est créé à l’aide de l’opérateur new, mais dans cet exemple il est implicite. Il n’en reste pas moins que les variables s1, s2 et s3 contiennent des références qui désignent des objets de type String situés dans le tas. L’instruction s3 = s1 n’a pas dupliqué la chaîne désignée par s1 mais a juste recopié la référence de cette chaîne dans s3.

Ajoutons une quatrième ligne.

s1 = s1 + s2;

Le résultat en mémoire est le suivant.

L’opérateur + n’a pas ajouté "Tim" à la fin de la chaîne désignée par s1, comme on pourrait le penser à l’issue d’une observation superficielle !

Cet opérateur a en fait créé une nouvelle chaîne résultant de la concaténation des chaînes désignées par s1 et s2, et la référence de cette nouvelle chaîne a été placée dans la variable s1.

La nuance est extrêmement importante. Si vous ne la saisissez pas, c’est qu’un pan entier de la programmation en Java vous échappe encore, et vous devez revenir sur les explications précédentes et / ou questionner un enseignant ou un expert pour bien saisir la subtilité. À défaut, vous pourrez produire, dans des applications que vous développerez, des bugs que vous ne comprendrez pas.

Exercices de découverte

A-dec-50

Après les lignes de code données en exemple précédemment, on écrit :

s2 = s3;

Dessinez la configuration en mémoire après l’exécution de cette ligne. Que devient le bloc mémoire contenant "Tim" ?

A-dec-51

Dans une même classe (par exemple Decouverte), on place les méthodes suivantes.

    public static void modif(String s)
    {
        s = s + s;
    }

    public static void main(String[] args)
    {
        String t = "Tim"; 
        modif(t); 
        System.out.println(t);
    }

Voici la configuration en mémoire au tout début de l’exécution de la méthode modif, juste avant l’exécution de la ligne s = s + s.

Dessinez la configuration en mémoire à la fin de l’exécution de la méthode modif, juste après l’exécution de la ligne s = s + s. Déduisez-en ce qui est affiché par l’exécution de main.

A6 : Ligne de commande

Présentation

Pour exécuter un programme Java directement depuis une console, vous devez taper java nom_du_programme. Mais il est possible d’ajouter des arguments, séparés par des espaces, comme par exemple :

java calc 10 + 20

Le programme calc récupérera ces arguments sous forme de chaînes de caractères dans le tableau args de sa méthode main. Voici une premier programme expérimental

public class Calc
{
      public static void main(String[] args)
      {
          for (String s : args)
          {
              System.out.println(s);
          }
			} 
}

Après compilation on tape dans la console :

java calc 10 + 20

Et on obtient l’affichage :

10 
+ 
20

Pour comprendre ce qui c’est passé, observons la configuration en mémoire juste avant la fin de l’exécution.

On constate que les arguments passés en ligne de commande ont été placé dans un tableau de chaînes de de caractères. Techniquement, les cellules d’un tel tableau contiennent des références d’objets de types String situés dans le tas.

Tentons une première version d’un programme qui se comporte comme une calculatrice rudimentaire limitée à l’addition.

public class Calc
{
    public static void main(String[] args)
    {
        if((args.length != 3) || !args[1].equals("+"))
        {
            System.out.println("Arguments incorrects"); 
        }
        else
        {
            System.out.println(args[0] + args[2]);
        } 
    }
}

On lance l’exécution du programme depuis la console avec les arguments suivants…

java calc 10 + 20

… et on obtient l’affichage 1020 et non 30 comme attendu de la part d’une calculatrice. La raison est très simple à comprendre. L’opérateur + a été utilisé avec deux chaînes de caractères, la chaîne "10" et la chaine "20". Dans ce contexte, l’opération réalisée est une concaténation et non une addition. Pour faire une addition, il faut traduire nos chaînes en nombres.

public static void main(String[] args)
{
    if((args.length != 3) || !args[1].equals("+"))
    {
        System.out.println("Arguments incorrects"); 
    }
    else
    {
        int a = Integer.parseInt(args[0]); 
        int b = Integer.parseInt(args[2]);
        System.out.println(a+b); 
    }
}

Cette fois-ci, le programme se comporte comme attendu. L’exécution de la ligne de commande décrite précédemment a bien pour effet l’affichage de 30.

Évidemment, le programme ne fonctionne que si le premier et le troisième arguments ont un format permettant de les interpréter comme des entiers. Si on tape…

calc 10 + vingt

… on obtient un message d’erreur qui nous parle d’une exception. Nous verrons plus tard comment gérer cela.

Exercices de découverte

A-dec-60

Améliorez le programme précédent de manière à ce qu’il puisse réaliser une addition ou une multiplication.

public static void main(String[] args)
{
    if( (args.length != 3) || !(args[1].equals("+") || args[1].equals("*")) )
    {
        System.out.println("Arguments incorrects"); 
    }
    else
    {
        int a = Integer.parseInt(args[0]); int b = Integer.parseInt(args[2]);
        if(args[1].equals("+"))
        {
            System.out.println(a + b);
        }
        else
        {
            System.out.println(a * b);
        }
    }
}

Exercices d’assimilation

A-ass-00

On peut classer les entiers naturels (0, 1, 2, 3, …) en deux catégories : les nombres premiers et les nombres composés. Un entier $x$ est premier si et seulement s’il n’a pas d’autre diviseur que lui même et 1. Dans le cas contraire, il est composé, ce qui implique qu’il existe au moins deux entiers $a>$1 et $b>$ 1 tels que $x=ab$.

Pour savoir si un entier naturel $x$ est premier ou composé, on peut rechercher s’il a un diviseur $a$ compris entre 2 et $\lfloor \sqrt x \rfloor$. En effet, il est impossible qu’un entier $x$ soit le produit de deux entiers supérieurs à $\sqrt x$. La démonstration est laissée à la discrétion du lecteur, si affinité. Par exemple, si je veux savoir si 103 est premier, il me suffit d’essayer de la diviser par les entiers 2 à 10. Comme chacune des divisions a un reste non nul, 103 est premier.

Pour savoir si la division d’un entier $x$ par un entier $a$ a un reste, on peut utiliser l’opérateur modulo, noté %, qui donne le reste de la division $a/b$. Par exemple, 103 % 5 a pour résultat 3. Autre information utile : pour placer dans une variable borne de type int la valeur $\lfloor \sqrt x \rfloor$, on peut écrire borne = (int)Math.sqrt(x).

Sachant tout cela, réalisez une méthode de classe qui accepte en paramètre un entier supposé positif ou nul et qui retourne un Booléen valant true si et seulement si x est premier.

    public static boolean premier(int x)
    {
        // À compléter
    }

    public static boolean premier(int x)
    {
        if(x<2) return false;

        int borne = (int)Math.sqrt(x);

        for(int d=2; d <= borne; d++) 
        {
            // À compléter
        }

        return true;
    }

    public static boolean premier(int x)
    {
        if(x<2) return false;

        int borne = (int)Math.sqrt(x);

        for(int d=2; d <= borne; d++) // au lieu de <x
        {
            if(x % d == 0) return false;
        }

        return true;
    }

A-ass-01

Réalisez une méthode de classe premiers qui accepte en paramètre un entier n et retourne une tableau contenant les nombres premiers inférieurs à n. Par exemple si n vaut 10, le tableau retourné doit contenir les entiers 2, 3, 5, 7. Cette méthode doit appeler la méthode premier de l’exercice précédent.

Comme le nombre de nombre premiers n’est pas connu à l’avance, la méthode commence par les stocker dans un tableau de taille suffisante (à déterminer), qui sera ensuite recopié dans un tableau ayant exactement la taille nécessaire.

public static int[] premiers(int n)
{
    int[] t = new int[n/2 + 1];
    int nbPremEnr = 0; // Nombre de nombres premiers enregistrés

    for(int candidat=2; candidat<n; candidat++)
    {
        // À compléter
    }

    int[] r = new int[nbPremEnr];
    // À compléter

    return r;
}

public static int[] premiers(int n)
{
    int[] t = new int[n/2 + 1];
    int nbPremEnr = 0;

    for(int candidat=2; candidat<n; candidat++)
    {
        if(premier(candidat))
        {
            // À compléter
        }
    }

    int[] r = new int[nbPremEnr];
    for(int i=0; i<nbPremEnr; i++)
    {
        // À compléter
    }

    return r;
}

public static int[] premiers(int n)
{
    int[] t = new int[n/2 + 1];
    int nbPremEnr = 0;

    for(int candidat=2; candidat<n; candidat++)
    {
        if(premier(candidat))
        {
            t[nbPremEnr] = candidat; nbPremEnr++;
        }
    }

    int[] r = new int[nbPremEnr];
    for(int i=0; i<nbPremEnr; i++)
    {
        r[i] = t[i];
    }

    return r;
}

A-ass-10

Vous devez réaliser une méthode acceptant en paramètre un entier n et retournant une chaîne de caractères constituée de n lettres majuscules tirées aléatoirement. Les informations suivantes vous seront utiles :

• La méthode de classe prédéfinie Math.ramdom() retourne une nombre aléatoire de type double compris entre 0.0 (inclus) et 1.0 (exclus).
• Si s est une chaîne de caractères, c’est à dire un objet de type String, et si i est un entier, alors s.charAt(i) retourne le caractère situé en position i dans s.
• Si c est un caractère et s est une chaîne, alors s+c est la chaîne obtenue en ajoutant de caractère c à la fin de s.

public static String ramdomStr(int n)
{
    String lettres = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String r = "";

    for(int i=0; i<n; i++)
    {
        // À compléter.
    }

    return r;
}

public static String ramdomStr(int n)
{
    String lettres = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String r = "";

    for(int i=0; i<n; i++)
    {
        int pos = (int)(lettres.length() * Math.random());
        // À compléter
    }

    return r;
}

public static String ramdomStr(int n)
{
    String lettres = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    String r = "";

    for(int i=0; i<n; i++)
    {
        int pos = (int)(lettres.length() * Math.random());
        r = r + lettres.charAt(pos);
    }

    return r;
}

A-ass-11

Vous devez réaliser une méthode acceptant en paramètre une chaîne s et retournant la chaîne de caractères obtenue en remplaçant chaque lettre minuscule par une lettre majuscule avec une probabilité 1/2.

Par exemple, l’appel…

System.out.println(effect("Bonjour, Comment allez-vous ?"));

…peut afficher des chaines telles que :

BoNJOUR, CoMMeNT ALLez-vOus ?
BOnJour, COmMeNt aLLEz-VouS ?
BonJoUR, CoMmeNt alleZ-VoUs ?

L’information suivante vous sera utile : si c est un caractère représentant une lettre minuscule, alors Character.toUpperCase(c) retourne la lettre majuscule correspondante. Dans le cas où c ne représente pas une lettre majuscule, l’appel retourne c.

    public static String effect(String s)
    {
        String r = "";

        for(int i=0; i<s.length(); i++)
        {
            if(Math.random() > 0.5)
            {
                // À compléter
            }
            else
            {
                // À compléter
            }
        }
        return r;
    }
}

    public static String effect(String s)
    {
        String r = "";
        for(int i=0; i<s.length(); i++)
        {
            if(Math.random() > 0.5)
            {
                r = r + s.charAt(i);
            }
            else
            {
                r = r + Character.toUpperCase(s.charAt(i));
            }
        }
        return r;
    }
}

Exercices d’approfondissement

Ne traitez ces exercices que si vous avez traité et maitrisé les exercices de découverte et d’assimilation de toutes les parties déjà en ligne.

A-top-00

Vous devez réaliser une méthode de classe premiers qui accepte en paramètre un entier n et retourne une tableau contenant les nombres premiers inférieurs à n. Par exemple si n vaut 10, le tableau retourné doit contenir les entiers 2, 3, 5, 7. Mais cette méthode doit être plus efficace que celle demandée dans un des exercices d’assimilation de cette partie. Pour déterminer si un nombre $x$ est composé ou premier, elle doit tester sa divisibilité par les nombres premiers compris entre 2 et $\lfloor \sqrt x \rfloor$, qui ont déjà été préalablement stockés dans le tableau, et uniquement par ces entiers. En effet, tout nombre composé est divisible par au moins un nombre premier compris entre 2 et $\lfloor \sqrt x \rfloor$. La preuve est laissée à la discrétion du lecteur, si affinité.

Comme le nombre de nombre premiers n’est pas connu à l’avance, la méthode commence par les stocker dans un tableau de taille suffisante (à déterminer), qui sera ensuite recopié dans un tableau ayant exactement la taille nécessaire.

A-top-01

Vous devez réaliser une méthode de classe premiers qui accepte en paramètre un entier n et retourne une tableau contenant les nombres premiers inférieurs à n. Par exemple si n vaut 10, le tableau retourné doit contenir les entiers 2, 3, 5, 7. Mais cette méthode doit être encore plus efficace que celle de l’exercice précédent. Elle doit utiliser le principe connu sous le nom de crible d’Ératosthène.

Le principe est simple, mais le codage nécessite d’être très attentifs et rigoureux. Imaginons qu’on cherche les nombres premiers inférieur à 100. On crée un tableau de 100 Booléens, dont les indices des cellules vont de 0 à 99. Les cellules sont initialisées à false. On place truedans les cellules d’indices 0 et 1, puis dans toutes les cellules d’indices pairs sauf 2, dans toutes les cellules d’indices multiples de 3 sauf 3 , multiples de 5 sauf 5, multiples de 7 sauf 7, etc. Pour faire cela, on utilise uniquement des boucles et des additions, donc ni division, ni modulo, ni multiplications. Par exemple pour les multiples de 3, on place true dans les cellules d’indices 3+3, 3+3+3, 3+3+3+3, etc. À l’issue de ce remplissage, les indices des cellules contenant falsesont les nombres premiers recherchés.

La figure suivante illustre les deux premières étapes du remplissage.

Cette méthode est très connue, donc vous pourrez facilement trouver des explications supplémentaire sur le WEB. Mais attention, vous pourrez aussi trouver des algorithmes détaillés et même des programmes déjà réalisés. Recopier ces codes ferait perdre tout intérêt à cet exercice dont le but est de développer votre pensée algorithmique.

Le tableau retourné devra contenir la liste des nombres premiers recherchés, exactement comme pour l’exercice précédents. Le tableau ayant permis de réaliser le crible est juste un tableau intermédiaire utilisé par la méthode et n’est pas le tableau à retourner.