class CompareRational  {

   static class Rational { 
    int x,y;
   }

  private static void  main(String[]  args)  {

    Rational  r1,r2;
    int a = Integer.parseInt(args[0]);
    int b = Integer.parseInt(args[1]);
    int c = Integer.parseInt(args[2]);
    int d = Integer.parseInt(args[3]);

    r1 = new  Rational(); 
    r1.x = a;
    r1.y = b;

    r2 = new  Rational();
    r2.x = c;
    r2.y = d;

    System.out.println("r1 " + r1.x + "/" + r1.y);
    System.out.println("r2 " + r2.x + "/" + r2.y);

    System.out.println("r1 == r2 " + (r1.x*r2.y == r2.x * r1.y));
  }
}

• a set with associate operators
• abstract (mathematical)
• defined by their functional properties, with no concern for the details of their computer representation (information hiding)

Informal specification

A rational number is a number that can be expressed as the quotient of two integers with the following applicable operations: creation, addition, testing for equality, and operation to reduce to the lowest term.

Java Implementation

/**
 * Rational implements a rational number as a number
 * that can be expressed as the quotient of two integers with 
 * the following applicable operations: creation, addition, 
 * and testing for equality.
 *
 * @author Terence
 * @version 1.0
 */
 public class Rational { 
   private int numerator; 
   private int denominator;

 /**
  * Constructor to create Rational object
  * precondition denominator <> 0
  * postcondition
  *	this.numerator = numerator
  * 	this.denominator = denominator
  *
  * @param numerator
  * @param denominator
  * @throw IllegalArgumentException
  */
  public Rational(int numerator, int denominator) {
   if (denominator != 0) { 
      this.numerator = numerator; 
      this.denominator = denominator;
   } else throw new IllegalArgumentException("denominator == 0)");
  }

 /**
  * addition method to add two Rationals 
  * postcondition	
  *	denominator = this.denominator * rhs.denominator
  *	this.numerator = this.numerator * rhs.denominator + 
  *                       this.denominator * rhs.numerator
  *
  * @param rhs operand Rational
  * @return  the resulting Rational
  */
  public Rational add(Rational  rhs)  {
   return  new  Rational(numerator * rhs.denominator + 
                         this.denominator * rhs.numerator,
                         denominator * rhs.denominator);
  }

 /**
  * compare two Rationals
  * postcondition	
  *	equal = (this.numerator * rhs.denominator == 
  *               this.denominator * rhs.numerator)
  *
  * @param rhs operand Rational
  * @return if the two Rational are equal
  */
  public boolean equal(Rational  rhs)  {
   return (this.numerator * rhs.denominator == 
           this.denominator * rhs.numerator);
  }

 /**
  * reduce the invoking Rational number to its lowest term 
  */
  public void reduce()  {

   if (numerator == 0)  {
	denominator = 1;
   }
   else  {
         int  gcd = gcd(Math.abs(numerator), denominator);
         numerator /= gcd;
         denominator /= gcd;
         }
  }

 /**
  * toString method to create a string representation of
  * the invoking Rational
  *
  * @return string representing the invoking Rational
  */
  public String toString()  {
   return  (numerator + "/" + denominator);
  }

 /*
  * recursive method to find the greatest common divisor fo
  * two int x and y
  */ 
  private static int  gcd(int  x, int  y)  {

   if (y == 0)
      return x;
   else return gcd(y,x%y);
  }
}

• It is desirable to make ADTs as general as possible. As long as the interface to the user remains the same, you may modify your implementation with no effect on the user.

  import  java.io.*;
  
  public class RationalDriver  {
  
    private static void  main(String[]  args)  {
  
      Rational  r1,r2;
      int a = Integer.parseInt(args[0]);
      int b = Integer.parseInt(args[1]);
      int c = Integer.parseInt(args[2]);
      int d = Integer.parseInt(args[3]);
  
  
      r1 = new  Rational(a, b);
      r2 = new  Rational(c, d);
      System.out.println("r1 " + r1.toString());
      System.out.println("r2 " + r2.toString());
      System.out.println("r1 == r2 " + r1.equal(r2));
      System.out.println("r1 + r2 " + r1.add(r2).toString());
      r1.reduce();
      r2.reduce();
      System.out.println("after reduce r1 " + r1.toString());
      System.out.println("after reduce r2 " + r2.toString());
      System.out.println("r1 == r2 " + r1.equal(r2));
      System.out.println("r1 + r2 " + r1.add(r2).toString());
    }
  }
  

• How ?
• information hiding, modular, high cohesivness, and low coupling
• the only items that can be seen or manipulated are the public ones
• keep the internals aspects of a class private
• field, constructor, mutator, and accessor method e.g. java.lang.String()