Tokens, Keywords, Identifiers, and Literals

Learning outcome: Break Java statements into tokens and correctly identify keywords, identifiers, literals, operators, separators, and comments.

When the Java compiler reads source code, it first breaks the stream of characters into the smallest meaningful units of the language. These units are called tokens. Whitespace and comments help humans read code, but the compiler mostly uses them only to separate tokens.

Java token categories:

Tokenizing a Statement

Consider this statement:

int sum = a + 25;

In simple terms: The compiler reads code the way you read a sentence: not as a stream of letters, but as words and punctuation. Each smallest meaningful piece is a token.

Keywords

Keywords are reserved words. They already have a fixed meaning in Java, so you cannot use them as variable names, class names, or method names.

In simple terms: Keywords are words the language has already claimed. Naming a variable class is like naming a child “and” — the sentence stops making sense.

Representative keyword groups (not a complete list):

Note: true, false, and null are technically literals, not keywords, but they are reserved and cannot be used as identifiers.

Modern Java also has context-sensitive words such as record, sealed, permits, and yield, whose special meaning depends on where they appear. Consult the language version used by the course before choosing new identifiers.

Identifiers

An identifier is a name created by the programmer.

In simple terms: An identifier is the name you choose. Java only insists that it is legal; readers insist that it is meaningful, and they are the harder audience to satisfy.

Identifiers are used for:

Rules enforced by the compiler:

1. An identifier may contain Java-recognised Unicode letters and digits, connecting characters such as _, and currency symbols such as $.
2. It must not start with a digit.
3. It must not be a keyword or reserved literal.
4. It is case-sensitive.
5. It may be any length, but it should remain readable.

The single underscore _ has been a keyword since Java 9 and cannot be an identifier, although names such as _count remain legal. The dollar sign is legal but is normally reserved for generated code rather than ordinary application names.

Examples:

int totalAmount;       // valid
int _count;            // valid, though not a preferred style
int student2;          // valid
int caféCount;         // valid Unicode letters
int 2cool;             // invalid: starts with a digit
int class;             // invalid: class is reserved
int _;                 // invalid in Java 9 and later

Professional naming conventions:

Literals

A literal is a fixed value written directly into source code.

In simple terms: A literal is a value written out in full, exactly as it stands. 42 in the source is the number 42 — nothing is looked up or computed.

Example:

int marks = 95;
long population = 1_400_000_000L;
double price = 99.50;
float rate = 2.5f;
char grade = 'A';
String course = "Project Based Learning in Java";
boolean passed = true;
String middleName = null;

Operators as Tokens

Operators perform actions on values.

Common operator groups:

Operators are covered in depth in the operators and casting topic.

Separators

Separators give structure to code.

Example:

public void greet(String name) {
    System.out.println("Hello, " + name);
}

Comments

Comments are ignored by the compiler and are written for humans.

// Single-line comment

/*
   Multi-line comment
   spanning several lines
*/

/**
 * Javadoc comment used to generate documentation.
 */

Use comments to explain intent, decisions, or non-obvious logic. Avoid comments that merely repeat the code.

Common Mistakes

Practice

Problem 1: Identify the Tokens

Break the statement into token categories:

double area = 3.14 * radius * radius;

Problem 2: Valid or Invalid

Mark each identifier as valid or invalid and give a reason:

myVar
2cool
_temp
class
totalAmount
MAX_MARKS
student-name

Problem 3: Rewrite with Conventions

Improve these names:

studentname
CalculateTotal
maxmarks
Student_record

Quick Check

Lecture Quiz

Summary

Tokens are the building blocks of Java source code. Keywords have fixed meanings, identifiers are programmer-created names, literals are fixed values, operators perform actions, and separators structure the program.