This chapter is from the book
This chapter is from the book
This chapter is from the book
Primitive Types and Literal Values
Java defines eight primitive types. Variables that are declared as primitive types are not references to objects. They are only placeholders to store primitive values. The eight primitive types are byte, short, int, long, float, double, char, and boolean. The byte, short, int, and long types represent 8-, 16-, 32-, and 64-bit signed integer values. The char type represents an unsigned 16-bit value. The float and double types represent 32- and 64-bit floating-point values. The ranges of the primitive types are shown in Table 2.1.
Table 2.1: Ranges of Numeric Types
|
Type |
Range |
|
boolean |
true and false |
|
byte |
-(27) to 27 - 1 |
|
char |
0 to 216 - 1 |
|
short |
-(215) to 215 - 1 |
|
int |
-(231) to 231 - 1 |
|
long |
-(263) to 263 - 1 |
|
float |
Float.MIN_VALUE to Float.MAX_VALUE, Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITYdouble Double.MIN_VALUE to Double.MAX_VALUE, Double.NaN, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY |
Know Your Ranges
It is a good idea to memorize Table 2.1 because a few range-related questions are on the exam. See if you notice any patterns in this table that will make it easier for you to memorize the content.
The literal values of these integer types are written using positive or negative decimal, hexadecimal, or octal integers. Hexadecimal values are preceded by 0x or 0X and use the letters a through f (uppercase or lowercase) to represent the digits 10 through 15. Octal numbers are preceded by 0. Long decimal values have an l or L appended to the end of the number. Examples of conversions between decimal, hexadecimal, and octal values are shown in Table 2.2.
Table 2.2: Decimal, Hexadecimal, and Octal Values
|
Decimal Value |
Hexadecimal Value |
Octal Value |
|
14 |
0x0E |
016 |
|
123 |
0x7B |
0173 |
|
4567 |
0x11D7 |
010727 |
The float and double types represent 32- and 64-bit IEEE 754 floating-point numbers. Float numbers have the f or F suffix. Double numbers have d or D. If no suffix is provided, the default double type is assumed. Floating-point numbers can be written using any of the following forms:
The suffix is optional. It consists of f, F, d, or D, as described previously.
The exponent part is optional. It consists of an e or E followed by a signed integer. It is used to identify the exponent of 10 of the number written in scientific notation. For example, 1000000.0 could be represented as 1.0E6. If a floating-point literal does not contain a decimal point, then it needs to have either the exponent part or the suffix to be recognized as a floating-point literal (as opposed to an integer literal).
The Float and Double classes define three special float and double constants. The special value NaN is used to represent the value for "not a number" that occurs as the result of undefined mathematical operations. The values POSITIVE_INFINITY and NEGATIVE_INFINITY represent infinite values in the positive and negative directions.
The char type represents 16-bit Unicode characters. Unicode is a 16-bit superset of the ASCII character set that provides many foreign-language characters. A single character is specified by putting the character within single quotes ('). Three exceptions exist: single quote ('), double quote ("), and backslash (\). The backslash character (\) is used as an escape code to represent special character values. For example, a single quote would be represented by '\''. The character escape codes are shown in Table 2.3.
Table 2.3: Character Escape Codes
|
Escape Code |
Character |
|
\b |
backspace |
|
\t |
tab |
|
\n |
linefeed |
|
\f |
form feed |
|
\r |
carriage return |
|
\" |
double quote |
|
\' |
single quote |
|
\\ |
backslash |
Field Variables and Local Variables
Field variables are variables that are declared as members of classes. Local variables, also referred to as automatic variables, are declared relative to (or local to) a method or constructor.
The backslash can also be followed by an 8-bit octal value (\000 through \377) or by a u or U followed by a four-digit, hexadecimal value (\u0000 through \uffff). The four-digit value can be used to specify the full range of Unicode characters.
The boolean type represents the logical values true and false.
Java also supports string literals. String literals are not primitive values. They are a shorthand notation for representing String objects. Strings consist of characters enclosed by double quotes ("). The character escape codes can be used within String literals to represent special characters within the string.
The literal value null is used to identify the fact that an object is not assigned to a variable. It can be used with any variable that is not of a primitive data type.
Class literals were introduced with Java 1.1. A class literal is formed by appending .class to the name of a primitive or reference type. It evaluates to the class descriptor of the reference type or class descriptor of the primitive type's wrapper class. The expression void.class evaluates to the class descriptor of the Void class. For example, suppose that Test is a class you have declared. The following statement displays the output class Test:
System.out.println(Test.class);
Declaring Arrays and Objects
The declaration and use of arrays and objects are covered in Chapter 4.
Automatic Initialization
Field variables and the elements of arrays are automatically initialized to default values. Local variables are not automatically initialized. Failure to initialize a local variable results in a compilation error. Table 2.4 identifies the default values of each primitive type.
Table 2.4: Default Values for Primitive Types
|
Type |
Default Value |
|
boolean |
false |
|
byte |
0 |
|
char |
\u0000 |
|
short |
0 |
|
int |
0 |
|
long |
0L |
|
float |
0.0f |
|
double |
0.0d |
Field variables of object types and the elements of arrays of object types are automatically initialized to the null value.
The Initialization program (see Listing 2.2) illustrates the use of the automatic initialization of field variables and arrays. It displays the following output:
boolean: false byte: 0 char: short: 0 int: 0 long: 0 float: 0.0 double: 0.0 Object: null int[2]: 0 0 Object[2]: null null
Listing 2.2: The Initialization Program
class Initialization {
boolean bo;
byte by;
char c;
short s;
int i;
long l;
float f;
double d;
Object o;
public static void main(String[] args) {
Initialization app = new Initialization();
app.run();
}
void run() {
int[] intArray = new int[2];
Object[] objectArray = new Object[2];
System.out.println("boolean: "+bo);
System.out.println("byte: "+by);
System.out.println("char: "+c);
System.out.println("short: "+s);
System.out.println("int: "+i);
System.out.println("long: "+l);
System.out.println("float: "+f);
System.out.println("double: "+d);
System.out.println("Object: "+o);
System.out.println("int[2]: "+intArray[0]+" "+intArray[1]);
System.out.println("Object[2]: "+objectArray[0]+" "+objectArray[1]);
}
}