Lets look at a Java Program¶

A time honored tradition in Computer Science is to write a program called “hello world.” The “hello world” program is simple and easy. There are no logic errors to make, so getting it to run relies only on understanding the syntax. To be clear lets look a a “complicated” version of hello world for Python:

def main():
    print "Hello World!"

Remember that we can define this program right at the Python command line and then run it:

>>> main()
"Hello World!"
>>>

Now lets look at the same program written in Java:

public class Hello {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }

}

What we see is that at the core there are a few similarities, such as a main and the string “Hello World” However there is a lot more stuff around the edges that make it harder to see the core of the program. Do not worry! An important skill for a computer scientist is to learn what to ignore and what to look at carefully. You will soon find that there are some elements of Java that will fade into the background as you become used to seeing them. One thing that will help you is to learn a little bit about Java Naming Conventions.

The first question you probably have about this little program is “How do I run it?” Running a Java program is not as simple as running a Python program. The first thing you need to do with a Java program is compile it. The first big difference between Java and Python is that Python is an interpreted language. We could run our Python programs in the Python interpreter and we were quite happy to do that. Java makes running programs a two step process. First we must type the hello world program into a file and save that file using the name Hello.java The file name must be the same as the public class you define in the file. Once we have saved the file we compile it from the command line as follows:

$ javac Hello.java
$ ls -l Hello.*
-rw-r--r--   1 bmiller  bmiller  391 Jul 19 17:47 Hello.class
-rw-r--r--   1 bmiller  bmiller  117 Jul 19 17:46 Hello.java

The command javac compiles our java source code into compiled byte code and saves it in a file called Hello.class. Hello.class is a binary file so you won’t learn much if you try to examine the class file with an editor. Hopefully you didn’t make any mistakes, but if you did you may want to consult Common Mistakes for helpful hints on compiler errors.

Now that we have compiled our java source code we can run the compiled code using the java command.

$ java Hello
Hello World!
$

Now you may be wondering what good is that extra step? What does compiling do for us? There are a couple of important benefits we get from compiling:

• Early detection of errors
• Faster Program Execution

The job of the compiler is to turn your java code into language that the Java Virtual Machine (JVM) can understand. We call the code that the JVM understands byte code. The JVM interprets the byte code much like the Python interpreter interprets your Python. However since byte code is much closer to the native language of the computer it can run faster.

When the compiler does the translation it can find many different kinds of errors. For example if you make a typo the compiler will find the typo and point it out to you before you ever run the program. We will look at some examples of compiler errors shortly. Chances are you will create some on your own very soon too.

The online server combines the compile and execute steps when you click on Run in the book..

Now that we have run our hello world program, lets go back and look at it carefully to see what we can learn about the Java language. This simple example illustrates a few very important rules:

1. Every Java program must define a class, all code is inside a class.
2. Everything in Java must have a type
3. Every Java program must have a function called public static void main(String[] args) in a file with the name of the class, with ”.java” appended.

Lets take the hello world example a line at a time to see how these rules are applied. On line 1 we see that we are declaring a class called Hello. As rule 1 says all Java code resides inside a class. Unlike Python where a program can simply be a bunch of statements in a file, Java programs must be inside a class. So, we define a class, Hello is not a very useful class it has no instance variables, and only one method. You will also notice the curly brace { In Java blocks of code are identified by pairs of curly braces. The block starts with a { and ends with a }. You will notice that I indented my code that followed the left brace, but in Java this is only done by convention it is not enforced.

On the next line we start our method definition. The name of this method is:

public static void main(String[] args)

Everything on this line is significant, and helps in the identification of this method. For example the following lines look similar but are in fact treated by Java as completely different methods:

• public void main(String[] args)
• public static void main(String args)
• public static void main()
• void main(String args)

Just digging in to this one line will take us deep into the world of Java, so we are going to start digging but we are not going to dig too deeply right away. Much of what could be revealed by this one line is better understood through other examples, so be patient.

The first word, public indicates to the Java compiler that this is a method that anyone can call. We will see that Java enforces several levels of security on the methods we write, including public, protected, and private methods.

The next word, static tells Java that this is a method that is part of the class, but is not a method for any one instance of the class (like @staticmethod in Python). The kind of methods we typically wrote in Python required an instance in order for the method to be called. With a static method, the object to the left of the . is a class, not an instance of the class. For example the way that we would call the main method directly is: Hello.main(parameter1). For now you can think of static methods the same way you think of methods in Python modules that don’t require an instance, for example the math module contains many methods: sin, cos, etc. You probably evaluated these methods using the names math.cos(90) or math.sin(60).

The next word, void tells the Java compiler that the method main will not return a value. This is roughly analogous to omitting the return statement in a Python method. In other words the method will run to completion and exit but will not return a value that you can use in an assignment statement. As we look at other examples we will see that every Java function must tell the compiler what kind of an object it will return. This is in keeping with the rule that says everything in Java must have a type. In this case we use the special type called void which means no type.

Next we have the proper name for the method: main. The rules for names in Java are similar to the rules in Python. Names can include letters, numbers, and the _. Names in Java must start with a letter.

Finally we have the parameter list for the method. In this example we have one parameter. The name of the parameter is args however, because everything in Java must have a type we also have to tell the compiler that the value of args is an array of strings. For the moment You can just think of an array as being the same thing as a list in Python. The practical benefit of declaring that the method main must accept one parameter and the parameter must be a an array of strings is that if you call main somewhere else in your code and and pass it an array of integers or even a single string, the compiler will flag it as an error.

That is a lot of new material to digest in only a single line of Java. Lets press on and look at the next line: System.out.println("Hello World!");. Python has some global functions, like print. In Java everything is in a class. This line should look a bit more familiar to you. Python and Java both use the dot notation for finding names. In this example we start with System. System is a class. Within the system class we find the object named out. The out object is the standard output stream for this program. Having located the out object Java will now call the method named println(String s) on that object. The println method prints a string and adds a newline character at the end. Anywhere in Python that you used the print function (without a keyword argument for end) you will use the System.out.println method in Java.

Now there is one more character on this line that is significant and that is the ; at the end. In Java the ; signifies the end of a statement. Unlike Python where statements are almost always only one line long java statements can spread across many lines. The compiler knows it has reached the end of a statement when it encounters a ;. This is a very important difference to remember. In Java the following statements are all legal and equivalent. I would not encourage you to write your code like this, but you should know that it is legal.

System.out.println("Hello World");
System.out.println("Hello World")
;
System.out.println
    (
     "Hello World"
    )     ;
System.
  out.
    println("Hello World")
    ;

The last two lines of the hello world program simply close the two blocks. The first or outer block is the class definition. The second or inner block is the function definition.

If we wanted to translate the Java back to Python we would have something like the following class definition.

class Hello(object):
    @staticmethod
    def main(args):
        print "Hello World!"

Notice that we used the decorator @staticmethod to tell the Python interpreter that main is going to be a static method. The impact of this is that we don’t have to, indeed we should not, use self as the first parameter of the main method! Using this definition we can call the main method in a Python session like this:

>>> Hello.main("")
Hello World!
>>>

Numeric¶

One of the great things about Python is that all of the basic data types are objects. Integers are objects, floating point numbers are objects, lists are objects, everything. In Java that is not the case. In Java some of the most basic data types like integers and floating point numbers are not objects. The benefit of having these primitive data types be non-objects is that operations on the primitives are fast. The problem is that it became difficult for programmers to combine objects and non-objects in the way that we do in Python. So, eventually all the non-object primitives ended up with Objectified versions.

In older versions of Java it was the programmers responsibility to convert back and forth from a primitive to an object whenever necessary. This processing of converting a primitive to an object was called “boxing.” The reverse process is called “unboxing.” In Java 5, the compiler became smart enough to know when to convert back and forth and is called “autoboxing”, for instance when passing an int to a function expecting an Integer.

Only Boolean (Python bool) and Double (Python float) are direct arithmetic matches. The Boolean literals are slightly different: capitalized in Python, not in Java (true, false).

Because the Java primitive types are stored in fixed-size spaces, as a Python float is, they have restrictions:

long

64 bits; range -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

int

32 bits; range -2,147,483,648 to 2,147,483,647

double

64 bits; maximum magnitude: \(1.7976931348623157(10^{308})\); about 15 digits of accuracy

float

32 bits; maximum magnitude: \(3.402823(10^{38})\); about 7 digits of accuracy

A char is a single character, with literals in single quotes, like ‘x’. In Java this is distinct from a String, even a String with one character, like “x”.

Lets go back in time and look at another of our very early Python programs. Here is a simple Python function to convert a Fahrenheit temperature to Celsius.

def main():
    fahr = float(input("Enter the temperature in F: "))
    cel = (fahr - 32) * 5.0/9.0
    print "the temperature in C is: ", cel

main()

Next, lets look at the Java Equivalent.

import java.util.Scanner;

public class TempConv {
    public static void main(String[] args) {
        double fahr;
        double cel;
        Scanner in;

        in = new Scanner(System.in);
        System.out.println("Enter the temperature in F: ");
        fahr = in.nextDouble();

        cel = (fahr - 32) * 5.0/9.0;
        System.out.println("The temperature in C is: " + cel);
    }

}

There are several new concepts introduced in this example. We will look at them in the following order:

• Import
• Variable Declaration
• Input/Output and the Scanner Class

TempConv.java:13: cannot find symbol
symbol  : variable cel
location: class TempConv
         cel = (fahr - 32) * 5.0/9.0;
         ^
TempConv.java:14: cannot find symbol
symbol  : variable cel
location: class TempConv
         System.out.println("The temperature in C is: " + cel);
                                                          ^
2 errors

import javax.swing.*;

public class TempConvGUI {

    public static void main(String[] args) {
        String fahrString;
        double fahr, cel;

        fahrString = JOptionPane.showInputDialog("Enter the temperature in F");
        fahr = new Double(fahrString);
        cel = (fahr - 32) * 5.0/9.0;

        JOptionPane.showMessageDialog(null,"The temperature in C is, " + cel);
    }

}

String¶

Strings in Java and Python are quite similar. Like Python, Java strings are immutable. However, manipulating strings in Java is not quite as obvious since Strings do not support an indexing or slicing operator. That is not to say that you can’t index into a Java string, you can. You can also pull out a substring just as you can with slicing. The difference is that Java uses method calls where Python uses Operators.

In fact this is the first example of another big difference between Java and Python. Java does not support any operator overloading. Table 3 maps common Python string operations to their Java counterparts. For the examples shown in the table we will use a string variable called “str”

The example for split was chosen carefully. For Java there must be a parameter, and it is a regular expressions, or regex for short: another specialized language with variants embedded in many programming languages. To match the behavior of a Python string parameter, treated verbatim, you need to escape any of the following characters you use: []{}()+*^$?

The regex escape character is \, but unfortunately that is also the string escape character, so to get it to the regex, it, too, needs to be escaped. So if you wanted to split on +, you would need str.split("\\+").

The analog for str.split() (no Python parameter) is trickier. Python ignores white space on either end, and splits out tokens with any number of whitespace characters in between. Java will generate empty strings in the list if there is whitespace at the beginning, and you need a regex to handle multiple whitespace characters together, so to match Python you need the mouthful str.trim().split("\\s+").

List¶

Lets look at another early Python program. We are going to read numbers from a file and produce a histogram that shows the frequency of the various numbers. The data file we will use has one number between 0 and 9 on each line of the file. Here is a simple Python program that creates and prints a histogram.

def main():
    count = [0]*10
    data = open('test.dat')

    for line in data:
        count[int(line)] = count[int(line)] + 1

    idx = 0
    for num in count:
        print(idx, " occured ", num, " times.")
        idx += 1

Now if we run this program on a data file that looks like this:

9 8 4 5 3 5 2 1 5

We will get output that looks like this:

0 occurred 0 times
1 occurred 1 times
2 occurred 1 times
3 occurred 1 times
4 occurred 1 times
5 occurred 3 times
6 occurred 0 times
7 occurred 0 times
8 occurred 1 times
9 occurred 1 times

Lets review what is happening in this little program. In the first line we create a list and initialize the first 10 positions in the list to be 0. Next we open the data file called ‘test.dat’ Third, we have a loop that reads each line of the file. As we read each line we convert it to an integer and increment the counter at the position in the list indicated by the number on the line we just read. Finally we iterate over each element in the list printing out both the position in the list and the total value stored in that position.

To write the Java version of this program we will have to introduce several new Java concepts. First, you will see the Java equivalent of a list, called an ArrayList. Next you will see three different kinds of loops used in Java. Two of the loops we will use are going to be very familiar, the third one is different from what you are used to in Python but is easy when you understand the syntax:

while

Used with boolean expression for loop exit condition.

for

Used to iterate over a sequence. This is very similar to for i in xxx where xxx is a list or string or file.

for

Used to iterate through a sequence of numbers. This is most similar to for i in range(), except the syntax is different.

Here is the Java code needed to write the exact same program:

import java.util.Scanner;
import java.util.ArrayList;
import java.io.File;
import java.io.IOException;

public class Histo {

    public static void main(String[] args) {
        Scanner data = null;
        ArrayList<Integer> count;
        int idx;

        try {
                data = new Scanner(new File("test.dat"));
        }
        catch ( IOException e) {
            System.out.println("Sorry but I was unable to open your data file");
            e.printStackTrace();
            System.exit(0);
        }

        count = new ArrayList<Integer>();
        for (int i =0; i<10; i++) {
            count.add(0);
        }

        while(data.hasNextInt()) {
            idx = data.nextInt();
            count.set(idx,count.get(idx)+1);
        }

        idx = 0;
        for(int i : count) {
            System.out.println(idx + " occurred " + i + " times.");
            idx++;
        }
    }
}

Example test.dat:

1 2 3
4 5
6
7
8 9 1 2 3
4
5

Before going any further, I suggest you try to compile the above program and run it on some test data that you create.

Now, lets look at what is happening in the Java source. As usual we declare the variables we are going to use at the beginning of the method. In this example we are declaring a Scanner variable called data, an int called idx and an ArrayList called count. However, there is a new twist to the ArrayList declaration. Unlike Python where lists can contain just about anything, in Java we let the compiler know what kind of objects our array list is going to contain. In this case the ArrayList will contain Integers. The syntax we use to declare what kind of object the list will contain is the <Type> syntax.

Technically, you don’t have to declare what is going to be on an array list. The compiler will allow you to leave the <``*Type*>`` off the declaration. If you don’t tell Java what kind of object is going to be on the list Java will give you a warning message like this:

Note: Histo.java uses unchecked or unsafe operations.
Note: Recompile with -Xlint:unchecked for details.

Without the <Integer> part of the declaration Java simply assumes that any object can be on the list. However, without resorting to an ugly notation called casting, you cannot do anything with the objects on a list like this! So, if you forget you will surely see more errors later in your code. (Try it and see what you get)

Lines 13—20 are required to open the file. Why so many lines to open a file in Java? The additional code mainly comes form the fact that Java forces you to reckon with the possibility that the file you want to open is not going to be there. If you attempt to open a file that is not there you will get an error. A try/catch construct allows us to try things that are risky, and gracefully recover from an error if one occurs. The following example shows the general structure of a try catch block.

try {
   Put some risky code in here.... like opening a file
}
catch (Exception e) {
   If an error happens in the try block an exception is thrown.
   We will catch that exception here!
}

Notice that in line 16 we are catching an IOException. In fact we will see later that we can have multiple catch blocks to catch different types of exceptions. If we want to be lazy and catch any old exception we can catch an Exception which is the parent of all exceptions.

The statement e.printStackTrace(); prints a stack trace something like] when Python bombs out. The statement System.exit(0); terminates the program, no matter how deep the stack is. The 0 is a value returned to the operating system. A 0 usually means success. A different value might make sense here.

On line 22 we create our array list. It will grow or shrink dynamically as needed just like a list in Python.

On line 23 we start the first of three loops. The for loop on lines 23–25 serves the same purpose as the Python statement count = [0]*10. Java does not have the Python multiplication operator for lists. Instead it adds 0 to the empty list (appends in Python), 10 times.

The syntax of this for loop probably looks very strange to you, but in fact it is not too different from what happens in Python using range. In fact for(int i = 0; i < 10; i++) is exactly equivalent to the Python for i in range(10) The first statement inside the parenthesis declares and initializes a loop variable i. The second statement is a Boolean expression that is our exit condition. In other words we will keep looping as long as this expression evaluates to true. The third clause is used to increment the value of the loop variable at the end of iteration through the loop. In fact i++ is Java shorthand for i = i + 1 or i += 1 that also exist in Python. Java also supports the shorthand i-- to decrement the value of i. Try to rewrite the following Python for loops as Java for loops:

• for i in range(2,101,2)
• for i in range(1,100)
• for i in range(100,0,-1)
• for x,y in zip(range(10),range(0,20,2)) [hint, you can separate statements in the same clause with a ,]

Note that zip creates a sequence of tuples or corresponding elements of multiple sequences. zip(range(10),range(0,20,2))) produces the sequence (0, 0), (1, 2), (2, 4), (3, 6), (4, 8), (5, 10), (6, 12), (7, 14), (8, 16), (9, 18).

The next loop (lines 27–30) shows a typical Java pattern for reading data from a file. Java while loops and Python while loops are identical in their logic. In this case we will continue to process the body of the loop as long as data.hasNextInt() returns true. This is a well-named method: true if there is a next token and if that token can be interpreted as an int. There are corresponding methods for the other types a Scanner can read.

Line 29 illustrates another important difference between Python and Java. Notice that in Java we can not write count[idx] = count[idx] + 1. This is because in Java there is no overloading of operators. Square brackets are used only for accessing array elements by index. Everything except the most basic math and logical operations is done using methods. So, to set the value of an ArrayList element we use the set method. The first parameter of set indicates the index or position in the ArrayList we are going to change. The next parameter is the value we want to set. Notice that once again we cannot use the indexing square bracket operator to retrieve a value from the list, but we must use the get method.

The last loop in this example is similar to the Python for loop where the object of the loop is a Sequence. Note that the introduction of a new variable i here, requires a type for i to be declared.

To distinguish this form of for statement fromt he earlier one, it is sometimes called a for-each statement. In Java we can use this kind of for loop over all kinds of sequences, which are called Collection classes in Java. The for loop on line 33 for(int i : count) is equivalent to the Python loop for i in count: This loop iterates over all of the elements in the ArrayList called count. Each time through the loop the Integer variable i is bound to the next element of the ArrayList. If you tried the experiment of removing the <Integer> part of the ArrayList declaration you probably noticed that you had an error on this line. Why?

List methods: Suppose w and w2 are lists of strings –

If you want to iterate over w[2:4] and not change anything in the list, w.subList(2,4) is an analog, but it does not create a new list: it is a view of w. The analog of w2 = w[2:4], which copies item references to a new list, is w2 = new ArrayList<String>(w.subList(2,4)).

Joining is a string method that uses string lists. To separate with ", " the strings in list sList:

', '.join(sList) in Python

String.join(", ", sList) in Java

In Java sList can be a more general iterable sequence of Strings, including an array of Strings.

For more extensive use of Java ArrayLists, you will want to see its documentation, https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html.

Arrays¶

As I said at the outset of this Section we are going to use Java ArrayLists because they are easier to use and more closely match the way that Python lists behave. However, if you look at Java code on the internet or even in your Core Java books you are going to see examples of something called arrays. In fact you have already seen one example of an array declared in the ‘Hello World’ program. Lets rewrite this program to use primitive arrays rather than array lists.

import java.util.Scanner;
import java.io.File;
import java.io.IOException;

public class HistoArray {
    public static void main(String[] args) {
        Scanner data = null;
        int[] count = new int[10];
        int idx;


        try {
                data = new Scanner(new File("test.dat"));
        }
        catch ( IOException e) {
            System.out.println("Sorry but I was unable to open your data file");
            e.printStackTrace();
            System.exit(0);
        }

        while(data.hasNextInt()) {
            idx = data.nextInt();
            count[idx] = count[idx] + 1;
        }

        idx = 0;
        for(int i : count) {
            System.out.println(idx + " occurred " + i + " times.");
            idx++;
        }
    }
}

The main difference between this example and the previous example is that we declare count to be an array of integers. The length must be specified when the new object is created. In general when instantiating a new object the new must be included.

Java objects are always intialized when created. Numeric arrays are initialized to all 0’s, which is what we want here.

Then notice that on line 24 we can use the square bracket notation to index into an array.

We also can initialize short arrays directly using a sequence of values in braces. The array of 10 0’s could have been initialized

int[] count = {0,0,0,0,0,0,0,0,0,0};

Automatic initialization for other element types: new boolean[5] sets all 5 elements to false. Any array of objects gets all item values null (no object, similar to Python None) by default.

Arrays have a length attribute – accessed with no parentheses after it. The length of array a is a.length. This is unlike Strings! The length of String s is s.length(). Both cannot be changed for a given object, array or string.

It is also easy to conflate syntax for list lengths. Lists can be changed: A different method name is used for the (current) length of ArrayList al: al.size().

Here is a function to return a new array containing the squares of the numbers in a passed array. See the use of the length attribute:

public static int[] squares(int[] nums)
{
    int n = nums.length;
    int[] sq = new int[n];
    for (int i = 0; i < n; i++) {
        sq[i] = nums[i]*nums[i];
    }
    return sq;
}

Dictionary¶

Just as Python provides the dictionary when we want to have easy access to key, value pairs, Java also provides us a similar mechanism. Rather than the dictionary terminology, Java calls these objects Maps. Java provides two different implementations of a map, one is called the TreeMap and the other is called a HashMap. As you might guess the TreeMap uses a balanced binary tree behind the scenes, and the HashMap uses a hash table.

Lets stay with a simple frequency counting example, only this time we will count the frequency of words in a document. A simple Python program for this job could look like this:

def main():
    data = open('alice30.txt')
    wordList = data.read().split()
    count = {}
    for w in wordList:
        w = w.lower()
        count[w] = count.get(w,0) + 1

    keyList = sorted(count.keys())
    for k in keyList:
        print('{:20} occurred {:4} times'.format(k, count[k]))

main()

Here is alice30.txt:

Down, down, down.  Would the fall NEVER come to an end!  'I
wonder how many miles I've fallen by this time?' she said aloud.
'I must be getting somewhere near the centre of the earth.  Let
me see:  that would be four thousand miles down, I think--' (for,
you see, Alice had learnt several things of this sort in her
lessons in the schoolroom, and though this was not a VERY good
opportunity for showing off her knowledge, as there was no one to
listen to her, still it was good practice to say it over) '--yes,
that's about the right distance--but then I wonder what Latitude
or Longitude I've got to?'  (Alice had no idea what Latitude was,
or Longitude either, but thought they were nice grand words to
say.)

Notice that the structure of the program is very similar to the numeric histogram program.

import java.util.Scanner;
import java.util.ArrayList;
import java.io.File;
import java.io.IOException;
import java.util.TreeMap;

public class HistoMap {

    public static void main(String[] args) {
        Scanner data = null;
        TreeMap<String,Integer> count;
        int idx;
        String word;
        int wordCount;

        try {
                data = new Scanner(new File("alice30.txt"));
        }
        catch ( IOException e) {
            System.out.println("Sorry but I was unable to open your data file");
            e.printStackTrace();
            System.exit(0);
        }

        count = new TreeMap<String,Integer>();

        while(data.hasNext()) {
            word = data.next().toLowerCase();
            wordCount = count.get(word);
            if (wordCount == null) {
                wordCount = 0;
            }
            count.put(word,++wordCount);
        }

        for(String i : count.keySet()) {
            System.out.format("%-20s occurred %5d times\n", i, count.get(i) );
        }
    }
}

The TreeMap has both keys and values, so two types are specified TreeMap<keyType, valueType>. This needs to occur both when the type is declared and later where the constructor is used.

The method hasNext with no type appended to the name is checking if there is any token next.

Python also has a get method for dictionaries, but the usage when there is no element is different: Python causes an error unless a default value is included as a second parameter. Java does not trigger an error, but just returns null (no object, used something like Python’s None).

Here there is a ++ operator, but the ++ is before the variable ++wordCount. If ++wordCount were used as a separate statement, it would be equivalent to wordCount++, but here is is an expression whose value is used in a larger statement: With the ++ first, the value of the expression is the new value, after incrementing. With the ++ second, the value of the expression is the original value, before incrementing. To avoid these fine points, you are encouraged not to use either where the expression value is used immediately. Same idea for the decrement operator --.

The method System.out.format is used much like printing a string with the format method. The % followed by modifiers is used much like the {} in Python format strings. This is more important in Java, since System.out.println and System.out.print can only take a single argument, unlike the allowed list in Python for print. Java format modifiers end with a type designation: s prints anything as a string, d is for ints. A field width can be given after the %, with a negative number indicating left justification. Though not appearing in the example, f is the type identifier for double. You can show field width and precision for a double:

double x = 2.345;
System.out.format("Two decimal places:%7.2, rounded");
// prints would print: Two decimal places:   2.35, rounded
// see the 7 character field between the literal colon and comma

The Java getKeys() method is like the Python keys() method. The extra step to sort the keys in Python is needed since a dict corresponds to a Java HashMap, generating keys in an unpredictable order. This Java example used a Treemap, which has slower access, but maintains the keys in order.

Improve the program above to remove the punctuation.

Simple if¶

if condition:
    statement1
    statement2
    ...

In Java this same pattern is simply written as:

if (condition) {
    statement1
    statement2
    ...
}

Once again you can see that in Java the curly braces define a block rather than indentation. In Java the parenthesis around the condition are required, but there is no colon.

if else¶

if condition:
    statement1
    statement2
    ...
else:
    statement1
    statement2
    ...

In Java this is written as:

if (condition) {
    statement1
    statement2
    ...
} else {
    statement1
    statement2
    ...
}

elif¶

Java does not have an elif pattern like Python. In Java you can get the functionality of an elif statement by nesting if and else. Here is a simple example in both Python and Java.

grade = int(input('enter a grade'))
if grade < 60:
    print 'F'
elif grade < 70:
    print 'D'
elif grade < 80:
    print 'C'
elif grade < 90:
    print 'B'
else:
    print 'A'

In Java we have a couple of ways to write this

public class ElseIf {
    public static void main(String args[]) {
     int grade = 85;

     if (grade < 60) {
         System.out.println('F');
     } else {
         if (grade < 70) {
             System.out.println('F');
         } else {
             if (grade < 80) {
                 System.out.println('F');
             } else {
                 if (grade < 90) {
                     System.out.println('F');
                 } else {
                     System.out.println('F');
                 }
             }
         }
     }
   }
 }

We can get even closer to the elif statement by taking advantage of the Java rule that a single statement does not need to be enclosed in curly braces. Since the if is the only statement used in each else we can get away with the following.

public class ElseIf {
    public static void main(String args[]) {
     int grade = 85;
     if (grade < 60) {
         System.out.println('F');
     } else if (grade < 70) {
         System.out.println('D');
     } else if (grade < 80) {
         System.out.println('C');
     } else if (grade < 90) {
         System.out.println('B');
     } else  System.out.println('A');
    }
}

switch¶

Java also supports a switch statement that acts something like the elif statement of Python under certain conditions. To write the grade program using a switch statement we would use the following:

public class SwitchUp {
    public static void main(String args[]) {
     int grade = 85;

     int tempgrade = grade / 10;
     switch(tempgrade) {
     case 10:
     case 9:
         System.out.println('A');
         break;
     case 8:
         System.out.println('B');
         break;
     case 7:
         System.out.println('C');
         break;
     case 6:
         System.out.println('A');
         break;
     default:
         System.out.println('F');
     }
   }
 }

The switch statement is not used very often, and I recommend you do not use it! First, it is not as powerful as the else if model because the switch variable can only be compared for equality with an integer or enumerated constant. Second it is very easy to forget to put in the break statement. If the break statement is left out then then the next alternative will be automatically executed. For example if the grade was 95 and the break was omitted from the case 9: alternative then the program would print out both A and B.

Boolean Operators¶

The conditionals used in the if statement can be boolean variables, simple comparisons, and compound boolean expressions.

Java also supports the boolean expression. condition ? trueValue : falseValue This expression can be used to test a condition as part of an assignment statement. For example a = a % 2 == 0 ? a*a : 3*x -1 In the previous assignment statement the expression a%2 ==0 is first checked. If it is true then a is assigned the value a * a if it is false then a is assigned the value of 3*x-1. Of course all of this could have been accomplished using a regular if else statement, but sometimes the convenience of a single statement is too much to resist.

Python recently added a corresponding construction (in English!):

trueValue if condition else falseValue

Definite Loop¶

In Python the easiest way to write a definite loop is using the for loop in conjunction with the range function. For example:

for i in range(10):
   print(i)

In Java we would write this as:

for (int i = 0; i < 10; i++ ) {
    System.out.println(i);
}

Recall that the range function provides you with a wide variety of options for controlling the value of the loop variable.

range(stop)
range(start,stop)
range(start,stop,step)

The Java for loop is really analogous to the last option giving you explicit control over the starting, stopping, and stepping in the three clauses inside the parenthesis. You can think of it this way:

for (start clause; stop clause; step clause) {
    statement1
    statement2
    ...
}

If you want to start at 100, stop at 0 and count backward by 5 the Python loop would be written as:

for i in range(100,-1,-5):
    print(i)

In Java we would write this as:

for (int i = 100; i >= 0; i -= 5)
    System.out.println(i);

In Python the for loop can also iterate over any sequence such as a list, a string, or a tuple. Java also provides a variation of its for loop that provides the same functionality in its so called for each loop.

In Python we can iterate over a list as follows:

l = [1, 1, 2, 3, 5, 8, 13, 21]
for fib in l:
   print(fib)

In Java we can iterate over an ArrayList of integers too:

ArrayList<Integer> l = new ArrayList<Integer>();
l.add(1); l.add(1); l.add(2); l.add(3);
for (int i : l) {
    System.out.println(i)
}

This example stretches the imagination a bit, and in fact points out one area where Java’ s primitive arrays are easier to use than an array list. In fact all primitive arrays can be used in a for each loop.

int l[] = {1,1,2,3,5,8,13,21};
for(int i : l) {
    System.out.println(i);
}

To iterate over the characters in a string in Java do the following:

String t = "Hello World";
for (char c : t.toCharArray()) {
    System.out.println(c);
}

Indefinite Loops¶

Both Python and Java support the while loop. Recall that in Python the while loop is written as:

while  condition:
   statement1
   statement2
   ...

In Java we add parenthesis, drop the colon, and add curly braces to get:

while (condition) {
    statement1
    statement2
    ...
}

Java adds an additional, if seldom used variation of the while loop called the do-loop. The do loop is very similar to while except that the condition is evaluated at the end of the loop rather than the beginning. This ensures that a loop will be executed at least one time. Some programmers prefer this loop in some situations because it avoids an additional assignment prior to the loop. For example:

do {
    statement1
    statement2
    ...
} while (condition);

This is one place in Java where their is a semicolon after a condition!

Loop and Array Exercises¶

1. Write a static void method printNums with int array parameter that prints out all the elements of the parameter on one line, blank separated. Use it for tests of methods below.

2. Write a program including a static void method called noNeg to mutate its int array parameter so all negative elements become 0. Include a test in main. Remember the easy way to initialize an array with braces.

3. Write a program including a static method called allUpper with a String array parameter that does not modifiy the parameter array, but returns a String array with all the strings of the parameter array in upper case. (Use string method toUpper: "Hello".toUpper() returns "HELLO".) Include a test in main. Use a for-each loop to display the contents fo the returned array.

4. Write a program including a static boolean method called isIncreasing with an int array parameter that returns true if the array elements are strictly increasing, and false otherwise. Include thorough tests in main.

5. Write the body of

   public static int factorial(int n)
   

   where factorial(n), or n! in math, means 1*2*...*n for positive n. By convention 0! is 1. 1! is 1; 2! is 1 * 2 = 2; 3! is 1*2*3 = 6.

   What is the largest value of n for which you get the correct answer in Java? (There is no limit until you run out of system memory in Python.)

6. Same as the last problem by with int type everywhere replaced by long.

Writing a constructor¶

Once you have identified the instance variables for you class the next thing to consider is the constructor. In Java, constructors have the same name as the class and are declared public. They are declared without a return type. So any function that is named the same as the class and has no return type is a constructor. Our constructor will take two parameters for the numerator and the denominator.

public Fraction(int num, int den) {
    this.num = num;
    this.den = den;
}

..index:: operator overloading excluded

Methods or Member Functions¶

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 Java there is no operator overloading. So we will have to write member functions, not operator symbols, to do addition, subtraction, multiplication, and division. Lets begin with addition.

public Fraction add(Fraction otherFrac) {
    int newNum, newDen, common;

    newNum = otherFrac.getDenominator()*this.num +
                             this.den*otherFrac.getNumerator();
    newDen = this.den * otherFrac.getDenominator();
    common = gcd(newNum,newDen);
    return new Fraction(newNum/common, newDen/common );
}

First you will notice that the add member function is declared as public Fraction The public part means that any other method may call the add method. The Fraction part means that add will return a fraction as its result.

Second, you will notice that on line two all of the local variables used in the function are declared. In this case there are three local variables: newNum, newDen, and common. It is a good idea for you to get in the habit of declaring your local variables at the beginning of your function. This declaration section provides a simple road map for the function in terms of the data that will be used. The listing above also makes use of the this variable, you may find it useful to use this until you are comfortable with abandoning your Pythonic ideas about self. Using the this makes a symmetry in referencing the instance variables for the current object, this, and otherFrac, but this. is not actually needed anywhere in this method.

Declaring your variables at the top is not a requirement, it is just a recommended practice for you. Java only requires that you declare your variables before they are used. The following version of Fraction is also legal Java, but may be somewhat less readable.

public Fraction add(Fraction otherFrac) {
    int newNum = otherFrac.getDenominator()*num +
                             den*otherFrac.getNumerator();
    int newDen = den * otherFrac.getDenominator();
    int common = gcd(newNum,newDen);
    return new Fraction(newNum/common, newDen/common );
}

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 function is used to find a common divisor to simplify the numerator and denominator in the result.

Finally on line 8 a new fraction 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.

public Fraction(int num) {
    this.num = num;
    this.den = 1;
}

public Fraction add(int other) {
    return add(new Fraction(other));
}

public class Fraction {

    private int num;
    private int den;

    public Fraction(int num, int den) {
        this.num = num;
        this.den = den;
    }

    public Fraction(int num) {
        this.num = num;
        this.den = 1;
    }

    public Fraction add(Fraction other) {
        int newNum, newDen, common;

        newNum = other.getDenominator()*this.num +
                 this.den*other.getNumerator();
        newDen = this.den * other.getDenominator();
        common = gcd(newNum,newDen);
        return new Fraction(newNum/common, newDen/common );
    }

    public Fraction add(int other) {
        return add(new Fraction(other));
    }


    private static int gcd(int m, int n) {
        while (n != 0) {
            int r = m % n;
            m = n;
            n = r;
        }
        return m;
    }

    public static void main(String[] args) {
        Fraction f1 = new Fraction(1,2);
        Fraction f2 = new Fraction(2,3);

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

}

Inheritance¶

If you ran the program above you probably noticed that the output is not very satisfying. Chances are your output looked something like this:

Fraction@7b11a3ac

The reason is that we have not yet provided a friendly string representation for our Fraction objects. The truth is that, just like in Python, whenever an object is printed by the println or print method it must be converted to string format. In Python you can control how that looks by writing an __str__ method for your class. If you do not then you will get the default, which looked something like the above.

public String toString() {
    return num + "/" + den;
}

object1 == object2

object1.equals(object2)

public boolean equals(Fraction other) {
    int num1 = this.num * other.getDenominator();
    int num2 = this.den * other.getNumerator();
    return num1 == num2;
}

public class Fraction extends Number {
    ...
}

public double doubleValue() {
    double numd = num;
    return numd / den;
}

public float floatValue() {
    float numf = num;
    return numf / den;
}

public int intValue() {
    return num / den;
}

public long longValue() {
    long longv = num / den;
    return longv;
}

public void test(Number a, Number b) {
    a.add(b);
}

Interfaces¶

The word interface is used several ways in programming:

• As a verb or noun about the boundary where things connect
• the public methods by which a class is connected to the outside
• The specific Java specification syntax discussed below

Lets turn our attention to making a list of fractions sortable by the standard Java sorting method Collections.sort. In Python 2 all we would need to do is implement the __cmp__ method. But in Java we cannot be that informal. In Java Things that are sortable must be Comparable. Your first thought might be that Comparable is Superclass of Number. That would be a good thought but it would not be correct. Java only supports single inheritance, that is, a class can have only one parent. Although it would be possible to add an additional Layer to the class hierarchy it would also complicate things dramatically. Because Not only are Numbers comparable, but Strings are also Comparable as would many other types. For example we might have a Student class and we want to be able to sort Students by their gpa. But Student already extends the class Person for which we have no natural comparison function.

Java’s answer to this problem is the Interface mechanism. Interfaces are like a combination of Inheritance and contracts all rolled into one. An interface is a specification that says any object that claims it implements this interface must provide the following methods. It sounds a little bit like an abstract class, however it is outside the inheritance mechanism. You can never create an instance of Comparable. Many objects, however, do implement the Comparable interface. What does the Comparable interface specify?

The Comparable interface says that any object that claims to be Comparable must implement the compareTo method. The following is the documentation for the compareTo method as specified by the Comparable interface.

int compareTo(T o)

Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object. The implementor must ensure sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y. (This implies that x.compareTo(y) must throw an exception iff y.compareTo(x) throws an exception.)

The implementor must also ensure that the relation is transitive: (x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0.

Finally, the implementor must ensure that x.compareTo(y)==0 implies that sgn(x.compareTo(z)) == sgn(y.compareTo(z)), for all z.

It is strongly recommended, but not strictly required that (x.compareTo(y)==0) == (x.equals(y)). Generally speaking, any class that implements the Comparable interface and violates this condition should clearly indicate this fact. The recommended language is “Note: this class has a natural ordering that is inconsistent with equals.”

In the foregoing description, the notation sgn(expression) designates the mathematical signum function, which is defined to return one of -1, 0, or 1 according to whether the value of expression is negative, zero or positive.

To make our Fraction class Comparable we must modify the class declaration line as follows:

public class Fraction extends Number implements Comparable<Fraction> {
    ...
}

The specification Comparable<Fraction> makes it clear that Fraction is only comparable with another Fraction. The compareTo method could be implemented as follows:

public int compareTo(Fraction other) {
    int num1 = this.num * other.getDenominator();
    int num2 = this.den * other.getNumerator();
    return num1 - num2;
}

With this we can shorten the equals method to just return compareTo(other) == 0.

This math of this implementation is close to the Python 2 __cmp__.

This section described how to use an existing Interface. You can also create them, with what looks like a stripped down class definition: inteface replacing class inthe heading, no instance variables, method headings for public methods followed by a semicolon and no body. Example:

public interface Response
{
    boolean execute(Command cmd); // methods assumed public

    String getCommandName();

    String help();
}

This comes from the large example, http://anh.cs.luc.edu/170/examples/zuul/src/.

Static member variables¶

Suppose that you wanted to write a Student class so that the class could keep track of the number of students it had created. Although you could do this with a global counter variable that is an ugly solution. The right way to do it is to use a static variable. In Python we could do this as follows:

class Student:
    numStudents = 0

    def __init__(self, id, name):
        self.id = id
        self.name = name

        Student.numStudents = Student.numStudents + 1

def main():
    for i in range(10):
        s = Student(i,"Student-"+str(i))
    print 'The number of students is: ', Student.numStudents

main()

In Java we would write this same example using a static declaration.

public class Student {
        public static int numStudents = 0;

        private int id;
        private String name;

        public Student(int id, String name) {
        this.id = id;
        this.name = name;

        numStudents = numStudents + 1;
        }

        public static void main(String[] args) {
        for(int i = 0; i < 10; i++) {
            Student s = new Student(i,"Student"+i.toString());
        }
        System.out.println(
           "The number of students: "+Student.numStudents.toString());
        }
    }

In this example notice that we create a static member variable by using the static modifier on the variable declaration. Once a variable has been declared static in Java it can be access from inside the class without prefixing the name of the class as we had to do in Python.

Static Methods¶

We have already discussed the most common static method of all, main. However in our Fraction class we also implemented a method to calculate the greatest common divisor for two fractions (gcd). There is no reason for this method to be a member method since it takes two int values as its parameters. Therefore we declare the method to be a static method of the class. Furthermore since we are only going to use this gcd method for our own purposes we can make it private.

private static int gcd(int m, int n) {
    while (n != 0) {
        int r = m % n;
        m = n;
        n = r;
    }
    return m;
}

Full Implementation of the Fraction Class¶

A final version of the Fraction class that exercises all of the features we have discussed is as follows.

import java.util.ArrayList;
import java.util.Collections;

public class Fraction extends Number
                      implements Comparable<Fraction> {

    private int num;
    private int den;

    /** Creates a new instance of Fraction */
    public Fraction(int num, int den) {
        this.num = num;
        this.den = den;
    }

    public Fraction(int num) {
        this.num = num;
        this.den = 1;
    }

    public Fraction add(Fraction other) {
        int newNum = other.getDenominator()*this.num +
                     this.den*other.getNumerator();
        int newDen = this.den * other.getDenominator();
        int common = gcd(newNum,newDen);
        return new Fraction(newNum/common, newDen/common );
    }

    public Fraction add(int other) {
        return add(new Fraction(other));
    }

    public int getNumerator() {
        return num;
    }

    public void setNumerator(int num) {
        this.num = num;
    }

    public int getDenominator() {
        return den;
    }

    public void setDenominator(int den) {
        this.den = den;
    }

    public String toString() {
        return num + "/" + den;
    }

    public boolean equals(Fraction other) {
        return compareTo(other) == 0;
    }

    public double doubleValue() {
        double numd = num;
        return numd / den;
    }


    public float floatValue() {
        float numf = num;
        return numf / den;
    }


    public int intValue() {
        return num / den;
    }

    public long longValue() {
        long longv = num / den;
        return longv;
    }
    public int compareTo(Fraction other) {
        int num1 = this.num * other.getDenominator();
        int num2 = this.den * other.getNumerator();
        return num1 - num2;
    }

    private static int gcd(int m, int n) {
        while (n != 0) {
            int r = m % n;
            m = n;
            n = r;
        }
        return m;
    }

    public static void main(String[] args) {
        Fraction f1 = new Fraction(1,2);
        Fraction f2 = new Fraction(2,3);
        Fraction f3 = new Fraction(1,4);

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

        ArrayList<Fraction> myFracs = new ArrayList<Fraction>();
        myFracs.add(f1);
        myFracs.add(f2);
        myFracs.add(f3);
        Collections.sort(myFracs);

        for(Fraction f : myFracs) {
            System.out.println(f);
        }
    }

}

Replacing Python input¶

The Python input function is so conventient: Supply a prompt, get a value for the line entered.

Consider a class UI that provides that functionality and more.

We will have a number of functions wanting data from the keyboard, new Scanner(System.in). Rather than instantiating a new Scanner in each method, we create it once as a static variable:

import java.util.Scanner;


class UI
{
    private static Scanner in = new Scanner(System.in);

    ...

}

The idea of input is to prompt for data. With the strong typing of Java it makes sense to have versions for different types. The direct analog of input could be

public static String promptLine(String prompt)
{
    System.out.print(prompt);
    return in.nextLine();
}

We can convert the entry on the next line to various types, like int:

public static int promptInt(String prompt)
{
    return Integer.parseInt(promptLine(prompt);
}

Note the mouthful to convert a String to int. This has a major disadvantage: Users can type poorly and enter something that is not an int. Then the program bombs. Here is a way more sophisticated version:

public static int promptInt(String prompt)
{
    System.out.print(prompt);
    while (! in.hasNextInt()) // loop when failure
    {
        in.next();  // dump the bad token
        in.nextLine(); // dump through the newline
        System.out.println("!! Bad int format!!");
        System.out.print(prompt);
    }
    int val = in.nextInt();
    String rest = in.nextLine().trim(); //clear line
    if (rest.length() > 0):
        System.out.println("Skipping rest of input line.");
    return val;
}

Here is a more complete UI class. We introduce the format of documentation that the utility javadoc can turn into separate pages. Javadoc documentation is a multi-line comment starting with /** right before the part being documented. In InteliJ IDEA, you can generate Javadocs: Tools -> Generate Javadocs....

import java.util.Scanner;

/**
 * Aid user keyboard input with prompts and error catching.
 *
 * @version 2017.09.24
 */
public class UI
{
   private static Scanner in = new Scanner(System.in);

   /** Return the Scanner reading the keyboard.
    *  There should be ONLY ONE in a program.
    */
   public static Scanner getKeyboardScanner()
   {
      return in;
   }


   /** Prompt the user for a line and return the line entered.
    *  @param prompt
    *      The prompt for the user to enter the input line.
    *  @return
    *      The line entered by the user.
    */
   public static String promptLine(String prompt) {
      System.out.print(prompt);
      return in.nextLine();
   }


   /** Prompt for a character.
    *  @param prompt
    *      The prompt for the user to enter a character
    *  @return
    *     The first character of the line entered or a blank if the line
    *     is empty.
    */
   public static char promptChar(String prompt)
   {
      String line = promptLine(prompt);
      if (line.length() == 0)
         return ' ';
      return line.charAt(0);
   }

   /** Print a question and return a response.
    *  Repeat until a valid answer is given.
    * @param question
    *    The yes/no question for the user to answer.
    * @return
    *    True if the answer is yes, or False if it is no.
    */
   public static boolean agree(String question)
   {
      String yesStr = "yYtT", noStr = "nNfF",
             legalStr = yesStr + noStr;

      char ans = promptChar(question);
      while (legalStr.indexOf(ans) == -1)
      {
         System.out.println("Respond 'y or 'n':");
         ans = promptChar(question);

      }
      return yesStr.indexOf(ans) >= 0;
   }

   /** Prompt and read an int.
    * Repeat until there is a legal value to return.
    * Read through the end of the line
    *  @param prompt
    *      The prompt for the user to enter a value.
    *  @return
    *      The value entered by the user.
    */
   public static int promptInt(String prompt)
   {
      System.out.print(prompt);
      while (! in.hasNextInt())
      {
         in.next();  // dump the bad token
         in.nextLine(); // dump through the newline
         System.out.println("!! Bad int format!!");
         System.out.print(prompt);
      }
      int val = in.nextInt();
      String rest = in.nextLine().trim(); //clear line
      if (rest.length() > 0)
          System.out.println("Skipping rest of input line.");
      return val;
   }

   /** Prompt and read a double.
    * Repeat until there is a legal value to return.
    *  @param prompt
    *      The prompt for the user to enter a value.
    *  @return
    *      The value entered by the user.
    */
   public static double promptDouble(String prompt)
   {
      System.out.print(prompt);
      while (! in.hasNextDouble())
      {
         in.next();  // dump the bad token
         in.nextLine(); // dump through the newline
         System.out.println("!! Bad double format!!");
         System.out.print(prompt);
      }
      double val = in.nextDouble();
      String rest = in.nextLine().trim(); //clear line
      if (rest.length() > 0)
          System.out.println("Skipping rest of input line.");
      return val;
   }

   /** Prompt and read a line of integers.
    * Repeat until there is a legal line to process.
    *  @param prompt
    *      The prompt for the user to enter data.
    *  @return
    *      The int values entered by the user.
    */
   public static int[] promptIntArray(String prompt)
   {
      while (true) { // exit via return statement
         String line = promptLine(prompt);
         String[] tokens = line.trim().split("\\s+");
         int n = tokens.length;
         int[] nums = new int[n];
         Scanner lineScan = new Scanner(line);
         int i = 0;
         while (i < n && lineScan.hasNextInt() )
         {
            nums[i] = lineScan.nextInt();
            i++;
         }
         if (i == n)
            return nums;
         System.out.format(
           "Bad input %s. Start your line over.\n", tokens[i]);
      }
   }

   /** Prompt and read a line of numbers.
    * Repeat until there is a legal line to process.
    *  @param prompt
    *      The prompt for the user to enter data.
    *  @return
    *      The double values entered by the user.
    */
   public static double[] promptDoubleArray(String prompt)
   {
      while (true) { // exit via return statement
         String line = promptLine(prompt);
         String[] tokens = line.trim().split("\\s+");
         int n = tokens.length;
         double[] nums = new double[n];
         Scanner lineScan = new Scanner(line);
         int i = 0;
         while (i < n && lineScan.hasNextDouble() )
         {
            nums[i] = lineScan.nextDouble();
            i++;
         }
         if (i == n)
            return nums;
         System.out.format(
           "Bad input %s. Start the line over.\n", tokens[i]);
      }
   }
}

Include UI.java in your project that is looking for user input. Here is a simple example, TestUI.java:

class TestUI
{
    public static void main(String[] args])
    {
        String s = UI.promptLine("Enter a line: ");
        int n = UI.promptInt("Repeat how many times? ");
        for (int i = 0; i < n; i++)
            System.out.println(s);
        int[] v = UI.promptIntArray("Nums: ");
        int sum = 0;
        for (int x: v)
            sum += x;
        System.out.println(
           UI.agree("Is the sum " + sum + "? "));
    }
}

Execution might look like:

Enter a line: I like programming.
Repeat how many times? 2
I like programming.
I like programming.
Nums: 3 5 7x 90
Bad input 7x. Start the line over.
Nums: 3 5 7 90
Is the sum 105? zxc
Respond 'y or 'n':
Is the sum 105? Y
true

Cohesion, Coupling, and Separation of Concerns¶

There are three important ideas in organizing your code into classes and methods:

Cohesion of code is how focused a portion of code is on a unified purpose. This applies to both individual methods and to a class. The higher the cohesion, the easier it is for you to understand a method or a class. Also a cohesive method is easy to reuse in combination with other cohesive methods. A method that does several things is not useful to you if you only want to do one of the things later.

Separation of concerns allows most things related to a class to take place in the class where they are easy to track, separated from other classes. Data most used by one class should probably reside in that class. Cohesion is related to separation of concerns: The data and methods most used by one class should probably reside in that class, so you do not need to go looking elsewhere for important parts. Also, if you need to change something, where concerns are separated into cohesive classes, with the data and logic in one place, it is easier to see what to change, and the changes are likely to be able to be kept internal to the class, affecting only its internal implementation, not its public interface.

Some methods are totally related to the connection between classes, and there may not be a clear candidate for a class to maximize the separation of concerns. One thing to look at is the number of references to different classes. It is likely that the most referred to class is the one where the method should reside.

Coupling is the connections between classes. If there were no connections to a class, no public interface, it would be useless except all by itself. The must be some coupling between classes, where one class uses another, but with increased cohesion and strong separation of concerns you are likely to be able to have looser coupling. Limiting coupling makes it easier to follow your code. There is less jumping around. More important, it is easier to modify the code. There will be less interfacing between classes, so if you need to change the public interface of a class, there are fewer places in other classes that need to be changed to keep in sync.

Aim for strong cohesion, clear separation of concerns, and loose coupling. Together they make your code clearer, easier to modify, and easier to debug.

To see a fairly large, multi-class project, designed to follow the ideas in this section, see the zuul/src subfolder of http://anh.cs.luc.edu/170/examples/. You can put it in a project and it starts frpm class Game. The use of the interface, Response, there has a lot to do with the ideas in this section.

User Defined Object Exercises¶

1. The Java Fraction class version is closer in concept to my Python Rational. Help make it closer yet:
   1. Move the simplification of a fraction into the constructor with two parameters, and force the denominator to be positive. Remove the gcd call from add, where it is no longer needed.
   2. Remove the setter methods: henceforth Fractions are immutable.
   3. Create the method mult for multiplication. Create two overloaded methods, one for a Fraction parameter, and one for an int.
   4. Create a neg method that returns the negation of the Rational.
   5. Create another constructor that takes a string parameter, so it can handle "23", "-15/20" and "34.567", like Python Rational.
   6. Elaborate toString so it does not print the /1 for integer values.
   7. With the simplified form of the instance variables, make equals a direct comparison of the numerators and of the denominators.
   8. Implement a pow method for a power, with int parameter. Make sure it works for a negative power.
   9. Little new here, but you could create overloaded sub and div methods for subtraction and division.
   10. Write a separate main class to test all your elaborations.
2. Convert the Python Animal class and testing code to Java.

Group Project¶