Literals in Java are fixed values written directly inside a program. They are used to assign data to variables and remain constant unless changed through code execution. Every Java application uses literals for storing numbers, text, characters, logical values, and references.
Values such as 100, 45.5, 'A', "Java", true, and null are examples of literals. Java provides different literal types so that different forms of data can be represented properly. Understanding literals is important because they are widely used in variables, operators, conditions, loops, methods, and object handling.
 

Table of Contents

---

Types of Literals in Java

1. Integer Literals: Integer literals are used to store whole numbers without decimal values.
2. Floating Point Literals: Floating point literals are used to store decimal numbers.
3. Character Literals: Character literals are used to store a single character value.
4. String Literals: String literals are used to store text enclosed inside double quotes.
5. Boolean Literals: Boolean literals are used to store logical values such as true and false.
6. Null Literal: Null literal represents the absence of an object reference.

Integer Literals in Java

Integer literals represent whole numbers and do not contain decimal values. Java supports multiple formats for writing integer literals.

Types of integer literals:
1. Decimal Literals: Decimal literals use digits from 0 to 9.
Syntax:

datatype variable = number;

Example:

int num = 50;

2. Binary Literal: Binary literals use only 0 and 1. They start with 0b or 0B.
Syntax:

datatype variable = 0bvalue;

Example:

int binary = 0b1010;

3. Octal Literal:
Octal literals use digits from 0 to 7 and begin with 0.
Syntax:

datatype variable = 0value;

Example:

int octal = 021;

4. Hexadecimal Literal:
Hexadecimal literals use digits 0–9 and letters A-F. They begin with 0x or 0X.
Syntax:

datatype variable = 0xvalue;

Example:

int hex = 0x2A;

Below is the Java program to implement all integer literals:

// Java program to implement 
// Integer Literals
public class IntegerLiteralExample 
{
    public static void main(String[] args) 
    {
        int decimal = 50;
        int binary = 0b1010;
        int octal = 021;
        int hexadecimal = 0x2A;
        System.out.println("Decimal Value = " + decimal);
        System.out.println("Binary Value = " + binary);
        System.out.println("Octal Value = " + octal);
        System.out.println("Hexadecimal Value = " + hexadecimal);
    }
}

Output:

Decimal Value = 50
Binary Value = 10
Octal Value = 17
Hexadecimal Value = 42

Explanation:

• 50 represents a decimal literal.
• 0b1010 represents a binary literal.
• 021 represents an octal literal.
• 0x2A represents a hexadecimal literal.

Floating Point Literals in Java

Floating point literals store values containing decimal points and are generally used with float and double.
Syntax:

float variable = valueF;
double variable = value;

Below is the Java program to implement floating-point literals:

// Java program to implement 
// Floating-Point Literals
public class FloatingLiteralExample 
{
    public static void main(String[] args) 
    {
        float marks = 87.5F;
        double salary = 65000.75;
        System.out.println(marks);
        System.out.println(salary);
    }
}

Output:

87.5
65000.75

Explanation:

• 87.5F is a float literal.
• 65000.75 is a double literal.

Character Literals in Java

Character literals store a single character enclosed inside single quotes.
Syntax:

char variable = 'value';

Below is the Java program to implement character literals:

// Java program to implement
// Character Literals
public class CharacterLiteralExample 
{
    public static void main(String[] args) 
    {
        char letter = 'A';
        char symbol = '#';
        char unicode = '\u0043';
        System.out.println(letter);
        System.out.println(symbol);
        System.out.println(unicode);
    }
}

Output:

A
#
C

Explanation:

• 'A' stores an alphabet.
• '#' stores a symbol.
• '\u0043' stores Unicode value C.

String Literals in Java

String literals store text values enclosed inside double quotes.
Syntax:

String variable = "text";

Below is the Java program to implement string literals:

// Java program to implement
// String Literals
public class StringLiteralExample 
{
    public static void main(String[] args) 
    {
        String language = "Java";
        String city = "Delhi";
        System.out.println(language);
        System.out.println(city);
    }
}

Output:

Java
Delhi

Explanation:

• "Java" and "Delhi" are string literals.
• Strings are always written inside double quotes.

Boolean Literals in Java

Boolean literals store logical values and are mostly used in conditions and decision-making.
Java supports:

1. true
2. false

Syntax:

boolean variable = true;
boolean variable = false;

Below is the Java program to implement boolean literals:

// Java program to implement
// Boolean Literals
public class BooleanLiteralExample 
{
    public static void main(String[] args) 
    {
        boolean passed = true;
        boolean rain = false;
        System.out.println(passed);
        System.out.println(rain);
    }
}

Output:

true
false

Explanation:

• true means the condition is correct.
• false means the condition is incorrect.

Null Literal in Java

Null literal indicates that a reference variable does not point to any object.
Syntax:

datatype variable = null;

Below is the Java program to implement null literal:

// Java program to implement
// Null Literal
public class NullLiteralExample 
{
    public static void main(String[] args) 
    {
        String name = null;
        System.out.println(name);
    }
}

Output:

null

Explanation:

• null means no object reference exists.
• It cannot be assigned to primitive data types.

Common Mistakes While Using Literals in Java

1. Using Double Quotes for Character Literals: Character literals must always be enclosed inside single quotes because double quotes are used for strings. Many beginners use double quotes for storing a single character.
Incorrect:

char grade = "A";

Correct:

char grade = 'A';

2. Forgetting F in Float Literals: Students often assign decimal values to float variables without using F. Java treats decimal values as double by default, so adding F is necessary for float literals.
Incorrect:

float price = 45.5;

Correct:

float price = 45.5F;

3. Writing Invalid Octal Numbers: Octal literals can contain only digits from 0 to 7. Using digits like 8 or 9 inside octal literals causes compilation errors.
Incorrect:

int num = 089;

Correct:

int num = 067;

4. Assigning Null to Primitive Data Types: Some beginners try assigning null to primitive variables. The null literal works only with reference types and cannot be used with primitive data types.
Incorrect:

int number = null;

Correct:

Integer number = null;

5. Using Single Quotes for String Literals: Single quotes are sometimes mistakenly used for storing text. Strings must always be enclosed inside double quotes because single quotes are reserved for character literals only.
Incorrect:

String language = 'Java';

Correct:

String language = "Java";

Conclusion

Literals in Java are constant values directly written inside programs. Java provides integer, floating point, character, string, boolean, and null literals to represent different types of data. Integer literals further include decimal, binary, octal, and hexadecimal forms. Understanding these literals helps beginners write programs correctly and understand Java syntax more easily.

Frequently Asked Questions

1. What are literals in Java?

Literals are fixed values written directly in Java programs such as numbers, text, characters, and logical values.

2. How many types of literals are available in Java?

Java supports six types of literals: integer, floating point, character, string, boolean, and null literals.

3. What are the types of integer literals in Java?

Integer literals are divided into decimal, binary, octal, and hexadecimal literals.

4. Can null be assigned to primitive data types?

No, null cannot be assigned to primitive types like int, char, and boolean.

5. Why is F used with float values?

F tells Java that the value belongs to the float data type.
Example:
float value = 45.5F;