/* ******************************************************************* * Module: Rational.java * Author: Lewis and Loftus * Destroyer: felipe @ IFT1010 * Comments: une version legerement modifiee de la classe originale * ******************************************************************* */ public class Rational { // pour illustrer le static (a voir plus tard) private static int nbObjets = 0; // les variables d'etat: seulement deux private int numerator, denominator; /* * les constructeurs * (deux en fait) */ public Rational (int numer, int denom) { // convention pour eviter les divisions par zero // en pratique on devrait lever une exception (a suivre) if (denom == 0) denom = 1; if (denom < 0) { numer = -numer; denom = -denom; } // initialisation de l'objet numerator = numer; denominator = denom; // 4/2 et 2/1 sont les memes rationnels // QUIZZ: pourquoi mettre le reduce ici ? reduce(); nbObjets ++; } // un autre constructeur qui ne prend qu'un entier // ici on fait appel au constructeur "general" // ce qui permet de ne pas reecrire du code deja ecrit public Rational(int num) {this(num,1);} // un detail, mais pour etre coherent avec le constructeur public void finalize() { System.err.println("Je purge le rationnel " + this); nbObjets--; } /* * ------------------------------- * arithmetique sur les rationnels * ------------------------------- */ public Rational add (Rational op2) { return new Rational (numerator * op2.getDenominator() + op2.getNumerator() * denominator , denominator * op2.getDenominator()); } public Rational subtract (Rational op2) { return new Rational (numerator * op2.getDenominator() - op2.getNumerator() * denominator, denominator * op2.getDenominator() ); } // juste pour montrer que c'est possible dans ce cas precis de ne pas passer par // l'assesseur getX public Rational multiply (Rational op2) { return new Rational (numerator * op2.numerator, denominator * op2.denominator); } // bel exemple de reutilisabilite public Rational divide (Rational op2) {// les deux sont viables mais la premiere est mieux ! return multiply (op2.reciprocal()); // return op2.multiply(reciprocal()).reciprocal(); } // simple non ? public Rational reciprocal () { return new Rational (denominator, numerator); } /* * les assesseurs */ public int getNumerator () {return numerator;} public int getDenominator () {return denominator;} // note: static est ici indispensable: voyez-vous pourquoi ? public static int getNbObjects() {return nbObjets;} /* * egalite entre deux rationnels */ public boolean equals (Rational op2) { return ( numerator == op2.getNumerator() && denominator == op2.getDenominator() ); } public boolean equals(int val) { return (numerator == val) && (denominator == 1); } public double getValue() { return ((double) numerator) / denominator; } //----------------------------------------------------------------- // Returns this rational number as a string. //----------------------------------------------------------------- public String toString () { String result; if (numerator == 0) result = "0"; else if (denominator == 1) result = numerator + ""; else result = numerator + "/" + denominator; return result; } //----------------------------------------------------------------- // Reduces this rational number by dividing both the numerator // and the denominator by their greatest common divisor. //----------------------------------------------------------------- private void reduce () { if (numerator != 0) { int common = gcd (Math.abs(numerator), denominator); numerator = numerator / common; denominator = denominator / common; } else { // j' ai ajoute ceci. QUIZ: qui voit pourquoi ? denominator = 1; } } //----------------------------------------------------------------- // Computes and returns the greatest common divisor of the two // positive parameters. Uses Euclid's algorithm. //----------------------------------------------------------------- private int gcd (int num1, int num2) { while (num1 != num2) if (num1 > num2) num1 = num1 - num2; else num2 = num2 - num1; return num1; } }