# Reserved Words

Java reserved words cannot be used in any capacity other than their intended purpose. You cannot use these words for variables, methods, classes, or anything else. Many of these aren't used in this course, and won't be assessed on the AP exam.

| **Reserved Word** | **Description**                                                                                                |
| ----------------- | -------------------------------------------------------------------------------------------------------------- |
| `abstract`        | An abstract class or method.                                                                                   |
| `assert`          | An assertion that a condition is met, often used during debugging.                                             |
| `boolean`         | A primitive data type that stores true and false values.                                                       |
| `break`           | Breaks out of a `switch` statement or loop.                                                                    |
| `byte`            | A primitive data type that stores 8-bit integers.                                                              |
| `case`            | A label in a `switch` statement.                                                                               |
| `catch`           | The clause of a `try` block designed to handle an exception.                                                   |
| `char`            | A primitive data type that stores Unicode characters.                                                          |
| `class`           | Defines a class type.                                                                                          |
| `const`           | Unused but reserved nonetheless.                                                                               |
| `continue`        | Skips the remainder of a loop body.                                                                            |
| `default`         | The default clause of a `switch` statement, or a default method in an interface.                               |
| `do`              | The opening component of a `do...while` loop.                                                                  |
| `double`          | A primitive data type that stores double-precision floating-point numbers.                                     |
| `else`            | The alternative clause of an `if` statement.                                                                   |
| `enum`            | An enumerated type.                                                                                            |
| `extends`         | Indicates that a class is the subclass of another.                                                             |
| `final`           | A constant, or a class or method that cannot be extended or overridden.                                        |
| `finally`         | The clause of a `try` block that is always executed.                                                           |
| `float`           | A primitive data type that stores single-precision floating-point numbers.                                     |
| `for`             | A loop type.                                                                                                   |
| `goto`            | Unused but reserved nonetheless.                                                                               |
| `if`              | A conditional control statement.                                                                               |
| `implements`      | Defines the interface(s) that a class implements.                                                              |
| `import`          | Imports a package.                                                                                             |
| `instanceof`      | Tests if an object is an instance of a particular class.                                                       |
| `int`             | A primitive data type that stores 32-bit integers.                                                             |
| `interface`       | An abstract type with methods that a class can implement.                                                      |
| `long`            | A primitive data type that stores 64-bit integers.                                                             |
| `native`          | A method implemented by the host system.                                                                       |
| `new`             | Allocated a new object or array.                                                                               |
| `null`            | A `null` reference (technically a literal, rather than a keyword).                                             |
| `package`         | A package of classes.                                                                                          |
| `private`         | A feature that is accessible only by methods of the same class.                                                |
| `protected`       | A feature that is accessible only by methods of the same class, its children, and classes in the same package. |
| `public`          | A feature that is accessible by methods of all classes.                                                        |
| `return`          | Returns a value from a method.                                                                                 |
| `short`           | A primitive data type that stores 16-bit integers.                                                             |
| `static`          | A feature that is unique to a class or interface, but not to an instance of the class.                         |
| `strictfp`        | Use strict rules for floating-point computations.                                                              |
| `super`           | Invokes a constructor or method of the parent class.                                                           |
| `switch`          | A multiple selection statement.                                                                                |
| `synchronized`    | A method or block of code that is atomic to a thread.                                                          |
| `this`            | The implicit argument of a method, or invocation of a constructor of the same class.                           |
| `throw`           | Throws an exception.                                                                                           |
| `throws`          | The exceptions that a method can throw.                                                                        |
| `transient`       | Marks instance variables that should not be persisted (or serialized).                                         |
| `try`             | A block of code with exception handling.                                                                       |
| `void`            | Denotes a method that returns no value.                                                                        |
| `volatile`        | Ensures that a variable is coherently accessed by multiple threads.                                            |
| `while`           | A loop type.                                                                                                   |
