Keywords in Java

keywords are reserved words that have predefined meanings and cannot be used as identifiers (such as variable names, method names, or class names) within the program. These keywords are part of the Java language syntax and serve specific purposes in defining the structure, behavior, and functionality of Java programs. Java keywords are case-sensitive, meaning they must be written in lowercase letters.

In the below PDF we discuss about Variables in Java in detail in simple language, Hope this will help in better understanding.

List of all Java Keywords:

  • abstract: Used to declare abstract classes and methods.
  • assert: Used for debugging purposes to assert a condition.
  • boolean: Declares a boolean data type.
  • break: Exits from the innermost loop or switch statement.
  • byte: Declares a byte data type.
  • case: Defines a case within a switch statement.
  • catch: Catches and handles exceptions in exception handling.
  • char: Declares a character data type.
  • class: Declares a class.
    const (not used): Reserved for future use.
  • continue: Skips the current iteration of a loop and proceeds to the next iteration.
  • default: Defines the default case in a switch statement.
  • do: Initiates a do-while loop.
  • double: Declares a double-precision floating-point data type.
  • else: Specifies an alternative condition in an if-else statement.
  • enum: Declares an enumeration (enum) type.
  • extends: Indicates inheritance, where one class extends another class.
  • final: Prevents a variable, method, or class from being modified or extended.
  • finally: Defines a block of code to be executed after try-catch blocks, regardless of whether an exception is thrown.
  • float: Declares a floating-point data type.
  • for: Initiates a for loop.
    goto (not used): Reserved for future use.
  • if: Defines a conditional statement.
  • implements: Indicates that a class implements an interface.
  • import: Imports packages or classes into the current Java file.
  • instanceof: Checks whether an object is an instance of a particular class or interface.
  • int: Declares an integer data type.
  • interface: Declares an interface.
  • long: Declares a long integer data type.
  • native: Specifies that a method is implemented in platform-dependent code (e.g., C or C++).
  • new: Creates a new object.
  • null: Represents a null reference or absence of a value.
  • package: Declares a package of related classes and interfaces.
  • private: Specifies that a member (variable or method) is accessible only within its own class.
  • protected: Specifies that a member is accessible within its own package and by subclasses.
  • public: Specifies that a member is accessible by all classes.
  • return: Exits from a method and optionally returns a value.
  • short: Declares a short integer data type.
  • static: Specifies that a member belongs to the class rather than instances of the class.
  • strictfp: Ensures consistent floating-point arithmetic across different platforms.
  • super: Refers to the superclass (parent class) of the current object.
  • switch: Defines a switch statement for multi-way branching.
  • synchronized: Controls access to a block of code by multiple threads.
  • this: Refers to the current object.
  • throw: Throws an exception explicitly.
  • throws: Indicates that a method may throw one or more exceptions.
  • transient: Specifies that a variable should not be serialized.
  • try: Defines a block of code that may generate exceptions
  • void: Specifies that a method does not return a value.
  • volatile: Indicates that a variable may be modified asynchronously.
  • while: Initiates a while loop.


Java keywords are fundamental building blocks of Java programs, providing syntax rules and structure for defining classes, methods, control flow, and data types. By understanding and correctly using Java keywords, developers can write clear, concise, and effective Java code that adheres to the language specifications and conventions.

Must Read: Variables in Java

Related Question

Keywords in Java are reserved words that have predefined meanings and cannot be used for any other purpose such as naming variables, classes, or methods.

Java keywords are fundamental building blocks of the language’s syntax and semantics. They define the structure, behavior, and flow of Java programs. Proper understanding and usage of keywords are essential for writing correct and efficient Java code.

No, Java keywords are not case-sensitive. This means that you can use them in any case (lowercase, uppercase, or mixed case) and they will have the same meaning. For example, public, Public, and PUBLIC all represent the same keyword.

No, Java keywords cannot be used as identifiers such as variable names, method names, or class names. Attempting to use a keyword as an identifier will result in a compilation error.

You can access variables from another class by creating an instance of that class and then using dot notation to access the variables. Instance variables can be accessed directly if they are public, or through accessor methods (getters/setters). Static variables can be accessed using the class name followed by the dot operator.


A Complete Guide to Java

Java Regex | Regular Expressions

Java Collection Framework The Java

Multithreading in Java Multithreading refers

File Handling in Java File

Exception Handling in Java An

Packages in Java A package

1 thought on “Keywords in Java”

Leave a Comment

Your email address will not be published. Required fields are marked *

// Sticky ads