Programming Vocabulary in Java
In the ever-evolving world of programming, Java remains a popular choice for developers worldwide. One fundamental aspect of the Java language is its set of keywords, which are reserved words with predefined meanings used by the Java compiler for various internal processes. As of Java 21, there are 53 keywords defined in the language, providing a robust foundation for building applications.
Java keywords are crucial for defining the language's syntax and structure, and they are used for a wide range of purposes. Some examples include specifying that a class or method will be implemented later (abstract), indicating alternative branches in an if statement (else), starting a for loop (for), or declaring an enumerated type (enum).
Here's a breakdown of the current Java keywords, categorised for clarity:
1. **Access specifier keywords:** - `public`: Makes a method or variable accessible from any class or package. - `private`: Restricts a method or variable's access to the current class only. - `protected`: Allows access within the current class, its subclasses, and within the same package.
2. **Class and object-related keywords:** - `class`: Defines a new class. - `interface`: Defines a new interface. - `enum`: Defines a new enumerated type. - `extends`: Indicates the superclass of a class or the superinterface of an interface. - `implements`: Lists the interfaces that a class implements. - `new`: Creates a new instance of a class. - `this`: Refers to the current object. - `super`: Refers to the current object's base class.
3. **Control flow keywords:** - `if`: Executes code based on a condition. - `else`: Provides an alternative branch in an if-else statement. - `switch`: Executes code based on a test value. - `case`: Specifies a case in a switch statement. - `default`: Represents the default case in a switch statement. - `while`: Starts a while loop. - `do`: Starts a do-while loop. - `for`: Starts a for loop. - `break`: Exits a loop or a switch statement. - `continue`: Skips to the next iteration of a loop. - `return`: Sends control and possibly a return value back from a called method.
4. **Exception handling keywords:** - `try`: Starts a block of code that will be tested for exceptions. - `catch`: Catches and handles exceptions. - `finally`: Contains code that will always be executed, regardless of whether an exception is thrown or not. - `throw`: Throws a new exception. - `throws`: Declares that a method may throw an exception.
5. **Primitive types and related:** - `byte`: A data type that can hold an 8-bit signed integer. - `short`: A data type that can hold a 16-bit signed integer. - `int`: A data type that can hold a 32-bit signed integer. - `long`: A data type that can hold a 64-bit signed integer. - `float`: A data type that can hold a single-precision floating-point number. - `double`: A data type that can hold a double-precision floating-point number. - `boolean`: A data type that can hold a true or false value. - `char`: A data type that can hold a single Unicode character. - `void`: Specifies that a method does not have a return value. - `null`: Represents the absence of a value (though null is a literal, not a keyword).
6. **Modifiers:** - `static`: Indicates that a variable or method is a class method (rather than being limited to one particular object). - `final`: Prevents a variable or method from being overridden or reassigned. - `abstract`: Specifies that a class or method is abstract (and must be implemented by a subclass). - `synchronized`: Specifies critical sections or methods in multithreaded code. - `volatile`: Indicates that a variable may change asynchronously. - `transient`: Indicates that a variable should not be included in serialisation. - `native`: Indicates that a method is implemented in native code (not written in Java). - `strictfp`: Restricts the precision and rounding of floating-point calculations to ensure portability.
7. **Other keywords:** - `package`: Defines the package of a class or interface. - `import`: Imports classes, interfaces, or packages for use in the current class. - `instanceof`: Indicates whether an object is an instance of a specific class or implements an interface. - `assert`: Used for testing conditions during runtime. - `const`: Reserved but not currently used in Java. - `goto`: Reserved but not currently used in Java.
Notably, keywords such as `delete`, `main`, `exit`, or `null` are not Java keywords. `main` is a method name convention, while `null` is a literal. Java 21 introduced some newer language features, such as string templates preview, but these do not add new keywords; rather, they extend syntax or utilize existing keywords in innovative ways.
In summary, the current Java keywords in Java 21 remain consistent with the long-standing Java language specification, with some additions for preview features but no fundamental keyword changes. The core 50+ Java keywords for syntax, access control, flow control, types, and exception handling constitute the full set.
Java technology, in its current form with Java 21, incorporates a distinct set of keywords that are crucial for structuring the language. These keywords, such as 'for' and 'enum', are used for looping, defining enumerated types, and more. Each keyword has a specific purpose, whether it be for access specification, controlling flow, handling exceptions, or defining primitive types and related concepts.
