Reserved Words in Java: Keyword Categories and Usage

A reserved word, also called a keyword, is a word the Java compiler has claimed for its own use. It already means something to the language, so you are not allowed to use it as a name for your own classes, variables or methods.

Write this and the compiler stops you immediately:

int class = 50;
// ERROR: class is a keyword and cannot be used as a variable name

The reason Java is strict about this is safety. If you were allowed to name a variable class, then every existing program would become ambiguous, and old code could suddenly stop compiling. Reserved words guarantee that a piece of code always means the same thing.

HOW THE COMPILER TREACHES A NAME

    totalPrice   ──►  looks in the keyword list first
                        |
                        +── not a keyword ──► treat it as YOUR identifier
                        |
                        +── is a keyword  ──► syntax error, always

    Keywords are reserved for the whole language, everywhere, all the time.

• Java has 50 traditional keywords, and Java 9 added a 51st reserved word which is a lone underscore.

• true, false and null are reserved literals rather than keywords, but they behave exactly the same way for naming.

• Modern releases added contextual keywords such as var, record, sealed, permits and yield, which only act as keywords in specific positions.

Beginners often merge these three ideas. One line of code contains all three, which makes it a useful starting point.

ONE LINE, THREE DIFFERENT THINGS

    int   totalPrice   =   500;
     |        |            |
     |        |            +--► LITERAL   a fixed value typed directly
     |        +---------------► IDENTIFIER a name YOU invented
     +------------------------► KEYWORD    a word owned by Java

  KEYWORD    int, class, return, if, while, new, this
  LITERALS   500, 3.14, 'A', true, false, null
  IDENTIFIER totalPrice, customerAge, calculateTotal

• Keywords cannot be used anywhere as names, not even for a package.

• Literals cannot be used as names either, so true and null are permanently off limits.

• Identifiers are your own words. Anything that is neither a keyword nor a literal belongs here.

Reserved words are much easier to learn once you group them by what they do. Here is the whole picture in one place.

You do not need to memorise this table by heart. The next sections walk through each group with a working example, so the words stick because you have seen them do something.

These eight keywords are the simplest and the first you will meet. Each one maps to exactly one primitive type in the language.

• boolean stores true or false.

• byte, short, int and long store whole numbers of increasing size.

• char stores a single 16-bit character.

• float and double store decimal numbers, with double being the default for decimals.

• void is the odd one out. It is not a data type you declare variables with, but it is the return type of a method that hands back nothing.

public class DataTypes {
    public static void main(String[] args) {
        boolean isEnrolled = true;
        byte smallCount = 12;
        short mediumCount = 3200;
        int count = 250000;
        long phoneNumber = 9876543210L;
        char grade = 'A';
        float ratio = 0.75f;
        double price = 1499.99;
        System.out.println(isEnrolled + " " + smallCount + " " + mediumCount);
        System.out.println(count + " " + phoneNumber + " " + grade);
        System.out.println(ratio + " " + price);
    }
}

Notice that long values need an L suffix and float values need an f suffix. Without them Java treats the literal as a different type, which is a very common beginner error.

Control flow keywords decide which code runs and in what order. They are the vocabulary of every decision your program makes.

• if and else choose between two branches.

• while and do while repeat code, with do while running the body at least once.

• for repeats a known number of times and is the loop you will use most.

• break leaves a loop or switch immediately.

• continue skips to the next iteration of a loop.

• return leaves the current method and hands back an optional value.

• switch, case and default give you a multi-way choice that reads better than a long chain of else if blocks.

public class ControlFlowDemo {
    public static void main(String[] args) {
        int score = 82;
        if (score < 40) {
            System.out.println("Fail");
        } else if (score < 70) {
            System.out.println("Average");
        } else {
            System.out.println("Pass");
        } for (int i = 1;
        i

These are the words that make Java an object-oriented language in the first place.

• class declares a new reference type.

• interface declares a contract of methods.

• enum declares a fixed set of named constants.

• new creates an object in memory.

• extends creates an inheritance link between classes.

• implements connects a class to the interfaces it promises to honour.

• this points at the current object.

• super points at the parent class.

• instanceof checks the runtime type of a reference.

class Vehicle {
    void start() {
        System.out.println("Vehicle started");
    }
}class Car extends Vehicle implements Comparable {
    private final String model;
    Car(String model) {
        this.model = model;
    } // this refers to this object
    @Override public int compareTo(Car other) {
        return this.model.compareTo(other.model);
    } void showModel() {
        System.out.println("Model: " + model + ", parent is " + super.getClass().getSimpleName() + " from " + super.toString().split("@")[0]);
    }
}public class OopDemo {
    public static void main(String[] args) {
        Car car = new Car("Swift");
        // new creates the object
        car.start();
        // inherited from Vehicle
        Object reference = car;
        if (reference instanceof Car c) {
            // instanceof narrows the type
            System.out.println("Confirmed: " + c.model);
        }
    }
}

These three keywords decide who is allowed to touch a class or one of its members.

• Use private by default and open access only when there is a real reason.

• Use protected for members a subclass genuinely needs to reuse.

• Use public for the small surface of API that other code is meant to call.

Beyond visibility, Java has modifiers that change how a member behaves.

• static makes a member belong to the class rather than to each object.

• final stops a variable being reassigned, a method being overridden, or a class being extended.

• abstract demands that a class or method be completed by a subclass.

• synchronized protects shared resources from concurrent access.

• volatile guarantees visibility of a variable across threads.

• transient stops a field being serialised.

• native marks a method implemented outside Java, in another language.

• strictfp is now a no-op because Java 17 always uses strict floating point.

public class Shape {
    static final double PI = 3.14159;
    // constant shared by all shapes
    private String name;
    // every object has its own copy
    private transient int cache;
    // never written to a file
    public Shape(String name) {
        this.name = name;
    } public String getName() {
        return name;
    } public double area() {
        throw new UnsupportedOperationException("Subclass must override");
    }
}abstract class Circle extends Shape {
    private final double radius;
    Circle(double radius) {
        super("Circle");
        this.radius = radius;
    } @Override public double area() {
        return PI * radius * radius;
    }
}

package and import control how classes are organised and found.

• package places a class inside a named folder structure.

• import lets you refer to a class without typing its full name.

• Naming a package with a reserved word fails, because each part must be a legal identifier, so com.int.banking is illegal while com.integer.banking is fine.

package com.mycompany.billing.payment;
import java.util.List;
import java.time.LocalDate;
public class PaymentService {
    public void settle(List invoiceIds, LocalDate on) {
        System.out.println("Settled " + invoiceIds.size() + " invoices on " + on);
    }
}

Java uses five keywords to deal with runtime errors, and this is one area where the language design is unusually tidy.

• try marks the block of code that might fail.

• catch states what happens when a particular exception is thrown.

• finally always runs, whether or not an exception occurred, which makes it ideal for releasing resources.

• throw raises an exception yourself.

• throws declares in the method signature that an exception may escape.

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class FileDemo {
    // throws says: this method may hand an IOException back to the caller
    static int countLines(String path) throws IOException {
        int lines = 0;
        try(BufferedReader reader = new BufferedReader(new FileReader(path))) {
            while (reader.readLine() != null) {
                lines++;
            }
        } finally {
            System.out.println("Finished reading " + path);
        } return lines;
    } public static void main(String[] args) {
        try {
            System.out.println(countLines("data.txt"));
        } catch (IOException e) {
            System.out.println("Could not read the file: " + e.getMessage());
        }
    }
}

The try-with-resources form shown above is worth learning early, because it closes the file for you and needs no finally block at all.

Two keywords are reserved by the Java specification but were never given any meaning. Using them is a compile error rather than a feature.

• const was reserved because other languages needed a way to declare compile-time constants. Java solved that with final instead.

• goto was reserved because structured loops made it unnecessary, and unlimited jumps make code hard to follow.

// int const = 10;   ERROR: const is reserved and has no meaning in Java
// goto skip;        ERROR: goto is reserved and has no meaning in Java
// int goto = 1;     ERROR: same reason
int constant = 10;
// use a descriptive name, or declare it final
int constant = 10;
// and never reassign it

• Never name your own variables const or goto out of habit from C or C++.

• If you need a constant, declare it static final, which is exactly what the constants keyword list in the earlier table describes.

Newer Java versions have added words that only behave like keywords in specific positions. Elsewhere they are ordinary identifiers, which is why you can still write a variable called record.

CONTEXTUAL KEYWORDS ARRIVED OVER TIME

  Java 9     │  _            a lone underscore became reserved
  Java 10    │  var          local type inference
  Java 14    │  yield        value from a switch expression
  Java 16    │  record       immutable data carrier class
  Java 17    │  sealed       restricts who may extend a class
             │  permits      lists the allowed subclasses
             │  non-sealed   opts back out of a sealed hierarchy
             └────────────────────────────────────────────

• var asks the compiler to infer a local variable type from its initialiser, and you can still use var as a variable or method name.

• record creates a compact immutable data class, and you can still write a variable called record.

• sealed and permits create controlled inheritance hierarchies, useful for pattern matching.

• yield is used inside a switch expression to return a value, and it is not the same as return.

Almost everyone meets these errors once. The fix is nearly always renaming something.

• Keywords are matched as whole words only, so ClassFactory and recordCount are perfectly legal.

• That is exactly why good style adds a meaningful suffix such as ClassLoader or RecordEntry instead of an ugly one.

• Package names have the same rule, since each dot-separated part must be a legal identifier.

Keep this table close while you write your first programs. It is the whole keyword story on one screen.

Now that you can recognise every reserved word on sight, the next topic, Java variables, becomes much easier because you already know which names are available to you.