Keywords and Identifiers

In Java, source code is parsed into tokens. Two of the most fundamental token classes are Keywords (words reserved by the language compiler for syntax) and Identifiers (names defined by programmers to represent classes, variables, methods, and packages).

Java Keywords

Java has over 50 keywords. These are divided into two main categories:

1. Hard Reserved Keywords: Always reserved by the compiler. You cannot declare a variable, class, or method named after these. Examples include class, public, static, void, if, else, return, int, and new.
   • Unused Reserved Keywords: const and goto are reserved keywords in Java, even though they serve no syntax function. This prevents programmers from writing buggy code resembling other procedural languages, allowing the compiler to yield clear, targeted errors instead.
2. Soft/Restricted Keywords: Words introduced in modern Java versions that act as keywords only in specific syntax contexts. To maintain backwards compatibility with code written in older Java versions, these words can still be used as variable names elsewhere. Examples:
   • var: Treated as local variable type inference keyword (Java 10+), but you can still write int var = 10; (legal, though discouraged).
   • yield: Used to return values from switch expressions (Java 14+).
   • record, sealed, non-sealed, permits: Structural keywords introduced in Java 16/17 for data layout encapsulation.

Identifier Rules and Conventions

An identifier is a sequence of characters of any length that represents a named element.

Strict Compiler Rules:

• Must begin with a letter, currency character ($), or connecting character (_). It cannot begin with a digit.
• Subsequent characters can be letters, digits, $, or _.
• Cannot be a hard reserved keyword. (Note: true, false, and null are literals, not keywords, but they are also strictly forbidden as identifiers).
• Identifiers are case-sensitive. myVariable and myvariable represent two entirely separate names in compiled symbol tables.

Naming Conventions (Best Practices):

• Classes and Interfaces: Use PascalCase (e.g., class InvoiceManager).
• Methods and Variables: Use camelCase (e.g., void calculateTotal(), int itemCount).
• Constants: Use UPPER_SNAKE_CASE (e.g., final int MAX_RETRIES = 3;).
• Currency Character ($): Avoid using $ in variable names. The Java compiler uses this character internally to generate naming structures for inner classes (e.g., Outer$Inner.class).

Common Pitfalls

• Starting with a number: Writing int 1stValue = 10; will cause a compilation error. Use int value1st or int firstValue instead.
• Using Reserved words: Forgetting that literals like null, true, and false are forbidden variable identifiers.
• Abusing underscores: Java 9+ treats a single underscore (_) as a keyword representing an unnamed variable. Writing int _ = 5; was legal in Java 8 but is a compiler error in modern Java versions.

Interview-Relevant Information