Programmer-defined classes

Part 3

A class for representing Fractionspublic class Fraction {

private int numerator;private int denominator;public Fraction(int num, int denom) {

setNumerator(num); setDenominator(denom);

}public int getDenominator( ) {

return denominator;} public int getNumerator( ) {

return numerator;}

public void setDenominator(int denom) { if (denom == 0) { //Fatal error System.err.println("Fatal Error"); System.exit(1); } denominator = denom; } public void setNumerator(int num) { numerator = num; } public String toString( ) { return getNumerator() + "/" + getDenominator(); }}

// … continued from previous slide

Additional methods for Fraction

• The basic set of methods defined thus far give us ways to construct, set values, and print out (via the toString method) Fraction objects

• A richer set of methods would give us functionality comparable to the other numeric types (int, double, etc.)

• The next slide illustrates a method for simplifying a Fraction; rather than having it alter the calling object, we’ll make it return a new Fraction object

• The methods that add, subtract, multiply and divide Fractions should return Fraction results – so they will also be object-returning methods

The simplify() method (with helper method gcd())

public Fraction simplify( ) { int num = getNumerator(); int denom = getDenominator(); int gcd = gcd(num, denom); Fraction simp = new Fraction

(num/gcd, denom/gcd); return simp; }

private static int gcd (int m, int n) {int r;while (true) {

r = n%m;if (r == 0) break;n=m;m=r;

}return m;

}

Arithmetic algorithms for Fractions

• The next several slides illustrate arithmetic methods for our Fraction class, based on the following formulae:– Addition: a/b + c/d = (ad + cb)/bd– Subtraction: a/b – c/d = (ad – cb)/bd– Multiplication: a/b * c/d = ac/bd– Division: a/b / c/d = ad/bc

• We will define four Fraction-returning methods: plus, minus, times, and dividedBy

Calling the arithmetic methods

• Client code that uses Fraction objects might include instructions like these:Fraction f1, f2, f3;

…

f3 = f1.plus(f2);

f2 = f3.times(f1);

f1 = f2.minus(f3);

f3 = f1.dividedBy(f2);

Java’s keyword this

• Each of our arithmetic methods corresponds to a binary arithmetic operation

• Binary operations take two operands; they will be represented in our methods by the calling object and the argument

• We will need to access the numerator and denominator of both objects to perform the arithmetic operations

• We can use the keyword this to access data components of the calling object

The plus method

public Fraction plus (Fraction f) {int n1, n2, d1, d2; // numerators & denominators of the 2 FractionsFraction sum; // result to be returned

n1 = this.numerator; // numerator of calling objectn2 = f.numerator; // numerator of argumentd1 = this.denominator; // from calling objectd2 = f.denominator; // from argument

sum = new Fraction(n1*d2 + n2*d1, d1*d2);return sum;

}

Optional use of this

• In the previous example, the use of keyword this was actually optional

• The next couple of slides illustrate the implementation of arithmetic Fraction methods without using this

The minus method

public Fraction minus (Fraction f) {int n1, n2, d1, d2; // numerators & denominators of the 2 FractionsFraction difference; // result to be returned

n1 = numerator; // numerator of calling objectn2 = f.numerator; // numerator of argumentd1 = denominator; // from calling objectd2 = f.denominator; // from argument

difference = new Fraction(n1*d2 - n2*d1, d1*d2);return difference;

}

The times method

public Fraction times (Fraction f) {int n1, n2, d1, d2; // numerators & denominators of the 2 FractionsFraction product; // result to be returned

n1 = getNumerator(); // numerator of calling objectn2 = f.getNumerator(); // numerator of argumentd1 = getDenominator(); // from calling objectd2 = f.getDenominator(); // from argument

product = new Fraction(n1*n2, d1*d2);return product;

}

To this or not to this?

• As the last two slides illustrate, the use of keyword this to represent the calling object is optional

• In fact, it’s only optional from our point of view; if we don’t insert it (as was the case in the plus method), the compiler will insert it for us; so in fact, all three methods use this, whether implicitly or explicitly

Another use of this: avoiding scope clashes

• You may recall that a local variable with the same name as a variable with wider scope will hide the more “famous” variable within its local block

• You can use the keyword this to avoid such a scope clash

• For example, we could have written the set methods like this:void setNumerator (int numerator) {

this.numerator = numerator;}

Method overloading

• The term overloading refers to the use of a program symbol (usually an identifier) to mean more than one thing

• Although Java doesn’t support programmer-defined operator overloading (as C++ does), we can still use the operator + to illustrate the point:– it means addition– it also means concatenation– context determines which meaning applies

Method overloading

• Methods can be overloaded, as follows:– they can have the same name– their parameter lists must differ in some

significant way:• type(s) of argument(s)• number of arguments

– they can represent completely different algorithms

Example: plus method

• We have already defined method plus, which produces the sum of the calling object and another Fraction (the argument to the method)

• To make our Fraction class more versatile, we can overload this method so that it can be used to add a calling Fraction object and an int argument, as illustrated on the next slide

Overloaded plus method

public Fraction plus (int num) {Fraction sum = new Fraction (num, 1);sum = sum.plus(this);return sum;

}

In this instance, the overloaded method incorporates a call to the original method. The compiler distinguishes between the two methods by examining each method’s parameter list. Since the message embedded in the overloaded method is using a Fraction argument (this), the compiler looks for a method named plus with a Fraction parameter, which is easily distinguished from the int parameter in the new method.

Using the plus method

• Client programmers can now call plus using either a Fraction or int argument, as in the examples below:Fraction f1 = new Fraction (2,3),

f2 = new Fraction (3,4);f1 = f1.plus(5);f2 = f1.plus(f2.plus(6));

• We can overload the other arithmetic methods in a similar fashion

Overloading constructors

• Although all the classes we have looked at so far have included a single constructor, it is quite common to have multiple constructors for an object

• Since a constructor always has the same name as its class, then multiple constructors must by definition be overloaded methods

Additional constructors for Fraction class

// default constructor (requires no arguments)public Fraction () {

numerator = 1;denominator = 1;

}

// copy constructor – creates a duplicate object of its argumentpublic Fraction (Fraction f) {

numerator = f.numerator;denominator = f.denominator;

}

// constructor with int argument – creates num/1public Fraction (int num) {

numerator = num;denominator = 1;

}

Examples of calls to Fraction constructors

Fraction f1 = new Fraction (2, 3);// calls original constructor because there are// two int arguments

Fraction f2 = new Fraction();// calls default constructor; creates object with// numerator & denominator both equal to 1

Fraction f3 = new Fraction(5);// calls constructor with single int parameter; // creates object with data value 5/1

Fraction f4 = new Fraction(f1);// calls copy constructor; creates object identical to f1

Alternate definitions for constructors

Another use for keyword this is in the definition of multiple constructors. Consider the definition of the original constructor:

public Fraction (int n, int d) {setNumerator (n);setDenominator (d);

}

Since this constructor already exists, we can use it to define additional constructors. For example:public Fraction () {

this (1, 1);}This is a different way to define the default constructor

Class methods

• As we have previously seen, methods declared with the static keyword are class methods rather than instance methods– class methods are not part of any object– class methods exist independent of any object– all objects of a class share a single copy of

any class method

• The private helper method gcd is an example of a static method

Method gcd

private static int gcd (int m, int n) {int r;while (true) {

r = n%m;if (r == 0) break;n=m;m=r;

}return m;

}

The method is declared private because it only exists as a helper method for the simplify method; it isn’t supposed to be available to client programmers. It is declared static because it is unnecessary to include a new copy of this method for every Fraction object.

A method for comparing two Fractions

• Strategy: pass two Fraction objects to the method, which returns an int value, as follows:o 0 if the Fractions are equalo 1 if the first argument is greater than the secondo -1 if the first argument is less than the second

• Since neither object is the calling object, it makes sense to make this a static method, since then no calling object is necessary

• Another private helper method, toDouble, is used to accomplish the task

The compareTo methodpublic static int compareTo (Fraction f1, Fraction f2) {

double x = f1.toDouble();double y = f2.toDouble();int result;if (x > y)

result = 1;else if (x < y)

result = -1;else

result = 0;return result;

} private double toDouble() {double result;result = (double)numerator / denominator;return result;

}

Notes on class methods

• Class methods can only access class variables and constants, and cannot call instance methods of the same class (except by declaring objects and having them call the methods)

• Instance methods can call all other methods of the same class (without declaring new objects)

Organizing Classes into a Package

• For a class A to use class B, their bytecode files must be located in the same directory.

• This is not practical if we want to reuse programmer-defined classes in many different programs

Organizing Classes into a Package

• The correct way to reuse programmer-defined classes from many different programs is to place reusable classes in a package.

• A package is a Java class library.

Creating a Package

1. Include the statementpackage myutil;

as the first statement of the source file for the Fraction class.

2. The class declaration must include the visibility modifier public as

public class Fraction { ...}

The following steps illustrate the process of creating a package named myutil that includes the Fraction class.

Creating a Package

3. Create a folder named myutil, the same name as the package name. In Java, the package must have a one-to-one correspondence with the folder.

4. Place the modified Fraction class into the myutil folder and compile it.

5. Modify the CLASSPATH environment variable to include the folder that contains the myutil folder.

Using Javadoc Comments

• Many of the programmer-defined classes we design are intended to be used by other programmers.

• It is, therefore, very important to provide meaningful documentation to the client programmers so they can understand how to use our classes correctly.

Using Javadoc Comments

• By adding javadoc comments to the classes we design, we can provide a consistent style of documenting the classes.

• Once the javadoc comments are added to a class, we can generate HTML files for documentation by using the javadoc command.

javadoc for Fraction• This is a portion of

the HTML documentation for the Fraction class shown in a browser.

• This HTML file is produced by processing the javadoc comments in the source file of the Fraction class.

javadoc Tags

• The javadoc comments begins with /** and ends with */

• Special information such as the authors, parameters, return values, and others are indicated by the @ marker @param

@author

@return

etc

Example: javadoc Source

. . .

/*** Returns the sum of this Fraction* and the parameter frac. The sum* returned is NOT simplified.** @param frac the Fraction to add to this* Fraction** @return the sum of this and frac*/public Fraction add(Fraction frac) { ...}. . .

this javadocwill produce

Example: javadoc Output