How Java’s New Null‑Restricted Types Aim to Eradicate NullPointerExceptions

Java language handling null references has long been a headache for developers. Many assume certain variables will never be null, but existing Java syntax cannot explicitly express this intent, leading to pervasive NullPointerException risks.

To address this, Java is introducing a new preview feature—Null‑Restricted and Nullable types. This feature allows developers to explicitly indicate whether a type permits null values, providing stronger type safety and detection at compile time and runtime.

Examples: Foo! is a non‑null‑restricted type—its acceptable values do not include null. Foo? is a nullable type—its acceptable values explicitly include null. Foo does not specify null acceptance, leaving it ambiguous.

Feature Highlights

Explicit nullability : Use Foo! to denote non‑null types, Foo? for nullable types, while the default Foo remains unspecified.

Compatibility with existing code : The feature can be introduced gradually, ensuring compatibility with traditional Java code without requiring a full refactor or changes to the standard library.

Automatic detection and warning of potential NullPointerExceptions : During type conversion, the Java compiler automatically checks for improper null handling and issues warnings. For example, converting Foo? to Foo! inserts runtime checks to prevent null ‑induced exceptions.

Strict initialization of fields and arrays : Fields or arrays declared with a null restriction must be initialized before they are read, otherwise an exception is thrown. For instance, String![] labels must provide initial values for each element.

Flexible nullness conversion : Types can be converted similarly to boxing and unboxing, making transitions between different nullability annotations natural, while still detecting risks at runtime.

Future Outlook

Although currently a preview, this feature gives Java developers a powerful tool to better control null handling. In the future, more APIs are expected to adopt these new syntaxes, and entire classes or modules might default to null‑restricted behavior.

This represents a significant benefit for developers, moving Java toward a more robust and safe programming language.

Comparison with TypeScript

In TypeScript, ! and ? have distinct meanings for handling optional properties and non‑null assertions.

1. ! Non‑null Assertion

The ! operator in TypeScript is called the non‑null assertion operator. It tells the compiler that a variable or property is definitely not null or undefined, even if static analysis cannot infer this.

Example:

let name: string | null = "Alice";
console.log(name!.toUpperCase()); // Non‑null assertion, assuming name is not null

Here name! asserts that name is not null. If the actual value is null, a runtime error may still occur, though the compiler does not flag it.

Common use cases:

When you are certain a value will not be null or undefined in certain contexts, but the compiler cannot deduce it.

Typical in DOM manipulation or third‑party library data handling within TypeScript projects.

2. ? Optional Property/Parameter

The ? symbol in TypeScript declares optional properties or parameters, indicating that the property may be absent or its value may be undefined.

Example 1: Optional Property

interface Person {
  name: string;
  age?: number; // optional property
}

const alice: Person = { name: "Alice" }; // age can be omitted

Marking a property or parameter with ? makes it optional, allowing omission or undefined values.

You interested in Java’s new feature? Share your thoughts in the comments!

Reference: Java new preview feature – Null‑Restricted and Nullable types. https://openjdk.org/jeps/12