Literals in Java

Literals in Java

int a = 5;

1. In the above expression, a is a variable but 5 is literal.
2. Literal can be of many types, we will discuss all types of literal one by one.

Integral Literal

Any integer constant is treated as integral literal. it can be written in 3 formats.

1. int a = 10; (decimal format)
2. int a = 010; (octal format, equivalent to 8)
3. int a = 0x10; (hexadecimal format, equivalent to 16)

Note:

1. Octal constants can contain digits from 0 to 9.
2. Hexadecimal constants can contains digits from 0 to 9 and a to f, where a to f can be uppercase or lowercase.

Example - 1:

int a = 10;   (✓)
int a = 0678;  (✕) // Compile time error, number too large
int a = 0777;  (✓)
int a = 0xace;  (✓)
int a = 0xBeer;  (✕) // Compile time error, number too large

Example - 2:

int a;
a = 10 + 010 + 0x10;
System.out.println(a); // 34, because 010 = 8 and 0x10 = 16 so 10 + 8 + 16

Important Notes

• We(programmer) have option to write integer constant in decimal, octal and hexadecimal format but JVM always return integer type value in decimal format.
• By default all integer literals are integer type, to specify long type literal it must be suffixed with 'l' or 'L'.

Example - 3:

int a = 10; (✓)
long a = 10L; (✓)
int a = 10L;  (✕) // Compile time error - Incompatible types, required int found long.

Type Conversion

• In Java Narrowing is not allowed, only widening is allowed implicitly (Automatically).
• If anywhere you perform Narrowing a compile time error occurred, possible loss of precision.
• If you want to perform Narrowing the you can do it explicitly.

Example-1

int a = 10L;
System.out.println(a); // Compile time error, possible loss of precision.

Example - 2

byte b = 10;
System.out.println(a);

Example - 3

byte b = 128;
System.out.println(b); // Compile time error, possible loss of precision.

Example - 4

byte b;
b = 5 + 6; // Compile time error, possible loss of precision
System.out.println(b);

Example - 5

byte b;
b = (bye)(5 + 6);  (✓)System.out.println(b);

Some important Points

1. In java, if a integer constant is assigned to lower data type than int (byte / short), then if constant is within the range of lower data type, it is allowed otherwise compile time error occurred.
2. If arithmetic is performed with any integer type (byte / short / int) result to integer type value, and if assigned to byte and short type directly it would be a compile time error.

Floating point literals

1. 54.5, 0.009, and -0.9877 all are floating points constants.
2. floating point literals can be written in two ways
1. Fixed format. (Ex: 0.007)
2. Exponential format. (Ex: 0.7 E 4)

0.7 E 4 is equivalent to 0.7 * 10⁴.

Example - 1

float f = 10.087;  (✕) // Compile time error - Incompatible types, required float found double.
float f = 10.087f; (✓)
double d = 10.087; (✓)
double d = 10.087d; (✓)

Note:

• Every floating point constant is by default of double type.
• To treat floating point constant of type float suffix with f or F. 

Example - 2

double d = 123.456; (✓)
double d = 0123.456; (✓), it is allowed due to it is treated as decimal value.
double d = 0x123.456; (✕), malformed floating value, decimal value can't be written in hexadecimal format.

Example - 3

double d = 0678;  (✕) malformed integer value, because octal can't contain 8.
double d = 0x678; (✓) Well formed integer value assigned in double so it is allowed.

Example - 4

double d = 1.1e4; (✓)
float f = 1.1e4; (✕) because of narrowing
float f = 1.1f4f; (✓)

boolean literal 

Example - 1:

boolean b = true; (✓)
boolean b = 1; (✕) compile time error, incompatible type required boolean found int.
boolean b = True; (✕) compile time error, can't find symbol True.
boolean b = "true";  (✕) compile time error, incompatible type required boolean found String.