Computer Science 202
Introduction to Programming

Fall 2012, The College of Saint Rose

Ratios BlueJ Project

Click here to download a BlueJ project for Ratios.

Ratios Source Code

The Java source code for Ratios is below. Click on a file name to download it.

 * Example Ratios -- a main method that demonstrates the use of
 * the Ratio class (also provided in this project)
 * Jim Teresco, The College of Saint Rose, CSC 202, Fall 2012
 * $Id: 2003 2012-12-04 01:42:42Z terescoj $

public class Ratios {

    public static void main(String[] args) {

        // Now to represent ratios, we create an instance of Ratio
        // for each.  The "new" results in a call to the constructor
        // of the class.
        Ratio a = new Ratio(4, 6);
        Ratio b = new Ratio(2, 4);

        // print some information about these.  If we try to "print out"
        // an instance of a class, Java will implicity call the class's
        // toString method.  We can also call it explicitly, as in the
        // second example.
        System.out.println("Ratio a is " + a);
        System.out.println("Ratio b is " + b.toString());

        // we can print their decimal equivalents, which is now done by
        // the Ratio class by calling its getDecimalValue method
        System.out.println("a as a decimal is " + a.getDecimalValue());
        System.out.println("b as a decimal is " + b.getDecimalValue());

        // let's change the ratios a bit, this time by calling mutator
        // methods of our Ratio instances, then do the printouts again

        System.out.println("Ratio a is " + a);
        System.out.println("Ratio b is " + b);

        System.out.println("a as a decimal is " + a.getDecimalValue());
        System.out.println("b as a decimal is " + b.getDecimalValue());        


 * Example Ratios -- the Ratio class
 * This class encapsulates a numerator and denominator and
 * includes the capability to set the numerator or denominator,
 * retrieve the numerator or denominator, retrieve the decimal
 * equivalent of the ratio, and return a "pretty" String 
 * representation of the ratio
 * Jim Teresco, The College of Saint Rose, CSC 202, Fall 2012
 * $Id: 2003 2012-12-04 01:42:42Z terescoj $

public class Ratio {

    // We first define the fields -- also called instance variables
    // that define the state of a ratio.
    // In this case, we need only two integers, one each for the numerator
    // and denominator.
    // Note that these look like local variables in a method, except we
    // add the qualifier "private" to indicate that no one except the
    // methods of this class can access these variables.  This is the
    // most common qualifier for instance variables.
    // Instance variables have a class scope -- they are visible inside all
    // methods we write within this class.
    private int numerator;
    private int denominator;
    // We next provide the methods that operate on a Ratio.  The first is usually
    // a special method that gets called when we create a Ratio, called the
    // constructor.  It looks like the method calls we have seen earlier in
    // the semester, except we do not need "static" or "void".  The name of
    // the constructor must match the name of the class, and it should take
    // any parameters needed to give the class its initial value.
    public Ratio(int num, int den) {
        // Inside the constructor, we initialize our instance variables.  In
        // this case, we initialize them based entirely on the parameters.
        // In some other cases, the initialization might be to constant values
        // or may use more complex expressions.  Note that "num" and "den" are
        // parameters whose scope is only this constructor -- they will not 
        // exist when we get to other methods later on.  While "numerator"
        // and "denominator" are instance variables that will remain in scope
        // and retain their values in other methods we call later.
        numerator = num;
        denominator = den;
    // We next provide two "mutator" methods.  These methods are capable of
    // modifying the "private" instance variables based on the values in the
    // parameters.  Mutator methods modify the state of an object, but do
    // not usually return any information, so they are specified with a "void"
    // qualifier in addition to "public".  Note that we do not specify "static"
    // on any of our methods in the class now that we are defining our own
    // classes that represent objects.
    public void setNumerator(int num) {
        numerator = num;
    public void setDenominator(int den) {
        denominator = den;
    // Objects aren't useful if we cannot get information back out from them.
    // This is done with "accessor" methods -- methods that allow us to access
    // the private instance variables within the class describing our object.
    // We start with 2 simple accessors -- ones that allow us to retrieve the
    // numerator and denominator.  Since those are both integer values, we specify
    // "int" return values on our methods.
    public int getNumerator() {
        return numerator;
    public int getDenominator() {
        return denominator;
    // Methods can also compute and return something interesting.  In this case,
    // we add the capability to compute and return the "decimal" equivalent
    // of the ratio.  This will be a double.
    public double getDecimalValue() {
        return 1.0 * numerator / denominator;
    // All Java classes provide a mechanism for printing a meaningful
    // representation of each instance of the class.  It is always in a
    // method named toString that returns a String.  If we do not provide
    // such a method, Java will use a builtin one (which will work but
    // which probably does not do quite what we'd like).  So we provide one
    // here to print out our Ratio in a "nice" format.
    public String toString() {
        return numerator + "/" + denominator;