Programs would be pretty boring if the only thing you could do was print things on the screen. We would like our programs to be interactive.
Unfortunately, interactivity requires several different concepts working together, and explaining them all at once might be confusing. So I am going to cover them one at a time.
First up: variables! If you have ever taken an Algebra class, you are familiar with the concept of variables in mathematics. Programming languages have variables, too, and the basic concept is the same:
“A variable is a name that refers to a location that holds a value.”
Variables in Java have four major differences from math variables:
scoremight start out with a value of
0, but by the end of the program,
scoremight hold the value
Okay, enough discussion. Let’s get to the code! I’m not going to tell you what the name of the file is supposed to be. You’ll have to figure it out for yourself.
On lines 3 through 5 we declare3 nine variables. The first three are named x, y, and age. All three of these variables are “integers”, which is the type of variable that can hold a value between ± two billion.
A variable which is an integer could hold the value
10. It could hold
-8192. An integer variable can hold
123456789. It could
not hold the value
3.14 because that has a fractional part. An integer
variable could not hold the value
10000000000 because ten billion is
On line 4 we declare variables named seconds, e, and checking. These three variables are “floating-point”, which is the type of variable that can hold a number that might have a fractional part. “Double” is short for “double-precision floating-point”. In this book, I will use the terms “double” and “floating-point” interchangably. I know that’s kind of confusing, but I didn’t invent the terminology; I just teach it.
A floating-point variable could hold the value
4.71. It could hold the
-8192. (It may have a fractional part but doesn’t have to.)
A double-precision floating-point variable can pretty much hold any
value between ± 1.79769 × 10308 and 4.94065
However, doubles have limited precision. Notice that on line 12 I store
2.71828182845904523536 into the variable named e, but
when I print out that value on line 22, only
out. Doubles do not have enough significant figures to hold the value
2.71828182845904523536 precisely. Integers have perfect precision,
but can only hold whole numbers and can’t hold huge, huge values. (And
single-precision floating-point variables (a.k.a.
floats) have even fewer
significant figures than
doubles do. Which is why they aren’t used much
The last type of variable we are going to look at in this exercise is
String. On line 5 we declare three String variables: firstName,
lastName and title. String variables can hold words and phrases;
the name is short for “string of characters”.
On lines 7 through 9 we initialize4 the three integer
values. The value
10 is stored into x. Before this point, the variable
x exists, but its value is undefined.
400 is stored into y and
is stored into the variable age.
Lines 11 through 13 give initial values to the three double variables, and lines 15 through 17 initialize the three String variables. Then lines 19 through 24 display the values of those variables on the screen. Notice that the variable names are not surrounded by quotes.
I know that it doesn’t make sense to use variables for a program like this, but soon everything will become clear.
“Learn Java the Hard Way” is ©2013–2016 Graham Mitchell