<?xml version="1.0"?>

<chapter xml:id="classes-in-java">

<title>Classes in Java</title>

<section xml:id="sec-classes-and-objects">

<title>Classes and Objects</title>

<p>

<idx>object-oriented programming</idx> <idx>OOP</idx>

Depending on how deep your knowledge of Python and programming in general is, you may or may not be familiar with classes and objects. These two important <term>Object-Oriented Programming</term> (<term>OOP</term>) concepts will briefly be discussed. If you already have a good understanding of classes and objects in Python, this section may be skipped.

</p>

<p>

<idx>object</idx>

<idx>attribute</idx>

<idx>instance variable</idx>

<idx>method</idx>

<term>Objects</term> in the context of programming are instances of classes. Objects contain <term>attributes</term> (also referred to as <term>instance variables</term>), which are data that describe the object or are associated with the object, and <term>methods</term>, which are special functions used by the object. Methods are typically actions the object can perform, or can be used to make changes to the object's attributes.

</p>

<p>

<idx>class</idx>

<idx>constructor</idx>

<term>Classes</term> can be thought of as being similar to blueprints or a recipe; they hold details of how to create an instance of an object. Classes contain a special method called a <term>constructor</term> that is used to create an instance of an object. Once the object is created, it will use the class definition to define its attributes and call methods.

</p>

<p>

The best way to understand classes and objects is to see them in action. Let's define a <c>Dog</c> class in Python:

</p>

<listing xml:id="python-class-example">

<program interactive="activecode" language="python">

<code>

class Dog:

""" A simple Dog class definition. """

def __init__(self, name, breed, fur_color):

# constructor method to create a Dog object

self.name = name

self.breed = breed

self.fur_color = fur_color

self.trained = False # dogs are not trained by default

print("Dog named " + self.name + " created!")

def bark(self):

# method to make the dog bark

print(self.name + " says woof!")

def sit(self):

# method to make the dog sit

if self.trained: # check if the dog has been trained otherwise it will not sit

print(self.name + " sits.")

else:

print(self.name + " has not been trained.")

def train(self):

# method to train the dog, which will set the trained attribute to True

self.trained = True

</code>

</program>

</listing>

<p>

Let's unpack what is going on in <xref ref="python-class-example" text="type-global"/>. The first line is where we declare the class definition and name it <c>Dog</c>. Next, we have a special method called <c>__init__</c>. This <c>__init__</c> method is the constructor and is required for every Python class definition. Within the <c>__init__</c> method, attributes are defined. As you can see, the attributes <c>name</c>, <c>breed</c>, and <c>fur_color</c> must be defined when creating a Dog object using this class definition, but the <c>trained</c> attribute is defined within the constructor and is initialized as <c>False</c>. We can also have the <c>__init__</c> method run any code, such as the print statement informing us that a Dog object was created.

</p>

<p>

The next three blocks of code are the class's methods. These include <c>bark(self)</c>, <c>sit(self)</c>, and <c>train(self)</c>. As you can see, the class defines attributes (the variables in the <c>__init__</c> method) and methods for instances of the Dog class.

</p>

<p>

<idx><c>self</c></idx>

Within each method, and for each attribute, you will notice the use of <term><c>self</c></term>. This is required in Python. <c>self</c> simply indicates that an attribute or method is being used for a specific instance of an object created with a class.

</p>

<p>

Next, we will use this class to create a new <c>Dog</c> object. We will call this new Dog object <c>my_dog</c>:

</p>

<listing xml:id="python-class-create-object" names="python-class-create-object">

<program interactive="activecode" language="python" >

<code>

class Dog:

""" A simple Dog class definition. """

def __init__(self, name, breed, fur_color):

# constructor method to create a Dog object

self.name = name

self.breed = breed

self.fur_color = fur_color

self.trained = False # dogs are not trained by default

print("Dog named " + self.name + " created!")

def bark(self):

# method to make the dog bark

print(self.name + " says woof!")

def sit(self):

# method to make the dog sit

if self.trained: # check if the dog has been trained otherwise it will not sit

print(self.name + " sits.")

else:

print(self.name + " has not been trained.")

def train(self):

# method to train the dog, which will set the trained attribute to True

self.trained = True

# Create a Dog object called my_dog

my_dog = Dog("Rex", "pug", "brown")

</code>

</program>

</listing>

<p>

In the final line of code in <xref ref="python-class-create-object" text="type-global"/>, we have created an object called <c>my_dog</c>. We have initialized its attributes, setting <c>name</c> to Rex, <c>breed</c> to pug, and <c>fur_color</c> to brown.

</p>

<p>

Now that we have created a <c>Dog</c> object using the class we defined, we can utilize the class's methods:

</p>

<listing xml:id="python-class-full" names="python-class-full">

<program interactive="activecode" language="python">

<code>

class Dog:

""" A simple Dog class definition. """

def __init__(self, name, breed, fur_color):

# constructor method to create a Dog object

self.name = name

self.breed = breed

self.fur_color = fur_color

self.trained = False # dogs are not trained by default

print("Dog named " + self.name + " created!")

def bark(self):

# method to make the dog bark

print(self.name + " says woof!")

def sit(self):

# method to make the dog sit

if self.trained:

print(self.name + " sits.")

else:

print(self.name + " has not been trained.")

def train(self):

# method to train the dog, which will set the trained attribute to True

self.trained = True

my_dog = Dog("Rex", "pug", "brown")

my_dog.bark() # call the bark method

my_dog.sit() # call the sit method

</code>

</program>

</listing>

<note>

<p>

When running <xref ref="python-class-full" text="type-global"/>, the line <c>Rex has not been trained.</c> will appear in the output when calling the <c>sit()</c> method. Try adding a one or more lines of code so that <c>Rex sits.</c> appears in the output!

</p>

</note>

<p>

Now, we have a full class definition and have utilized its methods. Class definitions in Java will be covered thoroughly in chapter 6. For now, it is important to know that Python programs can be written without using classes at all. Java, on the other hand, requires all code to reside in a class. This will be discussed later in chapter 6.

</p>

</section>

<section xml:id="defining-classes-in-java">

<title>Defining Classes in Java</title>

<introduction>

<p>

You have already seen how to define classes in Java.

It&#x2019;s unavoidable for even the simplest of programs.

In this section we will look at how we define classes to create our own data types.

Lets start by creating a fraction class to extend the set of numeric data types provided by our language.

The requirements for this new data type are as follows:

</p>

<p>

<ul>

<li>

<p>

Given a numerator and a denominator create a new Fraction.

</p>

</li>

<li>

<p>

When a fraction is printed it should be simplified.

</p>

</li>

<li>

<p>

Two fractions can be added or subtracted

</p>

</li>

<li>

<p>

Two fractions can be multiplied or divided

</p>

</li>

<li>

<p>

Two fractions can be compared

</p>

</li>

<li>

<p>

A fraction and an integer can be added together.

</p>

</li>

<li>

<p>

Given a list of Fractions that list should be sortable by the default sorting function.

</p>

</li>

</ul>

</p>

<p>

<xref ref="python-fraction-class-all" text="type-global"/> is a mostly complete implementation of a Fraction class in Python that we will refer to throughout this section.

</p>

<listing xml:id="python-fraction-class-all">

<program interactive="activecode" language="python">

<code>

class Fraction:

def __init__(self, num, den):

"""

:param num: The top of the fraction

:param den: The bottom of the fraction

"""

self.num = num

self.den = den

def __repr__(self):

"""

:return: a string representation of the fraction

"""

if self.num &gt; self.den:

retWhole = int(self.num / self.den) # find the whole number part

retNum = self.num - (retWhole * self.den) # find the numerator part

return str(retWhole) + " " + str(retNum) + "/" + str(self.den)

else:

return str(self.num) + "/" + str(self.den)

def show(self):

"""

:return: print the fraction

"""

print(self.num, "/", self.den)

def __add__(self, other):

"""

:param other: the fraction to add

:return: the sum of the two fractions

"""

# convert to a fraction

other = self.toFract(other)

newnum = self.num * other.den + self.den * other.num # find the new numerator

newden = self.den * other.den # find the new denominator

common = gcd(newnum, newden)

return Fraction(int(newnum / common), int(newden / common))

__radd__ = __add__ # allow the fraction to be added to a number

def __lt__(self, other):

"""

:param other: the fraction to compare

:return: whether the fraction is less than the other

"""

num1 = self.num * other.den

num2 = self.den * other.num

return num1 &lt; num2

def toFract(self, n):

"""

:param n: the number to convert to a fraction

:return: the fraction representation of the number

"""

if isinstance(n, int):

other = Fraction(n, 1)

elif isinstance(n, float):

wholePart = int(n)

fracPart = n - wholePart

fracNum = int(fracPart * 100) # convert to 100ths

newNum = wholePart * 100 + fracNum # combine the whole and fractional parts

other = Fraction(newNum, 100)

elif isinstance(n, Fraction):

other = n

else:

print("Error: cannot add a fraction to a ", type(n))

return None

return other

def gcd(m, n):

"""

A helper function for Fraction.

:param m: the first number

:param n: the second number

:return: the greatest common divisor

"""

while m % n != 0: # keep going until the gcd is found

oldm = m

oldn = n

m = oldn

n = oldm % oldn

return n

print(sorted([Fraction(5, 16), Fraction(3, 16), Fraction(1, 16) + 1]))

</code> <tests> </tests>

</program>

</listing>

<p>

<idx>data members</idx>

The instance variables (<term>data members</term>) we will need for our fraction class are the numerator and denominator. Of course in Python we can add instance variables to a class at any time by simply assigning a value to <c>objectReference.variableName</c>, whereas in Java all data members must be declared up front.

</p>

<p>

The declarations of instance variables can come at the beginning of the class definition or the end. Cay Horstman, author of <url href="https://horstmann.com/corejava/index.html" visual="https://horstmann.com/corejava/index.html">the &#x201C;Core Java&#x201D; books</url> puts the declarations at the end of the class. I like them at the very beginning so you see the variables that are declared before you begin looking at the code that uses them. With that in mind <xref ref="java-fraction-class-start" text="type-global"/> shows the first part of the Fraction class definition.

</p>

<listing xml:id="java-fraction-class-start">

<program interactive="activecode" language="java">

<code>

public class Fraction {

private Integer numerator; // notice the private modifier

private Integer denominator;

}

</code>

</program>

</listing>

<p>

<idx>private</idx>

Notice that we have declared the numerator and denominator to be <term>private</term>.

This means that the compiler will generate an error if another method tries to write code like <xref ref="java-private" text="type-global"/>.

</p>

<listing xml:id="java-private">

<program interactive="activecode" language="java">

<code>

Fraction f = new Fraction(1,2);

Integer y = f.numerator * 10; // trying to access the numerator

</code>

</program>

</listing>

<p>

<idx>getter method</idx>

<idx>setter method</idx>

Direct access to instance variables is not allowed in Java.

Therefore if we legitimately want to be able to access information such as the numerator or the denominator for a particular fraction we must have a <term>getter method</term> that returns the needed value.

Hence, it is a very common programming practice to both provide <term>getter methods</term> and <term>setter methods</term> when needed for instance variables in Java. <xref ref="java-getter-and-setter" text="type-global"/> shows how the getter and setter methods are written.

</p>

<listing xml:id="java-getter-and-setter">

<program interactive="activecode" language="java">

<code>

public Integer getNumerator() { // getter method

return numerator;

}

public void setNumerator(Integer numerator) { // setter method

this.numerator = numerator;

}

public Integer getDenominator() { // getter method

return denominator;

}

public void setDenominator(Integer denominator) { // setter method

this.denominator = denominator;

}

</code>

</program>

</listing>

</introduction>

</section>

<section xml:id="writing-a-constructor">

<title>Writing a constructor</title>

<p>

<idx>constructor</idx>

Once you have identified the instance variables for your class the next thing to consider is the constructor.

In Java, <term>constructors</term> have the same name as the class and are declared public.

They are declared without a return type.

So any method that is named the same as the class and has no return type is a constructor.

Our constructor will take two parameters: the numerator and the denominator. <xref ref="java-fraction-constructor" text="type-global"/> shows the constructor for the <c>Fraction</c> class.

</p>

<listing xml:id="java-fraction-constructor">

<program interactive="activecode" language="java">

<code>

public Fraction(Integer top, Integer bottom) {

num = top; // notice the use of num instead of top

den = bottom;

}

</code>

</program>

</listing>

<p>

<idx><c>this</c></idx>

There are a couple of important things to notice here.

First, you will notice that the constructor does not have a <c>self</c> parameter.

You will also notice that we can simply refer to the instance variables by name without the <c>self</c> prefix, because they have already been declared.

This allows the Java compiler to do the work of dereferencing the current Java object.

Java does provide a special variable called <c>this</c> that works like the <c>self</c> variable.

In Java, <c>this</c> is typically only used when it is needed to differentiate between a parameter or local variable and an instance variable.

For example,<xref ref="java-fraction-constructor" text="type-global"/> shows an alternate definition of the the Fraction constructor that uses <c>this</c> to differentiate between parameters and instance variables.

</p>

<listing xml:id="java-fraction-class-this">

<program interactive="activecode" language="java">

<code>

public Fraction(Integer num, Integer den) {

this.num = num; // notice how we use this.num instead of num

this.den = den;

}

</code>

</program>

</listing>

</section>

<section xml:id="methods">

<title>Methods</title>

<introduction>

<p>

Now we come to one of the major differences between Java and Python.

The Python class definition used the special methods for addition and comparison that have the effect of redefining how the standard operators behave: in Python, <c>__add__</c> and <c>__lt__</c> change the behavior of <c>+</c> and <c>&lt;</c>, respectively.

In Java there is no operator overloading.

So we will have to write the method for addition a little differently.

</p>

<p>

A point of terminology: Python has both &#x201C;functions&#x201D; (<c>def</c> outside a class) and &#x201C;methods&#x201D; (<c>def</c> inside a class).

Since Java requires all code to be inside classes, it only has &#x201C;methods.&#x201D; Those from a C++ background might refer to methods as &#x201C;member functions.&#x201D;

</p>

<p>

Before we dive into the <c>add</c> method, it's important to understand how Java passes arguments to methods, as this is a common point of confusion for programmers coming from Python. The terminology is different, but the practical result for objects is effectively identical.

</p>

<p>

<ul>

<li>

<p>

<idx>pass-by-value</idx>

Java is strictly <term>pass-by-value</term>. For primitive types (like <c>int</c>), a copy of the value is passed. For object types (like our <c>Fraction</c>), a copy of the <term>reference</term>(Namely, the memory address) is passed.

</p>

</li>

<li>

<p>

<idx>pass-by-assignment</idx>

<term>Python is pass-by-assignment</term> (or pass-by-object-reference). Since everything in Python is an object, the rule is consistent: a copy of the reference to the object is passed.

</p>

</li>

</ul>

</p>

<p>

What does this mean in practice? <strong>For objects, the behavior is the same in both languages.</strong> When you pass a <c>Fraction</c> object to the <c>add</c> method, both the original variable outside the method and the parameter inside the method (<c>otherFrac</c>) refer to the <strong>exact same object</strong> in memory. This allows the method to use the object's getters to read its state. If you were to call a setter method on <c>otherFrac</c>, the change would be reflected in the original object.

</p>

<p>

However, if you reassign the parameter to a completely new object inside the method (e.g., <c>otherFrac = new Fraction(0,1);</c>), it would <em>not</em> affect the original variable outside the method, because you are only changing the local copy of the reference.

</p>

<p>

<xref ref="java-fraction-class-addition-initial" text="type-global"/> shows the first part of the Fraction class definition.

</p>

<listing xml:id="java-fraction-class-addition-initial">

<program>

<code>

public Fraction add(Fraction otherFrac) {

Integer newNum = otherFrac.getDenominator() * this.numerator +

this.denominator * otherFrac.getNumerator(); // notice the use of this.

Integer newDen = this.denominator * otherFrac.getDenominator(); // find the new denominator

Integer common = gcd(newNum, newDen); // find the greatest common divisor

return new Fraction(newNum/common, newDen/common);

}

</code>

</program>

</listing>

<p>

First you will notice that the <c>add</c> method is declared as <c>public Fraction</c> The <c>public</c> part means that any other method may call the <c>add</c> method.

The <c>Fraction</c> part means that <c>add</c> will return a fraction as its result.

</p>

<p>

Second, you will notice that the method makes use of the <c>this</c> variable.

In this method, <c>this</c> is not necessary, because there is no ambiguity about the <c>numerator</c> and <c>denominator</c> variables.

<xref ref="java-fraction-class-addition-equivalent" text="type-global"/> is an equivalent version of <xref ref="java-fraction-class-addition-initial" text="type-global"/>.

</p>

<listing xml:id="java-fraction-class-addition-equivalent">

<program>

<code>

public Fraction add(Fraction otherFrac) {

Integer newNum = otherFrac.getDenominator() * numerator +

denominator * otherFrac.getNumerator(); // notice the absence of this.

Integer newDen = denominator * otherFrac.getDenominator();

Integer common = gcd(newNum, newDen);

return new Fraction(newNum/common, newDen/common);

}

</code>

</program>

</listing>

<p>

The addition takes place by multiplying each numerator by the opposite denominator before adding.

This procedure ensures that we are adding two fractions with common denominators.

Using this approach the denominator is computed by multiplying the two denominators.

The greatest common divisor method, <c>gcd</c>, is used to find a common divisor to simplify the numerator and denominator in the result.

</p>

<p>

Finally on line 6 a new <c>Fraction</c> is returned as the result of the computation.

The value that is returned by the return statement must match the value that is specified as part of the declaration.

So, in this case the return value on line 8 must match the declared value on line 1.

</p>

</introduction>

<subsection>

<title>Method Signatures and Overloading</title>

<p>

Our specification for this project said that we need to be able to add a <c>Fraction</c> to an <c>Integer</c>.

In Python we can do this by checking the type of the parameter using the <c>isinstance</c> function at runtime.

Recall that <c>isinstance(1,int)</c> returns <c>True</c> to indicate that 1 is indeed an instance of the <c>int</c> class.

See the <c>__add__</c> and <c>toFract</c> methods in the Python version of the <c>Fraction</c> class to see how our Python implementation fulfills this requirement.

</p>

<p>

<idx>method overloading</idx>

In Java we can do runtime type checking, but the compiler will not allow us to pass an Integer to the <c>add</c> method since the parameter has been declared to be a Fraction.

The way that we solve this problem is by writing another <c>add</c> method with a different set of parameters.

In Java this practice is legal and common we call this practice <term>method overloading</term>.

</p>

<p>

<idx>signature</idx>

This idea of method overloading raises a very important difference between Python and Java.

In Python a method is known by its name only.

In Java a method is known by its signature.

The <term>signature</term> of a method includes its name, and the types of all of its parameters.

The name and the types of the parameters are enough information for the Java compiler to decide which method to call at runtime.

</p>

<p>

To solve the problem of adding an <c>Integer</c> and a <c>Fraction</c> in Java we will overload both the constructor and the <c>add</c> method.

We will overload the constructor so that if it only receives a single <c>Integer</c> it will convert the <c>Integer</c> into a <c>Fraction</c>.

We will also overload the <c>add</c> method so that if it receives an <c>Integer</c> as a parameter it will first construct a <c>Fraction</c> from that integer and then add the two <c>Fractions</c> together.

<xref ref="java-method-overloading" text="type-global"/> shows the new methods that accomplish this task.

</p>

<listing xml:id="java-method-overloading">

<program>

<code>

public Fraction(Integer num) {

this.numerator = num; // set the numerator to the Integer

this.denominator = 1;

}

public Fraction add(Integer other) { // overload the add method when the parameter is an Integer

return add(new Fraction(other));

}

</code>

</program>

</listing>

<p>

Notice that the overloading approach can provide us with a certain elegance to our code.

Rather than utilizing if statements to check the types of parameters we just overload methods ahead of time which allows us to call the method we want and allow the compiler to make the decisions for us.

This way of thinking about programming takes some practice.

</p>

<p>

Our full <c>Fraction</c> class to this point would look <xref ref="java-full-fraction-class" text="type-global"/>.

You should compile and run the program to see what happens.

</p>

<listing xml:id="java-full-fraction-class">

<program interactive="activecode" language="java">

<code>

public class Fraction {

private Integer numerator;

private Integer denominator;

public Fraction(Integer num, Integer den) { // constructor that takes two Integers

this.numerator = num;

this.denominator = den;

}

public Fraction(Integer num) { // constructor that takes a single Integer, sets the denominator to 1

this.numerator = num;

this.denominator = 1;

}

public Integer getNumerator() {

return numerator;

}

public Integer getDenominator() {

return denominator;

}

public Fraction add(Fraction other) {

Integer newNum = other.getDenominator()*this.numerator + this.denominator*other.getNumerator();

Integer newDen = this.denominator * other.getDenominator();

Integer common = gcd(newNum,newDen);

return new Fraction(newNum/common, newDen/common );

}

public Fraction add(Integer other) { // overload the add method when the parameter is an Integer

return add(new Fraction(other));

}

private static Integer gcd(Integer m, Integer n) { // a helper method for the add method

while (m % n != 0) {

Integer oldm = m;

Integer oldn = n;

m = oldn;

n = oldm%oldn;

}

return n;

}

public static void main(String[] args) { // a main method

Fraction f1 = new Fraction(1,2);

System.out.println(f1.add(1));

}

}

</code> <tests> </tests>

</program>

</listing>

<p>

If you ran <xref ref="java-full-fraction-class" text="type-global"/>, you probably noticed that the output is not very satisfying. Chances are your output looked something like <xref ref="java-no-friendly-output" text="type-global"/>.

</p>

<listing xml:id="java-no-friendly-output">

<program language="java">

<code>

Fraction@6ff3c5b5

</code>

</program>

</listing>

<p>

The reason is that we have not yet provided a friendly string representation for our <c>Fraction</c> objects.

Just like in Python, whenever an object is printed by the <c>println</c> method it must be converted to string format.

In Python you can control how that looks by writing an <c>__str__</c> method for your class.

If you do not then you will get the default, which looks something like <xref ref="java-no-friendly-output" text="type-global"/>. We will see how to provide a friendly string representation for our <c>Fraction</c> class in <xref ref="inheritance" text="type-global"/>.

</p>

<exercise label="java_method_overloading_parsons">

<statement>

<p>

Rearrange the blocks to create a <c>Printer</c> class with two overloaded <c>printData</c> methods—one that accepts an <c>int</c> and another that accepts a <c>String</c>.

</p>

</statement>

<blocks>

<block order="1">

<cline>public class Printer {</cline>

</block>

<block order="2">

<choice correct="yes">

<cline> public void printData(int number) {</cline>

<cline> System.out.println("Number: " + number);</cline>

<cline> }</cline>

</choice>

<choice correct="no">

<cline> public void printData(int number) {</cline>

<cline> System.out.println("Number: " + number);</cline>

</choice>

</block>

<block order="3">

<choice correct="yes">

<cline> public void printData(String text) {</cline>

<cline> System.out.println("Text: " + text);</cline>

<cline> }</cline>

</choice>

<choice correct="no">

<cline> public void printData(int text) {</cline>

<cline> System.out.println("Text: " + text);</cline>

<cline> }</cline>

</choice>

</block>

<block order="4">

<cline>}</cline>

</block>

</blocks>

</exercise>

</subsection>

</section>

<section xml:id="inheritance">

<title>Inheritance</title>

<subsection>

<title>The <c>Object</c> Class</title>

<p>

<idx><c>toString</c></idx>

In Java, the equivalent of <c>__str__</c> is the <c>toString</c> method.

Every object in Java already has a <term> <c>toString</c> method</term> defined for it because every class in Java automatically inherits from the <c>Object</c> class.

The <c>Object</c> class provides default implementations for the following methods.

</p>

<p>

<ul>

<li>

<p>

<c>clone</c>

</p>

</li>

<li>

<p>

<c>equals</c>

</p>

</li>

<li>

<p>

<c>finalize</c>

</p>

</li>

<li>

<p>

<c>getClass</c>

</p>

</li>

<li>

<p>

<c>hashCode</c>

</p>

</li>

<li>

<p>

<c>notify</c>

</p>

</li>

<li>

<p>

<c>notifyAll</c>

</p>

</li>

<li>

<p>

<c>toString</c>

</p>

</li>

<li>

<p>

<c>wait</c>

</p>

</li>

</ul>

</p>

<p>

We are not interested in most of the methods on that list, and many Java programmers live happy and productive lives without knowing much about most of the methods on that list.

However, to make our output nicer we will implement the <c>toString</c> method for the <c>Fraction</c> class. <xref ref="java-tostring" text="type-global"/> shows a simple version of the method.

</p>

<listing xml:id="java-tostring">

<program language="java">

<code>

public String toString() {

return numerator.toString() + "/" + denominator.toString(); // convert to a string

}

</code>

</program>

</listing>

<p>

<idx><c>equals</c></idx>

The other important class for us to implement from the list of methods inherited from <c>Object</c> is the <c>equals</c> method.

In Java, when two objects are compared using the <c>==</c> operator they are tested to see if they are exactly the same object (that is, do the two objects occupy the same exact space in the computer&#x2019;s memory?).

This is also the default behavior of the <c>equals</c> method provided by <c>Object</c>.

The <c>equals</c> method allows us to decide if two objects are equal by looking at their instance variables.

However it is important to remember that since Java does not have operator overloading <em>if you want to use your</em> <c>equals</c> <em>method you must call it directly</em>.

Therefore once you write your own <c>equals</c> method:

</p>

<listing xml:id="java-class-equal-equal">

<program>

<code>

object1 == object2 // this checks to see if the two objects are the same object in memory

</code>

</program>

</listing>

<p>

<xref ref="java-class-equal-equal" text="type-global"/> is NOT the same as <xref ref="java-class-dot-equals" text="type-global"/>.

</p>

<listing xml:id="java-class-dot-equals">

<program>

<code>

object1.equals(object2) // this checks to see if the two objects are equal by looking at their instance variables

</code>

</program>

</listing>

<p>

<xref ref="java-fraction-equals" text="type-global"/> is an <c>equals</c> method for the <c>Fraction</c> class.

</p>

<listing xml:id="java-fraction-equals">

<program language="java">

<code>

public boolean equals(Fraction other) { // check if this fraction is equal to another fraction

Integer num1 = this.numerator * other.getDenominator();

Integer num2 = this.denominator * other.getNumerator();

if (num1 == num2)

return true;

else

return false;

}

</code>

</program>

</listing>

<p>

One important thing to remember about <c>equals</c> is that it only checks to see if two objects are equal &#x2013; it does not have any notion of less than or greater than.

We&#x2019;ll see more about that shortly.

</p>

</subsection>

<subsection>

<title>Abstract Classes and Methods</title>

<p>

<idx>abstract class</idx>

If we want to make our <c>Fraction</c> class behave like <c>Integer</c>, <c>Double</c>, and the other numeric classes in Java then we need to make a couple of additional modifications to the class.

The first thing we will do is plug <c>Fraction</c> into the Java class hierarchy at the same place as <c>Integer</c> and its siblings.

If you look at the documentation for <c>Integer</c> you will see that <c>Integer</c>&#x2019;s parent class is <c>Number</c>.

Number is an <term>abstract class</term> that specifies several methods that all of its children must implement.

In Java an abstract class is more than just a placeholder for common methods.

In Java an abstract class has the power to specify certain methods that all of its children <em>must</em> implement.

You can trace this power back to the strong typing nature of Java.

</p>

<p>

<xref ref="java-class-extends" text="type-global"/> makes the <c>Fraction</c> class a child of <c>Number</c>.

</p>

<listing xml:id="java-class-extends">

<program>

<code>

public class Fraction extends Number { // fraction class is a child of Number

...

}

</code>

</program>

</listing>

<p>

<idx><c>extending a class</c></idx>

The keyword <term><c>extends</c></term> tells the compiler that the class <c>Fraction</c> extends, or adds new functionality to the <c>Number</c> class.

A child class always extends its parent.

</p>

<p>

The methods we must implement if <c>Fraction</c> is going to be a child of <c>Number</c> are:

</p>

<p>

<ul>

<li>

<p>

<c>longValue</c>

</p>

</li>

<li>

<p>

<c>intValue</c>

</p>

</li>

<li>

<p>

<c>floatValue</c>

</p>

</li>

<li>

<p>

<c>doubleValue</c>

</p>

</li>

</ul>

</p>

<p>

This really isn&#x2019;t much work for us to implement these methods, as all we have to do is some type conversion and some division as shown in <xref ref="java-object-type-conversions" text="type-global"/>.

</p>

<listing xml:id="java-object-type-conversions">

<program language="java">

<code>

public double doubleValue() { // convert to a double

return numerator.doubleValue() / denominator.doubleValue();

}

public float floatValue() { // convert to a float

return numerator.floatValue() / denominator.floatValue();

}

public int intValue() { // convert to an int

return numerator.intValue() / denominator.intValue();

}

public long longValue() { // convert to a long

return numerator.longValue() / denominator.longValue();

}

</code>

</program>

</listing>

<p>

<idx>is-a</idx>

By having the <c>Fraction</c> class extend the <c>Number</c> class we can now pass a <c>Fraction</c> to any Java method that specifies it can receive a <c>Number</c> as one of its parameters.

For example many Java user interface methods accept any object that is a subclass of <c>Number</c> as a parameter.

In Java the class hierarchy and the &#x201C;<term>is-a</term>&#x201D; relationships are very important.

Whereas in Python you can pass any kind of object as a parameter to any method or function, the strong typing of Java makes sure that you only pass an object as a parameter that is of the type specified in the method signature, or one of the children of the type specified.

When you see a parameter of type <c>Number</c> it&#x2019;s important to remember that an <c>Integer</c> <em>is-a</em> <c>Number</c> and a <c>Double</c> <em>is-a</em> <c>Number</c> and a <c>Fraction</c> <em>is-a</em> <c>Number</c>, because these classes are children of <c>Number</c>.

</p>

<p>

However, and this is a big however, it is important to remember that if you specify <c>Number</c> as the type of a particular parameter then the Java compiler will <em>only let you use the methods of a</em> <c>Number</c>: <c>longValue</c>, <c>intValue</c>, <c>floatValue</c>, and <c>doubleValue</c>.

</p>

<p>

Suppose you try to define a method as <xref ref="java-ugly-add-method" text="type-global"/>.

</p>

<listing xml:id="java-ugly-add-method">

<program language="java">

<code>

public void test(Number a, Number b) {

a.add(b); // this is a bad idea

}

</code>

</program>

</listing>

<p>

The Java compiler would give an error because <c>add</c> is not a defined method of the <c>Number</c> class.

You will <em>still get this error</em> even if all your code that calls this <c>test</c> method passes two <c>Fractions</c> as parameters (remember that <c>Fraction</c> does implement <c>add</c>).

</p>

</subsection>

<exercise xml:id="java-inheritance-parsons-exercise" label="java-inheritance-parsons">

<statement>

<p>

Construct the <c>toString</c> method for the <c>Fraction</c> class so that printing a

fraction shows it in the form numerator/denominator. Drag the blocks into the correct order on the right.

</p>

</statement>

<blocks>

<block order="1">

<choice correct="yes">

<cline>public String toString() {</cline>

</choice>

<choice correct="no">

<cline>public void toString() {</cline>

</choice>

</block>

<block order="2">

<choice correct="yes">

<cline> return numerator.toString() + "/" + denominator.toString();</cline>

</choice>

<choice correct="no">

<cline> numerator.toString() + "/" + denominator.toString();</cline>

</choice>

</block>

<block order="3">

<cline>}</cline>

</block>

</blocks>

</exercise>

</section>

<section xml:id="interfaces">

<title>Interfaces</title>

<p>

<idx>single inheritance</idx>

Lets turn our attention to making a list of fractions sortable by the standard Java sorting method <c>Collections.sort</c>.

In Python, we would just need to implement the <c>__cmp__</c> method.

But in Java we cannot be that informal.

In Java, things that are sortable must be <c>Comparable</c>.