Scala has a similar construct called Option[T] to encapsulate the presence or absence of a value of type T. You then have to explicitly check whether a value is present or not using operations available on the Option type, which enforces the idea of "null checking." You can no longer "forget to do it" because it is enforced by the type system. OK, we diverged a bit and all this sounds fairly abstract. You might now wonder, "so, what about Java SE 8?"

January 8, 2024 - Here, @NonNull makes it clear that the argument cannot be null. If the client code calls this method without checking the argument for null, FindBugs would generate a warning at compile time. Developers generally rely on IDEs for writing Java code.

In Java, this would be the equivalent of a NullPointerException, or an NPE for short. Kotlin explicitly supports nullability as part of its type system, meaning you can explicitly declare which variables or properties are allowed to be null. Also, when you declare non-null variables, the compiler enforces that these variables cannot hold a null value, preventing an NPE. Kotlin's null safety ensures safer code by catching potential null-related issues at compile time rather than runtime.

3 weeks ago - This makes the previous annotations according to JSR 305 (Java Specification Request) obsolete (deprecated). JSpecify provides annotations that help prevent null pointer errors: @Nullable indicates that the value can potentially be null, while types annotated with @NonNull must never be null.

3 weeks ago - The easiest way to benefit from Spring null-safety is to upgrade to Spring Boot 4 and use an IDE that supports JSpecify annotations to provide feedback to the developer on how to handle potential nullability issues detected from Spring APIs usage.

October 1, 2025 - At execution time, however, a reference can be void (or null). In such cases, the call above will be a void call, leading to a run-time exception, often resulting in abnormal termination of the program. Void safety is a static (compile-time) guarantee that a void call will never arise.

Answer (1 of 4): Good question. Java is safer than C++ in this respect; NullPointerException at least does not crash the process in the OS. Java 8 Optional has given us a bit more for streams and method returns, but is still not quite there for representing values that might not be there. You ...

October 9, 2009 - Also, during debugging, it would make it difficult to know which value is null. ... Yes, it was rejected. Whilst it makes sense in Groovy, when actually tried out with real Java codebases as part of project coin testing, it didnt work so well compared to the Groovy implementation.

1 month ago - When a variable contains null, an attempt to dereference the variable leads to a NullPointerException. There are many ways to write code in order to minimize the probability of receiving null pointer exceptions. This guide covers differences between Java's and Kotlin's approaches to handling possibly nullable variables.

October 22, 2025 - JPlus code compiles to standard JVM bytecode, enabling full use of Java libraries and frameworks. JPlus enforces strict null checks at compile-time and introduces Kotlin-style operators:

October 22, 2025 - News and discussion of science and technology such as AI, VR, cryptocurrency, quantum computing, and more.

September 24, 2025 - The fundamental problem in Java is that nullability is implicit. Unless explicitly stated in API documentation, developers can't be sure whether a return value can be null, leading to misunderstandings and bugs. To solve this problem, teams from Google, JetBrains, Spring, and others collaborated to create the JSpecify standard. JSpecify is more than just a set of annotations; it provides a clear specification for null safety, ensuring consistent behavior across tools like IDEs and static analyzers.

September 6, 2025 - Passing null where an object is required · Detected at runtime: Unlike checked exceptions, these are not enforced by the compiler. No need for throws clause: Code that might throw unchecked exceptions doesn’t need to declare or catch them. Design philosophy: Java encourages using unchecked exceptions for programming errors and checked exceptions for recoverable conditions. Though seemingly separate, type safety helps prevent unchecked exceptions like ClassCastException at runtime.

October 17, 2024 - Whether you use traditional checks, Optional, or the Objects class, you can write code that is both readable and safe from null pointer exceptions. By leveraging these standard Java features, you can keep your codebase lightweight and maintainable without relying on third-party dependencies.

February 16, 2023 - Developers praise Kotlin for its null-safety: it's the result of its null-handling mechanism baked into the language design. Java will never be able to compete with Kotlin in this regard, as Java language architects value backward compatibility over code safety.

Although Java does not let you express nullness markers with its type system yet, the Spring Framework codebase is annotated with JSpecify annotations to declare the nullability of its APIs, fields, and related type usages. Reading the JSpecify user guide is highly recommended in order to get familiar with those annotations and semantics. The primary goal of this null-safety arrangement is to prevent a NullPointerException from being thrown at runtime via build time checks and to use explicit nullability as a way to express the possible absence of value.

March 10, 2025 - JSpecify is a set of annotations, specifications and documentation designed to ensure the null safety of Java applications and libraries in the IDE or during the compilation thanks to tools like NullAway.

April 30, 2024 - Java 8 introduced a powerful new class called Optional<T> aimed at combating these exceptions by encouraging developers to handle the absence of values more gracefully. Optional<T> is a container object used to represent a value that is either present or absent. It provides a clear and explicit way to deal with the absence of a value, rather than relying on null, thus helping avoid NullPointerExceptions.

February 11, 2024 - Introduced in Java 1.8, the Optional class gives a null safe standard library class for Java developers to express that a value may or may not be present. Null safety is an important characteristic of code, so much so that null safety is a first class feature of many newer programming languages.

November 22, 2022 - We developed a new static analysis tool called Nullsafe that is used at Meta to detect NullPointerException (NPE) errors in Java code. Interoperability with legacy code and gradual deployment model were key to Nullsafe’s wide adoption and allowed us to recover some null-safety properties in the context of an otherwise null-unsafe language in a multimillion-line codebase.