Special Keywords and Modifiers

What are Keywords and Modifiers?

Java reserves a set of words that carry specific meaning to the compiler and the runtime. You cannot use them as identifiers for variables, methods, or classes. Among these, modifiers are keywords that change the behaviour or accessibility of a declaration. Some modifiers affect visibility, such as public and private. Others affect how something is stored, shared, or executed.

This tutorial focuses on the modifiers and special keywords that show up most in real Java code and that beginners often find confusing: static, final, abstract, synchronized, volatile, transient, native, strictfp, instanceof, and a revisit of this and super.

static

The static modifier means that something belongs to the class itself rather than to any particular instance of that class. A static field is shared across all objects: there is only one copy of it in memory, and every object reads and writes the same value. A static method can be called using the class name directly, without creating an object first.

Static methods cannot access instance members (non-static fields or methods) directly, because there is no this reference inside them. They can only work with other static members or with objects passed to them as arguments. Static blocks are special initialisation blocks that run once when the class is first loaded by the JVM.

final

The final keyword means "this cannot change or be extended further." Its precise effect depends on where you place it. On a variable, it means the variable can only be assigned once; on a method, it means no subclass can override it; on a class, it means no class can extend it.

For object references declared final, the reference itself is fixed, but the object it points to is still mutable. This is a subtle but important distinction. If you write final List<String> names = new ArrayList<>(), you cannot make names point to a different list, but you can still call names.add() to modify the existing list.

abstract

The abstract modifier signals that something is incomplete by design and must be completed elsewhere. An abstract class cannot be instantiated directly: it exists to be extended. An abstract method has no body: the concrete subclass must provide the implementation. If a class contains even one abstract method, the class itself must also be declared abstract.

Abstraction is covered in depth in the Abstraction tutorial. Here, the focus is on understanding abstract as a keyword modifier and how it interacts with final and static.

synchronized

When multiple threads access the same object at the same time, you can get race conditions: two threads both read a value, both modify it, and one thread's change overwrites the other's. The synchronized keyword prevents this by allowing only one thread to execute a given block of code on a given object at a time. A thread must acquire the object's intrinsic lock (also called a monitor) before entering, and releases it when it exits.

You can synchronise an entire method by adding the keyword to the method signature, or synchronise just a critical block of code using a synchronized(obj) block. Synchronising a smaller block is often preferable because it reduces the time the lock is held, allowing other threads to proceed sooner.

volatile

Modern CPUs and JVMs optimise performance by caching variable values in thread-local registers or CPU caches. This means one thread might see a stale copy of a value that another thread has already updated in main memory. The volatile keyword tells the JVM never to cache this field locally: every read must come from main memory, and every write must go directly to main memory. This guarantees visibility across threads.

However, volatile does not guarantee atomicity. If two threads both read a volatile int and then both increment it, you can still lose updates because increment is a read-modify-write operation, not a single atomic step. volatile is most useful for simple flag-style variables (like a stop signal) where one thread writes and another thread reads.

transient

Java's serialisation mechanism converts an object into a byte stream that can be saved to a file, sent over a network, or stored in a database, and then reconstructed later. By default, every non-static field of a Serializable class is included in this byte stream.

The transient modifier tells the serialisation engine to skip a particular field. This is useful for fields that hold sensitive data (such as passwords or session tokens), fields that cannot be serialised (such as open database connections or file handles), or derived fields that can be recomputed from other data.

native

The native modifier marks a method whose implementation is written in another programming language, typically C or C++, and is accessed through the Java Native Interface (JNI). The method declaration in Java ends with a semicolon and has no body, similar in looks to an abstract method.

The JVM links the native method to a compiled shared library (a .dll on Windows or a .so on Linux). You will encounter native methods in the core Java class library itself: Object.hashCode(), System.currentTimeMillis(), and Thread.sleep() are all implemented natively because they need to talk directly to the operating system. Most application code never needs to write native methods directly.

strictfp

Floating-point arithmetic on different hardware platforms and JVM implementations can produce slightly different results because CPUs use varying internal precision for intermediate calculations. The strictfp modifier forces all floating-point operations within an annotated class or method to follow the IEEE 754 standard exactly. This produces identical results on any platform, at the potential cost of a small performance hit.

From Java 17 onwards, strictfp is the default behaviour for all code, meaning the modifier is now effectively redundant. It is still a legal keyword and will not cause a compile error, but modern code rarely uses it. You will encounter it mainly when reading older codebases or working with systems that ran on pre-Java 17 runtimes.

instanceof

The instanceof operator tests whether an object is an instance of a particular class or interface. It returns true if the object on the left can be safely cast to the type on the right, and false otherwise. If the left operand is null, the result is always false.

Java 16 introduced pattern matching for instanceof, allowing you to combine the type check and the cast into one step. Instead of checking the type and then casting on separate lines, you can write if (obj instanceof String s), which both checks the type and declares a new variable s that is already of type String and in scope within the if block.

this and super Revisited

You have already encountered this and super in earlier tutorials. Here, the goal is to consolidate all their uses in one place and highlight the nuances that often trip people up.

Quick Reference

Below is a concise summary of every keyword covered in this tutorial. Use it as a reference when you encounter these modifiers in code you are reading or debugging.

Quiz - Test Your Knowledge

Ten questions covering static, final, abstract, synchronized, volatile, transient, native, strictfp, instanceof, and the uses of this and super. Read each option carefully before selecting your answer.