Notice: This material is excerpted from Special Edition Using Java, ISBN: 0-7897-0604-0. The electronic version of this material has not been through the final proof reading stage that the book goes through before being published in printed form. Some errors may exist here that are corrected before the book is published. This material is provided "as is" without any warranty of any kind.

Chapter 9 - Types in Depth

by Jay Cross

Baseball players can be sorted into types: sluggers, contact hitters, defensive replacements, fireballers, control pitchers, the list is long. In the case of ball players, they have enough in common with each other that it may not make much of a difference to the final outcome if you get the type of player confused. The 1927 Yankees (arguably the best ball club in history) would probably still have won quite a few games if they had occasionally switched rolls for a pitcher with a heavy-hitting outfielder (Babe Ruth). Similarly from "Casey at the Bat" by Ernest Lawrence Thayer, we are told that Flynn was a "lulu," and Jimmy Blake's type was "cake," but both of them hit safely, and much to everyone's surprise, Casey, of type "mighty batsman" of the object "Mudville Nine" (An Irish Ghetto in Holliston, Mass.), an instance of the class "ballclub" struck out swinging. Types are important concerning humans and their endeavours, but are far less definable than data types in a computer.

Even on the smallest level, information can be stored in a computer in a variety of formats. The way that bits in a 32-bit integer are interperated is very different from the way that bits of a like-sized, floating-point number are used. Both of these interpretations are very different from bits in a string with a unicode-decimal representation of a number. It goes without saying that all of these formats are very different from a 32-bit memory address, which points to where one of these numbers is stored. Because the computer's processor follows a specific sequence of bit manipulations to do a calculation, treating a 32-bit number as the wrong type will produce a good result once in 4,294,967,296 instances. Java makes it difficult to make this kind of error by accident.

In the this chapter you will learn the following:

• How booleans are treated in Java.
• How char variables are stored.
• What the four types of integers in Java are.
• What the parts of a floating point number are.
• The limits on casting variables and expressions from one primitive type to another.
• The limits of the values of each type.
• How to declare arrays.

There are four groups of types in Java: Primative types, Array types, Class types, and Interface types. This chapter will cover Primative types, and Arrays of primative types. Classes and interfaces will be covered in great detail in chapters 11, "Classes in Depth" and 12, "More About Interfaces." There is one section in this chapter that covers each of the broad primative types (the four types of integers are treated collectively, as are the two floating-point types), plus one for arrays, and a summary.

Boolean Variables in Depth

Visualize Booleans in Java as representing one bit. Therefore a boolean has exactly two possible values: true or false. There is no other value. In some computer languages, a Boolean may have a multitude (if booleans in 'C' are defined based on the unsigned byte, they have 255 values that mean 'true')of possible values, of which one means false, and the rest usually mean true, but in Java there are only two values. This makes Java beautiful, elegant, and harder to abuse.

Default Value

The default value of a Boolean variable is false.

Operations on Booleans

Operators in Java have particular meanings for use with boolean expressions. Many of the same operator symbols are used as with other types of expressions. In most cases the meanings are a natural extension from the operations performed on integer types. The operations shown in table 9.1 can be performed on Booleans.

Table 9.1 Operations on boolean expressions

Booleans in Control Flow Statements

Booleans (and Boolean expressions) are the only type that may be used in the true clause of the control flow statements as seen in the following code fragment:

boolean TestVal = false;
int IntVal = 1;
...
if (TestVal) {} else {}
if (IntVal != 1) {} else {}
...
while (TestVal) {}
while (IntVal == 0) {}
...
do {} while (TestVal)
do {} while (IntVal == 0)
for (int j=0; TestVal; j++) {}
for (int j=0; IntVal < 5; j++) {}

In the above code fragment, the comparisons of the integer IntVal to an integer constant value are very simple boolean expression. Naturally, much more complicated expressions could be used in the same place.

C and C++ programmers beware: Assignments of other types cannot be used as a Boolean expression. Because the function (or method) getc returns an int, not a boolean, you can no longer use your old friend:

if (c=getc()) {}  //  !! Valid in C, but not in Java !!

You must use an explicit comparison to zero to get the same result. Object references must be explicitly compared to null.

Casting and Converting Booleans

Briefly, casting and converting are the way that Java allows the use of a variable 
of one type in an expression of another type. Casting and Converting are covered 
in much more detail in Chapter 13.

There are not any direct ways to cast or convert a Boolean to any other type. If you are intent on getting an integer to have a 0 or 1 value based on the current value of a Boolean, use an if-else statement, or imitate the following code:

int j;
boolean tf;
...
j = tf?1:0;          // integer j gets 1 if tf is true, and 0 otherwise.

Conversion the other way can be done with zero to be equal to false, and anything else equal to true as follows:

int j;
boolean tf;
...
tf = (j!=0);     // Boolean tf is true if j is not 0, false otherwise.

Boolean types are a new feature in Java, not found in C and C++. To some, this stricter adherence to typing may seem oppresive. On the other hand, pervasive ambiguity may be eliminated, which has resulted in countless lost man-hours from the world's intellectual workforce in the form of chasing many hard-to-detect programming errors.

Character Variables in Depth

Characters in Java are 16-bit Unicode characters. The Unicode standard allows for the use of many different languages' alphabets. The Latin alphabet, numerals, and punctuation have the same values as the ASCII character set, with a byte full of zeros as the high order bits.

Characters can be operands in any integer operation and can be treated as 16-bit unsigned integers. The result of the binary operations (operations with two operands) will be either an int or a long according to the same rules that the integers follow (except that if both operands are char, the result is a char). Recovering the result as a char requires an explicit cast back to char. The unary operations, such as the assignment operations, logical negation, and the increment and decrement operations, do not need explicit casting. Because they are unsigned, the unary sign operators (+ and -)-not to be confused with the binary operations of addition and subtraction (same symbols)-have no meaning with char type operands, and result in casting to int.

The default value for a char variable is '\u0000'.

Operations on Characters

The operations listed in table 9.2 can be performed with char type variables as at least one of the operands.

Table 9.2 Operations on char expressions

Casting and Converting Characters

Characters can be cast in the same way 16-bit (short) integers are cast; that is, you can cast it to be anything. If you cast into a smaller type, you will lose some data. Note that if you are using the Han character set (Chinese, Japanese, or Korean), you can lose data by casting a char into a short (16-bit integer), because the top bit will be lost.

See "Character literals"Chapter 8 (Tokens) for more about the char type and Unicode.

Floating Point variables in depth

Floating-point numbers are represented by the types float and double. Both of these follow the specifications defined in IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Std. 754-1985 (IEEE, New York). For those unfamiliar with floating-point numbers, they are different from integers, which (except for a negative numbers) are a straight base-2 representation of the integers you probably are familiar with from grade school. Floating-point numbers have a group of bits that are used for holding a sign and mantissa, and another group of bits for representing an exponent (base 2 with an offset). There are a few special configurations of the bits with special meanings such as, negative infinity, zero, positive infinity, and not a number (which is the result of zero divided by zero among other things).

The fact that these floating-point numbers follow this specification, no matter what machine the application or applet is running on, is one of the details that makes Java so portable. Many older implementations of other languages execute the floating-point operations as defined for the floating-point registers in their arithmetic logic unit, resulting in some minor variations from machine to machine in the least signifigant bits. This can be the cause of some consternation when the calculations involve money in some way. The down side for Java is that if the processor running the application doesn't support ANSI/IEEE 754-1985 in hardware, some extra bit shuffling has to occur with each floating-point calculation done, causing somewhat slower performance. On the upside, except possibly for Cray, almost no machines that don't follow 754 have been made in the last five years.

Limits of Floating-Point Values

Aside from the values mentioned in the preceding section of negative infinity, zero, positive infinity, and not a number, float type numbers can have absolute values from 1.40239846e-45f to 3.40282347e+38f. Likewise, the range for the non-zero absolute values of double-precision numbers is 4.94065645841246544e-324d to 1.7976931348623157e+308d. The default value for a floating-point variable is 0.0f for a float, and 0.0d for a double.

Operations on floats and doubles

Many of the operations that can be done on integers have an analogous operation that can be done on floating-point numbers. The main exceptions are the bitwise operations. It is easy to imagine how meaningless it would be to shift bits from the mantissa into the exponent. The operators which may be used in expressions of type float or double are given in table 9.3 below.

Table 9.3 Operations on float and double expressions

The equality and inequality operators produce a Boolean result, no matter what type the operands are.

When a binary operation has two floats as operands, the result is a float. When a binary operation has at least one double as an operand, the result is a double. When a binary operation has a float or double as one operand, and an integer as the other, the result is the same type as the float or double.

Casting and Converting floats and doubles

The float and double types can be cast to any other type except Boolean. Casting it into a smaller type can result in a loss of data. Casting to an integer results in a loss of the fractional part, rounding towards zero (i.e. truncating the fractional part).

Java floating-point numbers are rounded using the IEEE 754 "round to nearest" mode of rounding. When converting a float or double to some kind of integer, numbers are truncated towards zero.

No exceptions are produced by Java when performing floating-point arithmetic. Overflow (a condition which results when an operation produces a result which is larger than the largest number which may be expressed by the given type), or division of anything but zero by zero and similar operations result in the infinity and negative infinity type values, which are meaningful using the comparison operators. Underflows (resulting when an operation produces a non-zero number smaller than the smallest which may be expressed by the given type) result in special values called positive zero or negative zero. Division of zero by zero type calculation generates the not-a-number value, which produces a false in any comparison.

Integer variables in depth

There are four types of integers in Java. They are byte, short, int, and long. These are all signed two's compliment numbers, with 8, 16, 32, and 64 bits, respectively.

Two's compliment notation

The term two's compliment will be familiar to most computer scientists. It is a way of representing negative integers with bits. In fact,very nearly all computers use this method for storing integers. Commercial computing has developed to the point where most programmers won't need to know about the details of this notation, but out of respect for the past, your own inner beauty, or some hardware device-related need, read on.

As in the section of chapter 8, "Tokens in Depth," which deals with the bitwise arithmetic and shifting operators, we will use 8 bit (type byte) numbers as our example, but be aware that these ideas extend quite naturally to the longer integer types. We can see how the number 5 would be represented in a byte. It is 22+20 (4+1), so the lowest and second-to-lowest bits are ones and the rest are zeros:

5 = 0000_0101 = 0x05

But how do we represent -5? It would be conceptually simple to just use the top bit as a sign bit, and leave it at that, which means that -5 would be 0x85. It is not done this way primarily because there is a way (two's compliment arithmetic) that offers much simpler algorithms for binary arithmetic and type conversions. In two's compliment arithmetic, subtracting one from zero produces the same result as if there had been some higher order byte with a number in it. See table 9.4 below.

Table 9.4 Representing some negative numbers
256 - 1 = 255     // 1_0000_0000-1 = 0_1111_1111     (0x0100-1 = 0x00ff)
 0 - 1 = -1         //   0000_0000-1 =   1111_1111  (0x00-1 = 0xff)
-1 - 1 = -2          //   1111_1111-1 =   1111_1110     (0xff-1 = 0xfe)
-1 - 2 = -3          //   1111_1111-2 =   1111_1101     (0xff-2 = 0xfd)
-1 - 3 = -4          //   1111_1111-3 =   1111_1100     (0xff-3 = 0xfc)
-1 - 4 = -5          //   1111_1111-4 =   1111_1011     (0xff-4 = 0xfb)

Naturally, the same argument holds for operations with the whole range of integers.

To calculate what (-1) times a number will look like in two's compliment notation, simply subtract one from the number, and then flip every bit.

Don't confuse this with the logical compliment called one's compliment. With the logical compliment, you don't subtract anything, you just flip every bit. This is done in Java with the logical NOT (!) and compliment (or bitwise logigal negation) (~) operators.

One feature of two's compliment notation is that the sign bit is repeated from the highest bit down to, but not including, the most signifigant bit of the number. This is what the term sign extend refers to. This is also why two (as opposed to one) shift right (>>, >>>) operators are needed. The >>> operator simply shifts the bits, and inserts zero bits at the high end. The >> operator replicates the top bit as it shifts.

Limits on Integer Values

Integers can have values in the following ranges.

Note that the maximum number for a long is enough to provide a unique ID for one transaction per second for every person on the planet for the next fifty years. It is also the number of grains in about a cubic mile of sand. Yet, if a project is undertaken to count the black flies in Maine, or to catalog surveillance frames from every street corner in the world, surely the cry will arise for 128-bit integers.

Operations on Integers

The operations listed in table 9.5 can be performed with four integer type variables as at least one of the operands.

Table 9.5 Operations on integer expressions

The equality and inequality operators produce a Boolean result, no matter what type the operands are. The rest of this section refers to the other operations.

Binary operations with integer operands produce either an int or a long (never a byte or short, unless explicitly cast as such). The result will only be a long, if one of the operands was a long, or if the result won't fit into an int without overflowing.

Casting and Converting Integers

The four integer types can be cast to any other type except Boolean. Casting into a smaller type can result in a loss of data. Casting to a floating-point number (float or double will probably result in the loss of some precision, unless the integer is a whole power of two (for example, 1, 2, 4, 8...).

Overflows and Exceptions

If some operation creates a number exceeding above mentioned range, no overflow or exception is indicated. The low bits that fit are the result. (For a result cast as a byte, 127+1=-128, 127+9 =-120, and 127+127=-2.). An ArithmeticException will be thrown if the right-hand operand in an integer divide or modulo operation is zero.

Arrays in depth.

There are three types of reference variables, classes, interfaces, and arrays. Classes and interfaces are complicated enough that they each get their own chapter; but arrays are comparatively simple and are covered here with the primative types.

An array is an indexed collection of objects of one particular type. These can be arrays of Booleans, chars, bytes, short/TT>s, ints, longs, floats, doubles, arrays, or objects. There are three separate steps in the creation of an array: declaring it, allocating the memory for it, and populating it. It is possible to do two or more of these steps in the same statement. Several examples of creating arrays of long types are shown in the following code fragment:

long Primes[] = new long[1000000];     // declare an array and assign
                                             // some memory to hold it.
long[] EvenPrimes = new long[1];     // Either way, it's an array.
EvenPrimes[0] = 2;                         // populate the array.

// now declare an array with an implied 'new' and partially populate.
long Fibonacci[1000] = {1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144};

long Perfects = {6, 28};               // creates two element array.

long BlackFlyNum[];                         // declare an array. 
                                             // Default value is null.

BlackFlyNum = new long[2147483647];     // Array indexes must be type int.

// declare a two dimensional array and populate it.
long TowerOfHanoi[3][10] = {{10,9,8,7,6,5,4,3,2,1},{},{}};

long[][][] ThreeDTicTacToe;               // Uninitialized 3D array.

There are a number of points worth noting here.

• The array Primes is type long. The variable EvenPrimes is an array of longs. That is, two ways to express the same thing.
• Indexing of arrays starts with 0 (as in C and C++).
• You can partially populate an array on initialization.
• Array indexes must either be type int (32-bit integer) or be able to be cast as an int. As a result, the largest possible array size is 2,147,483,647. Most Java installations would fail with arrays anywhere near that size, but that is the maximum defined by the language.
• When populating an array, the right-most index sequences within the inner-most curly braces.

Differences with Arrays Between C or C++ and Java

In Java, arrays must be created dynamically, using the new command. An array in Java is a variable, not a pointer. In Java you cannot reference an array element that hasn't been created, therefore, memory is protected from either walking off the end, or uninitialized pointer corruptions, which are common in C.