Previous
Written by: rJTutorial Team | Last Updated:

Java Keywords

In the world of Java, keywords are the fundamental building blocks of the language's syntax. These are reserved words that have a special, predefined meaning to the Java compiler. Because they are part of the internal vocabulary of the language, you cannot use them to name your variables, classes, or methods.

Think of keywords as the "commands" that tell the Java Virtual Machine (JVM) exactly what to do whether it's creating a new object, starting a loop, or defining a decimal number.

Reserved Words:

  • Identifiers: Java keywords cannot be used as identifiers (e.g., you cannot name a variable int or a class public).
  • Case Sensitivity: All Java keywords are written in lowercase. For example, while is a keyword, but While is not.
  • Functionality: Each keyword is reserved for a specific structural or logical purpose within the code.
Developer Tip: While true, false, and null might look like keywords, they are technically "literals." However, they are still reserved, meaning you cannot use them as names for your variables or methods.
Java Reserved Keywords

Java Reserved Keywords

Keyword Description & Context
abstract Used to declare a class or method that does not have a full implementation.
assert Used for debugging; it tests an assumption that a condition is true.
boolean A data type that can only hold the values true or false.
break Used to exit a loop or a switch block immediately.
byte A primitive data type that holds an 8-bit integer.
case Used within switch statements to mark different blocks of code.
catch Defines a block of code to handle specific exceptions.
char A data type used to hold a single 16-bit Unicode character.
class The keyword used to define a new Java class.
const Reserved but not used by Java. Use final for constants instead.
continue Skips the current iteration of a loop and moves to the next one.
default The fallback code block in a switch statement or used for default interface methods.
do Used to start a do-while loop, which executes at least once.
double A data type used for large decimal numbers (64-bit precision).
else Defines the "otherwise" path in an if statement.
enum Used to define a fixed set of constants (enumerations).
extends Indicates that a class is inheriting from a parent class.
final Marks a variable as unchangeable, a method as unoverridable, or a class as unextendable.
finally A block in try-catch that always executes, regardless of an exception.
float A data type used for smaller decimal numbers (32-bit precision).
for Starts a standard loop used to repeat code a specific number of times.
goto Reserved but not used by Java. (Legacy keyword from C++).
if Used to create a conditional branch in your logic.
implements Used by a class to declare it will use a specific interface.
import Brings in other classes or entire packages so they can be used in your code.
instanceof Checks if an object is a specific type (class or interface).
int A primitive data type for 32-bit integers.
interface Used to declare a special type of class that contains only abstract methods (usually).
long A primitive data type for very large 64-bit integers.
native Indicates that a method is written in a language other than Java (like C++).
new Used to create new objects (instances of a class).
package Declares a namespace for the current Java file.
private An access modifier that hides members from any code outside the class.
protected Access modifier that allows access within the same package and by subclasses.
public Access modifier that makes a class or member visible to the entire project.
return Exits from a method and optionally sends back a value.
short A primitive data type for 16-bit integers.
static Indicates that a variable or method belongs to the class itself, not instances.
strictfp Ensures floating-point math is consistent across different platforms.
super Used to refer to the parent class (superclass) of the current object.
switch A multi-way branch statement based on a single value.
synchronized Used in multi-threading to prevent multiple threads from accessing code at once.
this Refers to the current instance of the class you are currently in.
throw Used to manually trigger (throw) an exception.
throws Declared in a method signature to warn that it might throw certain exceptions.
transient Tells Java not to include this variable when serializing an object.
try Starts a block of code where you expect exceptions might occur.
void Specifies that a method does not return any value.
volatile Used in multi-threading to ensure a variable's value is always read from main memory.
while Starts a loop that continues as long as a condition is true.
Watch Out: Even though const and goto are in the keyword list, they are not currently used in Java. They are "reserved" just in case Java developers decide to implement them in the future.

Practical Example

In the following example, we use several keywords to build a functional logic flow. Pay attention to how the keywords define the structure and visibility of the data.

package com.tutorial.example; // 'package' keyword organizes our code

public class Calculator { // 'public' and 'class' define our blueprint
    
    // 'static' and 'final' create a constant tied to the class
    public static final double PI = 3.14159;

    // 'int' and 'void' define data types and return types
    public void runDemo() {
        int limit = 3;
        
        // 'new' creates a new instance of an object
        String message = new String("Starting loop...");
        System.out.println(message);

        // 'for' starts a looping construct
        for (int i = 1; i <= limit; i++) {
            // 'if' and 'else' handle conditional logic
            if (i % 2 == 0) {
                System.out.println(i + " is even.");
            } else {
                System.out.println(i + " is odd.");
            }
        }
    }

    public static void main(String[] args) {
        Calculator myCalc = new Calculator();
        myCalc.runDemo();
    }
}
Common Mistake: Beginners often try to name variables using keywords, like int class = 5;. This will result in a compiler error. To fix this, use a more descriptive name like int classLevel = 5;.
Best Practice: Use the final keyword for variables that should not change after being assigned. This makes your code more predictable and prevents accidental bugs in large applications.

Summary

Java keywords are the "verbs" and "nouns" of the programming language. By mastering these 50+ reserved words, you gain the ability to control program flow, manage memory, and define complex data structures. As you gain experience, you'll stop thinking of them as a list to memorize and start seeing them as the natural tools needed to solve coding problems.

Previous