Optional Construction & Query

## What an Optional is In Java, a variable of a reference type (like `String` or `Customer`) can hold either an object or the special value `null`, meaning "nothing here." Calling a method on `null` throws a `NullPointerException` (NPE) at runtime. `Optional<T>` is a small container (a box) that holds *either* one value of type `T` or *nothing*. Its purpose is to make "this might be absent" visible in the type itself, so callers are reminded to handle the empty case instead of forgetting and hitting an NPE. An Optional is **immutable** (you can't change what's inside once created) and is a **value-based class** (don't synchronize on it or compare with `==`). ## The three factory methods (constructors) You never use `new Optional(...)`; the constructor is private. You create one through three static factory methods: 1. **`Optional.of(value)`** — Creates an Optional that contains `value`. If `value` is `null`, it throws a `NullPointerException` *right then*, on the line that calls `of`. Use this only when you are sure the value is non-null. Throwing early is actually helpful: it surfaces a programming bug at its source rather than letting a `null` travel deep into your code. 2. **`Optional.ofNullable(value)`** — The defensive version. If `value` is non-null it behaves exactly like `of`. If `value` is `null` it returns an *empty* Optional instead of throwing. This is the method you use whenever the source could legitimately be null: a `Map.get`, a field that may be unset, a result from older code that uses null to mean "not found." 3. **`Optional.empty()`** — Returns an Optional containing nothing. Internally Java returns a single shared empty instance (a cached singleton), so this is cheap. Use it as a base case, a default, or when you deliberately want to express "no value." ## How to choose - You **know** it's non-null (e.g., you just constructed it): use `of`. You *want* an NPE if it's somehow null, because that would mean a bug. - It **might** be null: use `ofNullable`. This is the single most common safe choice when bridging nullable code into the Optional world. - You want an explicit empty: use `empty()`. ## Common mistake Writing `Optional.of(map.get(key))` is a frequent bug: `Map.get` returns `null` when the key is missing, so `of` throws an NPE — exactly the situation Optional was meant to prevent. The correct call is `Optional.ofNullable(map.get(key))`. ## Tiny example ```java String known = "hello"; Optional<String> a = Optional.of(known); // holds "hello" Optional<String> b = Optional.ofNullable(null); // empty, no throw Optional<String> c = Optional.empty(); // empty // Optional.of(null); // throws NullPointerException ``` With these three you can wrap any source — guaranteed-present, maybe-null, or deliberately-absent — into the same container type, and downstream code handles all of them uniformly.