What are the literals in Java?

Literals in Java are fixed values that directly appear in a program, serving as a synthetic representation of boolean, character, numeric, or string data. They are fundamental constant values used to express particular values within a program, which can be directly assigned to variables.

Understanding Literals in Java

In programming, a literal represents a value that is explicitly written in the source code. Unlike variables, which store values that can change, literals are constant values. They are the simplest way to represent data directly in your code, making programs more readable and their logic clearer.

Why are Literals Important?

• Direct Representation: They provide a straightforward way to put specific values into your code, such as the number 10, the text "Hello", or the boolean true.
• Constant Values: Literals inherently represent constant values that do not change during program execution.
• Initialization: They are commonly used to initialize variables or to pass specific values as arguments to methods.

Types of Literals in Java

Java supports various types of literals, categorized by the kind of data they represent. These include integer, floating-point, character, string, boolean, and null literals.

1. Integer Literals

Integer literals represent whole numbers (without fractional parts). They can be expressed in different number systems:

• Decimal (Base 10): The most common representation, consisting of digits 0-9.
  • Example: _100, 25, 0, -15
• Octal (Base 8): Prefixed with 0. Digits 0-7.
  • Example: 010 (decimal 8), 077 (decimal 63)
• Hexadecimal (Base 16): Prefixed with 0x or 0X. Digits 0-9 and letters A-F (or a-f).
  • Example: 0xFF (decimal 255), 0xA (decimal 10)
• Binary (Base 2): Prefixed with 0b or 0B. Digits 0 and 1. (Introduced in Java 7).
  • Example: 0b101 (decimal 5), 0b1111_0000 (decimal 240)

For long integer literals, you can append an L or l (e.g., 123L) to explicitly indicate it's a long value.

int decimalVal = 100;
int octalVal = 0144;      // Equivalent to decimal 100
int hexVal = 0x64;        // Equivalent to decimal 100
int binaryVal = 0b1100100; // Equivalent to decimal 100
long bigNumber = 12345678901L; // A long literal

2. Floating-Point Literals

Floating-point literals represent numbers with fractional parts. They can be expressed in standard decimal notation or scientific notation.

• Decimal Form: Numbers with a decimal point.
  • Example: 3.14, 0.5, -10.0
• Scientific Notation: Uses e or E to indicate powers of 10.
  • Example: 6.022e23 (6.022 x 10^23)

By default, floating-point literals are treated as double. To specify a float literal, append F or f. To explicitly specify a double literal, append D or d (though it's optional).

double pi = 3.14159;
float temperature = 98.6F; // Must use F or f for float
double bigDouble = 1.23E-5; // 1.23 x 10^-5

3. Character Literals

Character literals represent a single Unicode character enclosed in single quotes (' ').

• Single Character:
  • Example: 'A', 'z', '5', '$'
• Escape Sequences: Special characters can be represented using escape sequences, starting with a backslash (\).
  • Examples:
    • '\n' (newline)
    • '\t' (tab)
    • '\\' (backslash)
    • '\'' (single quote)
    • '\"' (double quote)
• Unicode Escapes: Represent any Unicode character using \uXXXX where XXXX is a four-digit hexadecimal value.
  • Example: '\u0041' (represents 'A')

char grade = 'A';
char newlineChar = '\n';
char copyrightSymbol = '\u00A9'; // Unicode for ©

4. String Literals

String literals represent a sequence of characters enclosed in double quotes (" "). In Java, string literals are instances of the String class.

• Example: "Hello, World!", "Java", "" (empty string)

String literals can also include escape sequences for special characters.

String greeting = "Hello, Java!";
String path = "C:\\Program Files\\Java"; // Using double backslash for literal backslash
String multiLine = "First line.\nSecond line.";

5. Boolean Literals

Boolean literals represent the two logical states: true and false. These are keywords in Java.

• Example: true, false

boolean isJavaFun = true;
boolean hasError = false;

6. Null Literal

The null literal represents the absence of a value or a reference that points to nothing. It can be assigned to any reference type (object variables). It is not allowed for primitive types.

• Example: null

String emptyString = null;
Object myObject = null;
// int myInt = null; // This would cause a compile-time error

Summary of Java Literals

The table below provides a quick overview of the different types of literals in Java with examples.

Literals are essential building blocks in Java programming, allowing developers to embed specific, constant values directly into their code, making it functional and understandable.