Computational Problem Solving with Java and Interactive Object Graphics

Java divides numeric values into two broad categories: integers and floating point numbers. An integer is a numeric value having no decimal place. It may optionally be preceded by a sign, like - or +, but it may not have commas or a decimal place (.). Consequently, integers are whole numbers (positive, negative or zero). No fractional part is permitted. Examples of Java integer value include 2, -64, 0, and 2147483647. We may enter these values directly into JShell, with no comma, at least up to a point. For example, if we enter 2147483647, JShell happily reads it and saves it with a new variable name generated automatically (beginning with $ and followed a number). But if we enter a value that is larger by 1, that is 2147483648, we see an error.

jshell> 2147483647;
$1 ==> 2147483647
|  created scratch variable $1 : int

jshell> 2147483648
|  Error:
|  integer number too large: 2147483648;
|  2147483648
|  ^

The error tells us that the number is too large. More specifically, the number is too large to be stored in the memory allotted by the default type that JShell uses to store integers values, int. To store 2147483648 in memory, we must choose a different Java integer type, one capable of holding larger numbers by virtue of being allocated more memory.

Recall that Java provides four primitive integer types, byte, short, int, long. We use the term primitive because these types are fundamental to the Java language. These four types are listed in the following table along with the amount of memory used to store each as well as the range of values that may be stored as min and max. All integer variables are stored as one of these types. JShell chooses int to store integers by default. We can see this in the $1 scratch variable above when JShell produces the output created scratch variable $1 : int. The final int tells us that $1 is of type int. Attempting to create the value 2147483648 and store it as an int produces an error because, according to the following table, that value is outside the range of values capable of being stored as an int. What we need is a way to store the number as a long.

Any time we enter a number directly into a Java program, even if we don’t store it using a variable, Java must interpret it and hold in memory, at least temporarily. Whenever any value is entered directly into a Java program, such as a number, it is called a literal. Integer literals of type int are written as a sequence of digits, using no other special syntax. But other literal types require extra care, such as by adding trailing characters to indicate their type. For example, a long literal is written as a sequence of digits followed by a trailing L. The special trailing character tells Java to set aside twice the amont of memory used to store an int (8 bytes). To create a long literal, terminate the literal’s sequence of integer digits with an L, as follows. Note that when we enter an integer value like this, JShell in verbose mode tells us that the type is long.

jshell> 2147483648L;
$3 ==> 2147483648
|  created scratch variable $3 : long

Java now knows you intend to create a long and so is declares the scratch variable $3 with a type of long and initializes it with the value entered. This time, because a variable of type long is capable of storing the number 2147483648, JShell does not produce an error. long literals are made up of digits and a trailing L>. Unfortunately, Java provides no way to express a short or byte literal directly. We can declare short and byte variables and initialise them, but we must use integer literals as the initial value. Java handles the automatic conversion from an int to a short and byte before it is written to the variable’s memory. If the initial value is too big to fit, you will receive an error response.

As we’ve seen, declaring a variable is accomplished by entering a type followed by the name of the variable we wish to create and a final semicolon. For example, let’s say we want to create a variable named n of type long. We would enter long n;. Java assigns a default value of 0 to all new integer type variables that have not been initialized.

With the variable n and its associated memory created, we may safely assign our larger number to the variable because as a type long it is capable of holding the larger value.

jshell> long n;
n ==> 0
|  created variable n : long

jshell> n = 2147483648L;
n ==> 2147483648
|  assigned to n : long

jshell>

Using similar procedures you may declare variables with one of the four integer types and assign values. You may also use these variable names any place you would normally use its associated value, such as in a mathematical expression. Take care to ensure that all variables assigned values have enough memory to hold assigned values. Assigning an int value to a long variable is permitted, but not the other way around.

byte  b = 0;
short s = 10;
int   i = 255;
long  l = 12345L;

jshell> long _supercalifragilisticexpialidocious = 9223372036854775807L;
_supercalifragilisticexpialidocious ==> 9223372036854775807
|  created variable _supercalifragilisticexpialidocious : long
jshell> // It works!

jshell> _supercalifragilisticexpialidocious = 9223372036854775808L;
|  Error:
|  integer number too large
|  _supercalifragilisticexpialidocious = 9223372036854775808L;
jshell> // The number exceeds the size of a long

jshell> _supercalifragilisticexpialidocious = 9223372036854775807;
|  Error:
|  integer number too large
|  _supercalifragilisticexpialidocious = 9223372036854775807;
|                                        ^
jshell> // The literal initializer is too big for an int literal

jshell> b * s
$8 ==> 0
|  created scratch variable $8 : int

jshell> i + l
$9 ==> 12600
|  created scratch variable $9 : long

jshell> l / s;
$10 ==> 1234
|  created scratch variable $10 : long