Les entiers naturels - Une interface, plusieurs implémentations

Les accesseurs permettent d'observer un entier naturel suivant les deux points de vue, celui de la restriction d'une part, de la définition récursive d'autre part.

• int val()

  Méthode renvoyant l'entier relatif égal à l'entier naturel.

• int taille()

  Méthode renvoyant le nombre de chiffres (aucun 0 superflu en tête).

• int chiffre(int i)

  Méthode renvoyant le ième chiffre, les unités en 0, les dizaines en un, etc.

Ces deux méthodes sont déclarées dans la classe mère Object.

• String toString()

  Méthode permettant d'obtenir une représentation de l'entier naturel, en base dix.

• boolean equals(Object o)

  Méthode testant l'égalité entre l'objet cible et l'objet o passé en argument ; renvoie true si o pointe vers un entier naturel n et si l'entier naturel cible et n sont égaux (au sens mathématique), renvoie false sinon.

Toutes ces interfaces sont génériques car elles expriment des propriétés.

• int val

  Attribut privé ayant pour valeur un entier relatif positif ou nul.

• NatParInt(int val)

  Constructeur privé initialisant l'attribut à l'argument val supposé correct.

• static final FabriqueNaturels<Nat> FAB

  Fabrique constante initialisée par une invocation du constructeur.

Tous les calculs seront effectués en utilisant les int. On appliquera de manière systématique la méthode décomposant la couche en différentes couches : revoir sa description.

• String chiffres

  Attribut privé ayant pour valeur une suite non vide de chiffres entre 0 et 9, ne commençant pas par 0 lorsque sa longueur est strictement supérieure à un.

• NatDecimal(String rep)

  Constructeur privé initialisant l'attribut à l'argument rep supposé correct.

• static final FabriqueNaturels<Nat> FAB

  Fabrique constante initialisée par une invocation du constructeur.

Le code de la méthode somme est fourni.

public Nat somme(Nat x) {
        int t = this.taille() < x.taille() ? x.taille() : this.taille();
        String rep = "";
        int retenue = 0;
        for(int i = 0; i < t; i++){
                int chiffre = this.chiffre(i) + x.chiffre(i) + retenue;
                if(chiffre > 9){
                        chiffre = chiffre - 10;
                        retenue = 1;
                }else{
                        retenue = 0;
                }
                rep = Integer.toString(chiffre) + rep;
        }
        rep = retenue == 0 ? rep : 1 + rep;
        return this.creerNatAvecRepresentation(rep);
}

Tous les autres calculs (produit, division euclidienne) seront effectués en utilisant la somme. Le produit par 10 et la division euclidienne par 10 seront traités comme des cas particuliers : en effet, avec une représentation décimale, les calculs sont alors très simples.

Comme pour l'autre classe, on appliquera de manière systématique la méthode décomposant la classe en différentes couches : revoir sa description.

Définir l'interface Nat.

Pour la première implémentation, on procède par restriction. Implémenter l'interface Nat par la classe NatParInt, en procédant suivant la méthode rappelée ci-dessous.

• Définir l'état.
• Implémenter les constructeurs en accédant directement aux attributs de l'objet cible pointé par this.
• Implémenter les accesseurs en accédant aux attributs de l'objet cible pointé par this directement ou indirectement via d'autres accesseurs.
• Implémenter les fabriques en accédant aux constructeurs directement ou indirectement via d'autres fabriques.
• Implémenter les services en utilisant les seuls accesseurs et fabriques. Précisément, les implémenter en utilisant l'accesseur val() et la fabrique creerNatAvecValeur(int), autrement dit en ramenant les calculs sur les entiers naturels à des calculs sur des int.
• Pour vérifier que la méthode a été suivie correctement, déplacer les services dans l'interface Nat, sans oublier de les qualifier par default.

Pour la seconde implémentation, on utilise la représentation décimale. Procéder ainsi pour chaque classe.

• Définir l'état.
• Implémenter les constructeurs en accédant directement aux attributs de l'objet cible pointé par this.
• Implémenter les accesseurs en accédant aux attributs de l'objet cible pointé par this directement ou indirectement via d'autres accesseurs.
• Implémenter les fabriques en accédant aux constructeurs directement ou indirectement via d'autres fabriques.
• Implémenter les services. Recopier le code la méthode somme. Pour les autres opérations algébriques (produit et division euclidienne), utiliser un algorithme naïf fondé sur la somme, en distinguant cependant le cas de la multiplication ou de la division par 10.
• Pour vérifier que la méthode a été suivie correctement, déplacer les services dans l'interface Nat, sans oublier de les qualifier par default.

Les tests sont à placer dans la fonction principale main d'une classe appelée Test. Pour chaque test, il est demandé d'afficher tout d'abord le résultat que vous prévoyez, appelé oracle, puis effectivement le résultat calculé, sur le modèle suivant.

... // Calcul du résultat : rep
// Résultat prévu : oracle
System.out.println("oracle ? " + rep);

Remarque - Si rep est un objet, un appel implicite à la méthode toString() a lieu dans l'expression ​"oracle ? ​" + rep, équivalente à ​"oracle ? ​" + rep.toString(). La méthode toString() étant très pratique, tout objet en possède une. Par défaut, la méthode toString() renvoie une représentation de l'adresse de l'objet en mémoire.

1. Déclarer une fonction void test(FabriqueNat<Nat> fab) prenant en argument une fabrique d'entiers naturels de type Nat.
2. Implémenter dans la fonction test le scénario suivant.
   • Créer l'entier zéro à partir de la fabrique et l'affecter à une variable zero.
   • Afficher sa valeur.
   • Tester l'égalité entre zero et zero.zero().
   • Créer l'entier un à partir de la fabrique et l'affecter à une variable un.
   • Afficher sa valeur.
   • Tester l'égalité entre un et un.un().
   • Créer l'entier 5 à partir de la fabrique et l'affecter à une variable cinq.
   • Afficher sa valeur.
   • Créer l'entier 6 à partir de la fabrique et l'affecter à une variable six.
   • Calculer la somme de 5 et 6 et afficher le résultat.
   • Calculer le produit de 5 et 6 et afficher le résultat.
   • Calculer le quotient et le reste de la division euclidienne de 33 par 6.
   • Calculer la somme de 2\₀₀₀\₀₀₀\₀₀₀ avec lui-même. Rattraper l'exception possiblement lancée. Voir les tests du paquet session1.demo1.v2 pour un exemple de rattrapage.
3. Compléter la fonction principale en appelant la fonction test deux fois, avec des fabriques de type dynamique NatParInt et NatDecimal.

Dans la fonction de test, tester la fonction fournie Outils.produitRusse, en refaisant le produit de 5 et 6. Etudier sa définition et son utilisation.