Fall 2012, The College of Saint Rose

Ratios BlueJ Project

Ratios Source Code

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

### Ratios.java

```/*
* 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: Ratios.java 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
a.setNumerator(1);
b.setDenominator(10);

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());

}
}
```

### Ratio.java

```/*
* 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: Ratio.java 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;
}
}
```