Exercice Java : Synthèse entiers naturels


Reviewed by:
Rating:
5
On February 28, 2013
Last modified:June 24, 2013

Summary:

Exercice Java : Synthèse entiers naturels

Exercice java traite le  sujet suivant:

Synthèse entiers naturels

Examinons ce petit Exercice java:



Réaliser une classe permettant de manipuler des entiers naturels (positifs ou nuls) et disposant :

  • • d’un constructeur à un argument de type int ; il générera une exception ErrConst si la valeur de son argument est  négative ;
  • • de méthodes statiques de somme, de différence et de produit de deux naturels ; elles généreront respectivement des exceptions ErrSom, ErrDiff et ErrProd lorsque le résultat ne sera pas représentable ; la limite des valeurs des naturels sera fixée à la plus grande valeur du type int ;
  • • une méthode d’accès getN fournissant sous forme d’un int la valeur de l’entier naturel.

On s’arrangera pour que toutes les classes exception dérivent d’une classe ErrNat et pour qu’elles permettent à un  éventuel gestionnaire de récupérer les valeurs ayant provoqué l’exception.
Écrire deux exemples d’utilisation de la classe :

  • • l’un se contentant d’intercepter sans discernement les exceptions de type dérivé de ErrNat,
  • • l’autre qui explicite la nature de l’exception en affichant les informations disponibles.

Les deux exemples pourront figurer dans deux blocs try d’un même programme.

L’énoncé nous impose de respecter une certaine hiérarchie pour les classes exception. Ici, pour faciliter la tâche, nous prévoyons une classe intermédiaire supplémentaire nommée ErrOp qui servira de base aux exceptions liées à des  opérations arithmétiques (somme, différence ou produit) ; elle possèdera tout naturellement deux champs de type int (on aurait pu choisir aussi EntNat) représentant les valeurs des deux opérandes de l’opération.
La hiérarchie des classes d’exception se présentera donc ainsi :

la-hierarchie-des-classes-exception

Voici la définition de notre classe EntNat et des classes exception correspondantes :


class EntNat
{ public EntNat (int n) throws ErrConst
{ if (n<0) throw new ErrConst(n) ;
this.n = n ;
}
public static EntNat somme (EntNat n1, EntNat n2) throws ErrSom, ErrConst
{ int op1 = n1.n, op2 = n2.n ;
long s = op1 + op2 ;
if (s > Integer.MAX_VALUE) throw new ErrSom (op1, op2) ;
return new EntNat (op1+op2) ;
}
public static EntNat diff (EntNat n1, EntNat n2) throws ErrDiff, ErrConst
{ int op1 = n1.n, op2 = n2.n ;
int d = op1 - op2 ; if (d<0) throw new ErrDiff(op1, op2) ;
EntNat res = new EntNat (d) ;
return res ;
}

public static EntNat prod (EntNat n1, EntNat n2) throws ErrProd, ErrConst
{ int op1 = n1.n, op2 = n2.n ;
long p = (long)op1 * (long)op2 ;
if (p > Integer.MAX_VALUE) throw new ErrProd(op1, op2) ;
return new EntNat ((int)p) ;
}
public int getN() { return n ; }
private int n ;
}
class ErrNat extends Exception {}
class ErrConst extends ErrNat
{ public ErrConst (int n) { this.n = n ; }
public int n ;
}
class ErrOp extends ErrNat
{ public ErrOp (int n1, int n2)
{ this.n1 = n1 ; this.n2 = n2 ;
}
public int n1, n2 ;
}
class ErrSom extends ErrOp
{ public ErrSom (int n1, int n2)
{ super(n1, n2) ;
}
}
class ErrDiff extends ErrOp
{ public ErrDiff (int n1, int n2)
{ super(n1, n2) ;
}
}
class ErrProd extends ErrOp
{ public ErrProd (int n1, int n2)
{ super (n1, n2) ;
}
}

Il faut bien prendre garde à mentionner ErrConst dans la clause throws des méthodes somme, diff et prod puisque l’appel du constructeur de EntNat est une source potentielle d’une telle exception. Si on ne le fait pas, on obtiendra une erreur de compilation.
Notez que, dans la méthode prod, il a fallu prendre la précaution d’effectuer le calcul du produit en long. Pour cela, il ne faut surtout pas se contenter d’écrire :

long p = op1 * op2 ;

car le produit op1*op2 serait effectué dans le type int. Le résultat ne serait jamais supérieur à Integer.MAX_VALUE ; de plus, il pourrait être négatif, ce qui déclencherait une exception lors de la construction de EntNat ((int)p).

Voici deux exemples d’utilisation répondant aux conditions imposées par l’énoncé :

 public class TstEntN2
 { public static void main (String args[])
 { try
 { EntNat n1 = new EntNat(20), n2 = new EntNat(12) ;
 EntNat d ;
 d = EntNat.diff (n1, n2) ;
 d = EntNat.diff (n2, n1) ;
 }
 catch (ErrNat e)
 { System.out.println ("*** erreur Entier naturel ****") ;
 }
 try
 { EntNat n3 = new EntNat (50000), n4 = new EntNat (45000) ;
 EntNat d = EntNat.diff (n3, n4) ;
 EntNat s = EntNat.somme (n3, n4) ;
 EntNat p = EntNat.prod (n3, n4) ;
 }
 catch (ErrConst e)
 { System.out.println ("*** erreur construction EntNat avec argument "
 + e.n) ;
 }
 catch (ErrDiff e)
 { System.out.println ("*** erreur difference EntNat - valeurs "
 + e.n1 + " " + e.n2) ;
 }
 catch (ErrSom e)
 { System.out.println ("*** erreur somme EntNat - valeurs "
 + e.n1 + " " + e.n2) ;
 }
 catch (ErrProd e)
 { System.out.println ("*** erreur produit EntNat - valeurs "
 + e.n1 + " " + e.n2) ;
 }
 }
 }
 *** erreur Entier naturel ****
 *** erreur produit EntNat - valeurs 50000 45000

Remarque:

1. Si notre deuxième bloc try ne comportait pas l’appel des trois méthodes somme, diff et prod, le compilateur n’accepterait pas qu’il soit suivi d’un ou de plusieurs gestionnaires non utiles (par exemple, catch(ErrProd e) sans appel de EntNat.prod).
2. Nous pourrions exploiter l’existence de la classe ErrOp pour simplifier la gestion des exceptions en nous contentant de distinguer les exceptions de construction de celles de calcul. Dans ce dernier cas, on pourrait afficher les valeurs des deux opérandes mais on ne pourrait plus préciser l’opération concernée.

Leave a Reply

Your email address will not be published. Required fields are marked *


*

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>