Reading 2: Basic Java

You should be able to answer the questions on the Questions and Exercises pages for all four of the langage basics topics.

• Questions: Variables
• Questions: Operators
• Questions: Expressions, Statements, Blocks
• Questions: Control Flow

Note that each Questions and Exercises page has a link at the bottom to solutions.

Also check your understanding by answering some questions about how the basics of Java compare to the basics of Python:

int a = 5;     // (1)
if (a > 10) {  // (2)
    int b = 2; // (3)
} else {       // (4)
    int b = 4; // (5)
}              // (6)
b *= 3;        // (7)

Don’t worry if you find the Number wrapper classes confusing. They are.

You should be able to answer the questions on both Questions and Exercises pages.

• Questions: Numbers
• Questions: Characters, Strings

fahrenheit = 212.0
celsius = (fahrenheit - 32) * 5/9

You should be able to answer the questions on the first two Questions and Exercises pages.

• Questions: Classes
• Questions: Objects

Don’t worry if you don’t understand everything in Nested Classes and Enum Types right now. You can go back to those constructs later in the semester when we see them in class.

class Tortoise:
    def __init__(self):
        self.position = 0

    def forward(self):
        self.position += 1

pokey = Tortoise()
pokey.forward()
print pokey.position

public void forward() {
    // self.position += 1 (Python)
}

public class Tortoise {

    private int position = 0;      // (1)
    static int position = 0;       // (2)

    public Tortoise() {
        int position = 0;          // (3)
        int self.position = 0;     // (4)
        int this.position = 0;     // (5)
        int Tortoise.position = 0; // (6)
    }
    // ...
}

public class Tortoise {

    private int position;          // (1)
    static int position;           // (2)

    public Tortoise() {
        self.position = 0;         // (3)
        this.position = 0;         // (4)
        Tortoise.position = 0;     // (5)
    }
    // ...
}

You should be able to create a new HelloWorldApp.java file, enter the code from that tutorial page, and compile and run the program to see Hello World! on the console.

Primitive values are represented by bare constants. The incoming arrow is a reference to the value from a variable or an object field.

An object value is a circle labeled by its type. When we want to show more detail, we write field names inside it, with arrows pointing out to their values. For still more detail, the fields can include their declared types. Some people prefer to write x:int instead of int x, but both are fine.

Snapshot diagrams give us a way to visualize the distinction between changing a variable and changing a value:

• When you assign to a variable or a field, you’re changing where the variable’s arrow points. You can point it to a different value.

• When you assign to the contents of a mutable value – such as an array or list – you’re changing references inside that value.

Reassignment and immutable values

For example, if we have a String variable s, we can reassign it from a value of "a" to "ab".

String s = "a";
s = s + "b";

String is an example of an immutable type, a type whose values can never change once they have been created. Immutability (immunity from change) is a major design principle in this course, and we’ll talk much more about it in future readings.

Immutable objects (intended by their designer to always represent the same value) are denoted in a snapshot diagram by a double border, like the String objects in our diagram.

Mutable values

By contrast, StringBuilder (another built-in Java class) is a mutable object that represents a string of characters, and it has methods that change the value of the object:

StringBuilder sb = new StringBuilder("a");
sb.append("b");

These two snapshot diagrams look very different, which is good: the difference between mutability and immutability will play an important role in making our code safe from bugs.

Immutable references

Java also gives us immutable references: variables that are assigned once and never reassigned. To make a reference immutable, declare it with the keyword final:

final int n = 5;

If the Java compiler isn’t convinced that your final variable will only be assigned once at runtime, then it will produce a compiler error. So final gives you static checking for immutable references.

In a snapshot diagram, an immutable reference (final) is denoted by a double arrow. Here’s an object whose id never changes (it can’t be reassigned to a different number), but whose age can change.

Notice that we can have an immutable reference to a mutable value (for example: final StringBuilder sb) whose value can change even though we’re pointing to the same object.

We can also have a mutable reference to an immutable value (like String s), where the value of the variable can change because it can be re-pointed to a different object.

A Java List is similar to a Python list. A List contains an ordered collection of zero or more objects, where the same object might appear multiple times. We can add and remove items to and from the List, which will grow and shrink to accomodate its contents.

Example List operations:

In a snapshot diagram, we represent a List as an object with indices drawn as fields:

This list of cities might represent a trip from Boston to Bogotá to Barcelona.

A Set is a collection of zero or more unique objects. Like a mathematical set or a Python set – and unlike a List – an object cannot appear in a set multiple times. Either it’s in or it’s out.

Example Set operations:

In a snapshot diagram, we represent a Set as an object with no-name fields:

Here we have a set of integers, in no particular order: 42, 1024, and -7.

A Map is similar to a Python dictionary. In Python, the keys of a map must be hashable. Java has a similar requirement that we’ll discuss when we confront how equality works between Java objects.

Example Map operations:

In a snapshot diagram, we represent a Map as an object that contains key/value pairs:

This turtles map contains Turtle objects assigned to String keys: Bob, Buckminster, and Buster.

Python provides convenient syntax for creating lists:

lst = [ "a", "b", "c" ]

And maps:

map = { "apple": 5, "banana": 7 }

Java does not. It does provide a literal syntax for arrays:

String[] arr = { "a", "b", "c" };

But this creates an array, not a List. We can use a provided utility function to create a List from the array:

Arrays.asList(new String[] { "a", "b", "c" })

Unlike Python collection types, with Java collections we can restrict the type of objects contained in the collection. When we add an item, the compiler can perform static checking to ensure we only add items of the appropriate type. Then, when we pull out an item, we are guaranteed that its type will be what we expect.

Here’s the syntax for declaring some variables to hold collections:

List<String> cities;        // a List of Strings
Set<Integer> numbers;       // a Set of Integers
Map<String,Turtle> turtles; // a Map with String keys and Turtle values

Because of the way generics work, we cannot create a collection of primitive types. For example, Set<int> does not work. However, as we saw earlier, ints have an Integer wrapper we can use (e.g. Set<Integer> numbers).

In order to make it easier to use collections of these wrapper types, Java does some automatic conversion. If we have declared List<Integer> sequence, this code works:

sequence.add(5);              // add 5 to the sequence
int second = sequence.get(1); // get the second element

As we’ll see soon enough, Java helps us distinguish between the specification of a type – what does it do? – and the implementation – what is the code?

List, Set, and Map are all interfaces: they define how these respective types work, but they don’t provide implementation code. There are several advantages, but one potential advantage is that we, the users of these types, get to choose different implementations in different situations.

Here’s how to create some actual Lists:

List<String> firstNames = new ArrayList<String>();
List<String> lastNames = new LinkedList<String>();

If the generic types are the same on the left and right, Java can infer what’s going on and save us some typing:

List<String> firstNames = new ArrayList<>();
List<String> lastNames = new LinkedList<>();

ArrayList and LinkedList are two implementations of List. Both provide all the operations of List, and those operations must work as described in the documentation for List. In this example, firstNames and lastNames will behave the same way; if we swapped which one used ArrayList vs. LinkedList, our code will not break.

Unfortunately, this ability to choose is also a burden: we didn’t care how Python lists worked, why should we care whether our Java lists are ArrayLists or LinkedLists? Since the only difference is performance, for 6.005 we don’t.

When in doubt, use ArrayList.

HashSet is our default choice for Sets:

Set<Integer> numbers = new HashSet<>();

Java also provides sorted sets with the TreeSet implementation.

And for a Map the default choice is HashMap:

Map<String,Turtle> turtles = new HashMap<>();

So maybe we have:

List<String> cities        = new ArrayList<>();
Set<Integer> numbers       = new HashSet<>();
Map<String,Turtle> turtles = new HashMap<>();

A very common task is iterating through our cities/numbers/turtles/etc.

In Python:

for city in cities:
    print city

for num in numbers:
    print num

for key in turtles:
    print "%s: %s" % (key, turtles[key])

Java provides a similar syntax for iterating over the items in Lists and Sets.

Here’s the Java:

for (String city : cities) {
    System.out.println(city);
}

for (int num : numbers) {
    System.out.println(num);
}

We can’t iterate over Maps themselves this way, but we can iterate over the keys as we did in Python:

for (String key : turtles.keySet()) {
    System.out.println(key + ": " + turtles.get(key));
}

Under the hood this kind of for loop uses an Iterator, a design pattern we’ll see later in the class.

Iterating with indices

If you want to, Java provides different for loops that we can use to iterate through a list using its indices:

for (int ii = 0; ii < cities.size(); ii++) {
    System.out.println(cities.get(ii));
}

Unless we actually need the index value ii, this code is verbose and has more places for bugs to hide. Avoid.

Map<String, Double> treasures = new HashMap<>();
String x = "palm";
treasures.put("beach", 25.);
treasures.put("palm", 50.);
treasures.put("cove", 75.);
treasures.put("x", 100.);
treasures.put("palm", treasures.get("palm") + treasures.size());
treasures.remove("beach");
double found = 0;
for (double treasure : treasures.values()) {
    found += treasure;
}

These detailed descriptions are specifications. They allow us to use tools like String, Map, or BufferedReader without having to read or understand the code that implements them.

Reading, writing, understanding, and analyzing specifications will be one of our first major undertakings in 6.005, starting in a few classes.

Map<String, TreasureChest> treasures = new HashMap<>();
treasures.put("beach", new TreasureChest(25));
TreasureChest result = treasures.putIfAbsent("beach", new TreasureChest(75));

Map<String, String> translations = new HashMap<>();
translations.put("green", "verde");
??? result = translations.replace("green", "verde", "ahdar");