Java Keywords: Complete List of All 51 Reserved Keywords (with Examples)

Java keywords are words the Java language reserves for its own use — like class, public, static and if. Because the compiler gives them a fixed meaning, you can't use them as names for variables, methods or classes. Java 21 has 51 reserved keywords, plus a set of contextual keywords such as var and record that only act as keywords in certain places.

How Many Keywords Are There in Java?

There are 51 reserved keywords in current Java (Java 9 and later). Java 8 had 50; Java 9 added the underscore _. On top of those, Java has 16 contextual keywords (also called restricted keywords or restricted identifiers) that behave like keywords only in a specific context. Every word in the tables below was checked against the Java 21 compiler.

List of All 51 Java Keywords

Grouped by what they do, so they're easier to remember:

Contextual Keywords: var, record, yield and More

These words are only keywords in a particular place, so older code that used them as names still compiles. The compiler confirms all 16 can be used as variable names — but five of them (var, yield, record, sealed, permits) cannot be used as class or type names.

Java Keywords Example Program

This small program uses more than 25 keywords — each one is marked in a comment:

public class KeywordsDemo {

    enum Level { BEGINNER, ADVANCED }              // enum

    interface Greeter { String greet(String name); } // interface

    static final int MAX_TESTS = 3;                 // static, final, int

    public static void main(String[] args) {        // public, static, void
        int passed = 0;
        for (int i = 1; i <= MAX_TESTS; i++) {      // for
            boolean ok = (i % 2 != 0);              // boolean
            if (ok) {                               // if / else
                passed++;
            } else {
                continue;                           // continue
            }
        }
        Level level = (passed >= 2) ? Level.ADVANCED : Level.BEGINNER;
        Greeter g = name -> "Hello, " + name;
        try {                                       // try / catch / finally
            System.out.println(g.greet("tester"));
            System.out.println("Passed " + passed + " of " + MAX_TESTS + " -> " + level);
            if (passed < 0) throw new IllegalStateException("impossible"); // throw, new
        } catch (IllegalStateException e) {
            System.out.println("Error: " + e.getMessage());
        } finally {
            System.out.println("Done");
        }
    }
}

Output

Hello, tester
Passed 2 of 3 -> ADVANCED
Done

How it works: enum and interface declare types; static final makes a constant; the for loop uses if/else and continue; and try/catch/finally handles errors — finally runs every time, which is why "Done" is always printed.

Common Mistakes

1. Using a keyword as a variable name. The error message doesn't say "keyword", which confuses beginners:

   int class = 5;

   Bad.java:3: error: not a statement
           int class = 5;
           ^
   Bad.java:3: error: ';' expected

   Fix: choose another name such as className or clazz.
2. Thinking Java keywords are case-insensitive. Keywords are all lowercase, so Class, Main or String are not keywords — int Class = 5; compiles (though it's bad style).
3. Calling true, false or null keywords. They're literals. You still can't use them as names, but in interviews say "literals", not keywords.
4. Thinking main or String is a keyword. main is just a method name the JVM looks for, and String is a class in java.lang.
5. Trying to use goto or const. Both are reserved but unused — the compiler rejects them. Use labelled break/continue instead of goto, and final instead of const.

Practice Exercises

1. Without looking, write down the 8 primitive-type keywords. Check them against the table.
2. Write a class that uses static, final, switch, case, default and break, and predict its output before running it.
3. Interview question: explain the difference between final, finally and finalize() (hint: only two of them are keywords).

Key Takeaways

• Java 21 has 51 reserved keywords (including _) and 16 contextual keywords.
• true, false and null are literals, not keywords — but they are still reserved.
• var, yield, record, sealed and permits can be variable names but not class names.

📚 Official documentation: Java Language Specification: Keywords (Java 21) · dev.java: Learn Java

Frequently Asked Questions

How many keywords are there in Java?

Java has 51 reserved keywords (Java 9 and later, including the underscore _) plus 16 contextual keywords such as var, record and yield. Java 8 had 50 reserved keywords.

Are true, false and null keywords in Java?

No. They are literals. You still cannot use them as names for variables, methods or classes.

Is main a keyword in Java?

No. main is an ordinary method name that the JVM looks for to start a program. String is a class, not a keyword, either.

Is var a keyword in Java?

var is a contextual keyword (a reserved type name) added in Java 10. You can still name a variable var, but you cannot name a class var.

Why are goto and const reserved in Java?

They were reserved so they could never be used by mistake. Neither has any meaning in Java, and the compiler rejects both.