Lecture 2: Java: More on Fields, and Introduction to Types

Overview

• More examples of declaring and using fields

• The parts of a field declaration

• Strings and booleans

• Types and basic Java type-checking

2.1 Using Fields

In the last section, we saw lots of examples of declaring fields. That is, every time we wrote a line like

or

we were creating, or declaring, a new field. Java and the tester library would dutifully store these fields’ values, and then print them out when the program was run.

Fields have many more uses than just labelling a value that’s printed out by tester, however. For example, say we wanted to use Java as a calculator again to do some simple physics calculations, like how far something falls after a given amount of time. A quick glance at Wikipedia gives us a formula. We’ll round to whole numbers (since we’re using ints), and say that the value of gravitational acceleration on Earth is about 10 meters per second2. So we could write out a few calculations:

If we wanted to change this to, say, calculate the distance travelled on the moon (where acceleration is more like 4 m/s2), we’d need to change each of the 10 values to 4.

Do Now!

Change all the 10 values (for Earth’s acceleration) to 4 (for the acceleration on Mars) in the program above, and then re-run the program.

It’s pretty annoying to have to make those changes everywhere, and in a large program we may use a constant many more than three times. This motivates another use of fields – storing a common value used in many places. Instead of writing the above, we could define a field that is just for storing the gravity constant, and then use that field every time we want the value for that constant. That looks like:

Above, instead of repeating 10 over and over, we use a field access, in this case this.gravity, to look up the value in the gravity field. Since it was set to 10 when it was declared, that value is used for all the calculations. Now, we can just change the value for gravity if we want to get calculations for a different value, like for mars:

Notice that using this.gravity matches how the tester library prints out the values of fields, where each field is written as this.fieldName:

Here are some more examples of both declaring and using fields:

Exercise

Predict what each of the programs above will print, then try running them to see if you were right.

2.2 Beyond ints

So far, all the fields we’ve defined have held ints, as have all the calculations we’ve done. But Java, and programming languages in general, support many other kinds of data. A common instance of data is Strings, which are sequences of characters. Strings can represent a wide variety of information – names of people or places, the content of a paragraph like this one, addresses, passwords, usernames, web site addresses, and more. In Java, we create strings by putting a sequence of characters in between quotation marks. Strings can be stored in fields, just as ints can, though there’s an important difference in how we write down those fields:

See the difference? Instead of writing int, we write String before the name of the field.

Much like ints, if we run this program, it just prints the String values stored in these fields:

Strings, like ints, support a number of operations. A simple one is +, which appends, or concatenates, strings together. For example:

If we wanted the fullName field to contain a String with a space in it, we could use + again:

We’ll cover more String operations in future lectures. For now, we’ll get some practice mixing Strings and ints.

2.3 Java Checks Types

A natural next question to ask is what happens if we try to use the word int in place of String, or more generally, how we can mix Strings and ints. This is a kind of exploration that’s useful to do when we learn a programming language, especially on small examples. It can help explain what parts of the language do when combined together in a controlled setting, so if we encounter the error in a larger program later on, we have a better understanding.

2.3.1 Mixing Types

Let’s start with this simple program:

Do Now!

What happens when we run this?

When the program is run, it produces an error telling us that the String "Dorothy" is not allowed to be stored in the field firstName, since firstName must store an int:

A similar error occurs if we try the opposite, storing an int in a String-typed field:

Do Now!

Run this program and confirm that the error message says what you expect.

We might think that this is particular to storing values in fields, but Java will check the types of values wherever they appear in the program. For example, we might try to divide an int by a String:

Here, Java complains that the program is using / incorrectly, because it’s nonsensical to divide by a String.

In these examples, it’s easy to spot the issue. In larger programs, we need to keep in mind these type errors, just as we need to keep in mind syntax errors (from the last section), when we see Java produce an error message.

2.3.2 A Special Case

Java has special rules for +. Based on the above argument, we might think that it would be an error to write:

Do Now!

What would you expect the error to say?

However, when we run this, we get this:

It “works!” The + operator is fairly special in Java, in that it converts its operands to Strings if either is a String, and then concatenates them. So this works in the reverse order as well:

We need to be a bit careful with this, though, because + is not always aware of our intent:

In the second case, the + operator treats 1 + 1 as arithmetic, since it groups operands together left-to-right, and both are ints. I bring this up because it’s a small “gotcha” that can often come up with building up strings out of numbers. The remedy is simple in this case, we can just parenthesize to make it clear what we mean:

2.4 In Summary

This section has given us a few more examples of classes and fields, and of using them in different ways. It also showed us that the int in front of field names wasn’t meaningless, but actually specifies the type of the field. Now we know enough that we can give some better definitions:

• A class has a name (like ExamplesLec) and a list of fields. We write it by writing class TheClassName { followed by a sequence of fields, followed by }. It turns out that this is a very simplified definition of what a class is, and future lectures will add more to this definition. For now, it’s useful to pause and give ourselves this simple definition.

• A field has a type (we’ve seen String and int so far), a name, and a value (like 5 or "CSE11"). We write them as SomeType someName = someValue;, where the someValue can be a complex expression that does arithmetic, works with strings, or looks up other fields. It turns out this is also not the whole story for fields, but it’s a good definition to have given what we know so far.

• We can write this.someName to look up the value of a field, and Java will use that value in place of the expression this.someName. We call this a field lookup expression.

In future lectures, we’ll better learn how to manipulate and use values of different types to perform more intricate computations, and extend these definitions further.