We are only going to keep track of degrees and minutes, so we began with a class that has fields for each and a constructor:
public class Angle {
private int degrees;
private int minutes;
public Angle(int degrees, int minutes) {
this.degrees = degrees;
this.minutes = minutes;
}
}
We started with some client code that constructed an array of Angle objects and
that printed it out:
import java.util.*;
public class AngleTest {
public static void main(String[] args) {
Angle a1 = new Angle(23, 26);
Angle a2 = new Angle(15, 48);
List<Angle> list = new ArrayList<Angle>();
list.add(a1);
list.add(a2);
System.out.println(list);
}
}
When we ran this program, it produced output like the following:
[Angle@42719c, Angle@30c221]
The text being generated in each case includes the name of the class (Angle)
followed by an at sign followed by a hexadecimal (base 16) address. This is
what the built-in toString method produces. To get better output, we decided
to add a toString method to the class.Ideally we would show something like 23 degrees and 26 minutes using the standard symbols used for degrees and minutes:
23° 26′But those characters aren't easy to work with in Java, so instead we'll settle for "d" for degrees and "m" for minutes:
23d 26mWe wrote the following toString method to produce that output:
public String toString() {
return degrees + "d " + minutes + "m";
}
When we ran the client code again, it produced the following output:
[23d 26m, 15d 48m]
Then I discussed how to include a method that would add two of these angles
together. In a sense, what I'd like to be able to say in the client code is
something like this:
Angle a1 = new Angle(23, 26);
Angle a2 = new Angle(15, 48);
Angle a3 = a1 + a2;
We can't write it that way because the "+" operator is used only for numbers
and String concatenation. Some programming languages like C++ allow you to do
something called "operator overloading," but Java doesn't allow that. So we
have to settle for having a method called "add" that we can use to ask one of
these angles to add another one to it:
Angle a1 = new Angle(23, 26);
Angle a2 = new Angle(15, 48);
Angle a3 = a1.add(a2);
I pointed out that this is a common convention in the Java class libraries.
For example, there is a class called BigInteger for storing very large integers
that has a method called add that is similar.We wrote this as the first version of our add method:
public Angle add(Angle other) {
int d = degrees + other.degrees;
int m = minutes + other.minutes;
return new Angle(d, m);
}
I pointed out that we're referring to other.degrees and other.minutes, which
are private fields. This works because the understanding of the word private
is that it is "private to the class." This is not at all the way that we as
humans understand the meaning of private (if something is private to me, then
it shouldn't be available to other humans). But in Java, one Angle object can
access private elements of another Angle object because they are both of the
same class.I modified the client code to add this angle to the list as well:
Angle a1 = new Angle(23, 26);
Angle a2 = new Angle(15, 48);
Angle a3 = a1.add(a2);
List<Angle> list = new ArrayList<Angle>();
list.add(a1);
list.add(a2);
list.add(a3);
System.out.println(list);
When we ran it, we got the following output:
[23d 26m, 15d 48m, 38d 74m]
Clearly the program has added the two angles to get a third, but the third
angle is listed as having 74 minutes, which isn't right. I mentioned that this
is a good place to apply the idea of a class invariant, which is described in
chapter 8 of the textbook. We want to guarantee that the values for minutes
and seconds are always legal. We can begin by adding a precondition to the
constructor:
// pre: minutes <= 59 and minutes >= 0 and degrees >= 0
public Angle(int degrees, int minutes) {
this.degrees = degrees;
this.minutes = minutes;
}
Then we added code to throw an exception when the precondition was not
satisfied:
// pre: minutes <= 59 and minutes >= 0 and degrees >= 0
// (throws IllegalArgumentException if not true)
public Angle(int degrees, int minutes) {
if (minutes < 0 || minutes > 59 || degrees < 0) {
throw new IllegalArgumentException();
}
this.degrees = degrees;
this.minutes = minutes;
}
But we still needed to handle the case where the minutes become larger than 59.
We were able to fix this with a simple if statement:
public Angle add(Angle other) {
int d = degrees + other.degrees;
int m = minutes + other.minutes;
if (m >= 60) {
m -= 60;
d++;
}
return new Angle(d, m);
}
Because of the class invariant, we know that we don't need more than a simple
if to solve this problem because adding two legal angles together can't require
more than one operation of converting 60 minutes to a degree.It also would have been possible to use integer division and the mod operator to figure this out.
When we ran the code again, we got this output, indicating that it had correctly added the two angles together:
[23d 26m, 15d 48m, 39d 14m]
Then I said that I wanted to explore how to modify the class so that we can put
a collection of Angle objects into sorted order. I added the following client
code to add a specific list of Angle values to our list and then called
Collections.sort to put them into sorted order:
int[][]data = {{30, 19}, {30, 12}, {30, 45}, {30, 8}, {30, 55}};
for (int[] coords : data) {
list.add(new Angle(coords[0], coords[1]));
}
System.out.println(list);
Collections.sort(list);
System.out.println(list);
Unfortunately, this code did not compile. That's because we haven't told Java
how to compare Angle objects to put them into order. For example, we know that
an angle of 45 degrees and 15 minutes is more than an angle of 30 degrees and
55 minutes, but how is Java supposed to figure that out?If you want to use utilities like Arrays.sort and Collections.sort, you have to indicate to Java how to compare values to figure out their ordering. There is an interface in Java known as the Comparable interface that captures this concept.
Not every class implements Comparable because not all data can be put into sorted order in an intuitive way. For example, the Point class does not implement the Comparable interface because it's not clear what would make one two-dimensional point "less than" another two-dimensional point. But many of the standard classes we have seen like String and Integer implement the Comparable interface. Classes that implement the Comparable interface can be used for many built-in operations like sorting and searching. Some people pronounce it as "come-pair-a-bull" and some people pronounce it as "comp-ra-bull". Either pronunciation is okay. The interface contains a single method called compareTo.
public interface Comparable<T> {
public int compareTo(T other);
}
So what does compareTo return? The rule in Java is that:
public class Angle implements Comparable<Angle> {
...
}
We completed the compareTo method fairly quickly. I pointed out that in
general the degrees field tells you which Angle is larger, so we can almost get
by with writing the method this way:
public int compareTo(Angle other) {
return degrees - other.degrees;
}
Consider the case where an Angle object has a value for degrees that is larger
than the other object's value of degrees. Then the expression above returns a
positive integer, which indicates that the object is greater. If an Angle
object has a lower value for degrees than the other one, then this expression
returns a negative value, which indicates that it is less than the other Angle
object.The only case where this fails is when the degree values are equal. In that case, we should use the minutes fields in a similar manner to break the tie. So the right way to code this is as follows:
public int compareTo(Angle other) {
if (degrees == other.degrees) {
return minutes - other.minutes;
} else {
return degrees - other.degrees;
}
}
When we ran the client code with this new version of the code, we got output
like the following:
[23d 26m, 15d 48m, 39d 14m]
[23d 26m, 15d 48m, 39d 14m, 30d 19m, 30d 12m, 30d 45m, 30d 8m, 30d 55m]
[15d 48m, 23d 26m, 30d 8m, 30d 12m, 30d 19m, 30d 45m, 30d 55m, 39d 14m]
Then I mentioned that we were going to talk about the issue of
efficiency. Computer scientists describe this by characterizing the
complexity of an algorithm.The word "complexity" can be interpreted in many ways. It sounds like a measure of how complex or how complicated a program is. For example, jGRASP has a tool under the File menu that allows you to create a "Complexity Profile Graph" of your code, which is a software engineering concept that is somewhat similar to this. But that's not how computer scientists use the term most often. When we refer to the complexity of an algorithm or a code fragment, we most often are referring to the resources that it requires to execute. The two resources that we are generally most interested in are:
Of these two, the resource that computer scientists most often refer to when talking about complexity is time. In particular, we are interested in the growth rate as the input size increases. We begin by deciding on some way to measure the size of the input (e.g., the number of names to sort, the number of numbers to examine, etc) and call this "n". We are interested in what happens when we change n. For example, if it takes time "t" to execute for n items, how much time does it take to execute for 2n items?
I pointed out that this is one of the few places where computer science is actually like a science. Some instructors ask their students to collect empirical timing data for different input sizes and have them plot these values to see if the plot matches the prediction. Unfortunately, these experiments are more difficult to perform on modern computers because features like cache memory skew the results. The important thing is that the predictions hold for large values of n.
I pointed out that I see a lot of undergraduates who obsess about efficiency and I think that in general it's a waste of their time. Many computer scientists have commented that premature optimization is counterproductive. Don Knuth has said that "Premature optimization is the root of all evil." The key is to focus your attention where you can get real benefit. The analogy I'd make is that if you found that a jet airplane weighed too much, you might decide to put the pilot on a diet. While it's true that in some sense every little bit helps, you're not going to make much progress by trying to slim down the pilot when the plane and its passengers and cargo weigh so much more than the pilot. I see lots of undergraduates putting the pilot on a diet while ignoring much more important details.
In terms of the growth rate of different algorithms, I mentioned that some of your intuitions from calculus will be helpful. You've probably been asked to solve problems like figuring out what the limit is as you approach infinity of an expression like this:
n^3 - 18 n^2 + 385 n + 708
--------------------------
0.005 n^4 - 13 n^2 + 73842
When you solve a limit like this, you ignore things like coefficients and you
ignore small terms. What matters here is that you basically have:
n^3
---
n^4
The rest is noise. So this is something that you know is going to approach 0
because eventually the n^4 will dominate the n^3 no matter what the
coefficients and lower-order terms are. We use similar reasoning with
complexity. We ignore constant multipliers and we ignore lower order terms to
focus on the main term.