Explain Literals In Java, What Is Literal Explain With Example And Program, Integral Floating Boolean Literals In Java
In This Topic & Blog Having Any Query Then Post your Comment and Suggestion Below
Literals were mentioned briefly in Chapter 2. Now that the built-in types have been formally
described, let’s take a closer look at them.
Integer Literals
Integers are probably the most commonly used type in the typical program. Any whole
number value is an integer literal. Examples are 1, 2, 3, and 42. These are all decimal values,
meaning they are describing a base 10 number. There are two other bases which can be used
in integer literals, octal (base eight) and hexadecimal (base 16). Octal values are denoted in Java
by a leading zero. Normal decimal numbers cannot have a leading zero. Thus, the seemingly
valid value 09 will produce an error from the compiler, since 9 is outside of octal’s 0 to 7 range.
A more common base for numbers used by programmers is hexadecimal, which matches
cleanly with modulo 8 word sizes, such as 8, 16, 32, and 64 bits. You signify a hexadecimal
constant with a leading zero-x, (
0x
or
0X
). The range of a hexadecimal digit is 0 to 15, so A
through F (or a through f ) are substituted for 10 through 15.
Integer literals create an
int
value, which in Java is a 32-bit integer value. Since Java is
strongly typed, you might be wondering how it is possible to assign an integer literal to one
of Java’s other integer types, such as
byte
or
long
, without causing a type mismatch error.
Fortunately, such situations are easily handled. When a literal value is assigned to a
byte
or
short
variable, no error is generated if the literal value is within the range of the target type.
An integer literal can always be assigned to a
long
variable. However, to specify a
long
literal, you will need to explicitly tell the compiler that the literal value is of type
long
. Y
ou
do this by appending an upper- or lowercase L to the literal. For example, 0x7ffffffffffffffL
or 9223372036854775807L is the largest
long
. An integer can also be assigned to a
char
as
long as it is within range.
Floating-Point Literals
Floating-point numbers represent decimal values with a fractional component. They can be
expressed in either standard or scientific notation. Standard notation consists of a whole number
component followed by a decimal point followed by a fractional component. For example, 2.0,
3.14159, and 0.6667 represent valid standard-notation floating-point numbers. Scientific notation
uses a standard-notation, floating-point number plus a suffix that specifies a power of 10 by
which the number is to be multiplied. The exponent is indicated by an E or e followed by a
decimal number, which can be positive or negative. Examples include 6.022E23, 314159E–05,
and 2e+100.
Floating-point literals in Java default to
double
precision. To specify a
float
literal, you
must append an F or f to the constant. You can also explicitly specify a
double
literal by
appending a D or d. Doing so is, of course, redundant. The default
double
type consumes 64
bits of storage, while the less-accurate
float
type requires only 32 bits.
Boolean Literals
Boolean literals are simple. There are only two logical values that a
boolean
value can have,
true
and
false
.
The values of
true
and
false
do not convert into any numerical representation.
The
true
literal in Java does not equal 1, nor does the
false
literal equal 0. In Java, they can only
be assigned to variables declared as
boolean
, or used in expressions with Boolean operators.
Character Literals
Characters in Java are indices into the Unicode character set. They are 16-bit values that can
be converted into integers and manipulated with the integer operators, such as the addition
and subtraction operators. A literal character is represented inside a pair of single quotes. All
of the visible ASCII characters can be directly entered inside the quotes, such as a, z, and @.
For characters that are impossible to enter directly, there are several escape sequences that allow
you to enter the character you need, such as ‘\’’ for the single-quote character itself and
‘\n’
for
the newline character. There is also a mechanism for directly entering the value of a character in
octal or hexadecimal. For octal notation, use the backslash followed by the three-digit
number. For example, \141 is the letter a. For hexadecimal, you enter a backslash-u (
\u
),
then
exactly four hexadecimal digits. For example, \u0061 is the ISO-Latin-1 a because the top byte
is zero. \ua432 is a Japanese Katakana character. Table 3-1 shows the character escape sequences.
String Literals
String literals in Java are specified like they are in most other languages—by enclosing
a sequence of characters between a pair of double quotes. Examples of string literals are
“Hello World”
“two\nlines”
“\”This is in quotes\”“