return Optional.of(Boolean.TRUE);
        }
        return Optional.empty();
    }

    @Override
    @Nonnull
    public Optional<Boolean> model() {
        if (commandLine.hasOption(CLIManager.MODEL)) {
            return Optional.of(Boolean.TRUE);
        }
        return Optional.empty();
    }

    @Override
    @Nonnull
    public Optional<Boolean> plugins() {

兩者等價且底層相同，但我會推薦用 `Union` 而不要用 `Optional`，因為「optional」這個詞看起來會讓人以為這個值是可選的，但實際上它的意思是「可以是 `None`」，即使它不是可選的、仍然是必填。

我認為 `Union[SomeType, None]` 更能清楚表達其含義。

這只是措辭與命名問題，但這些詞會影響你與團隊成員對程式碼的理解。

例如，看看下面這個函式：

```python
from typing import Optional


def say_hi(name: Optional[str]):
    print(f"Hey {name}!")
```

參數 `name` 被標註為 `Optional[str]`，但它並不是可選的；你不能在沒有該參數的情況下呼叫這個函式：

```Python

     *
     * @return An Optional containing the lowest matching version, or empty Optional if no versions
     *         matched the requested range
     */
    @Nonnull
    default Optional<Version> getLowestVersion() {
        return getVersions().isEmpty()
                ? Optional.empty()
                : Optional.of(getVersions().get(0));
    }

    /**

Hier ist ein Tipp aus meiner sehr **subjektiven** Perspektive:

* 🚨 Vermeiden Sie die Verwendung von `Optional[SomeType]`
* Verwenden Sie stattdessen ✨ **`Union[SomeType, None]`** ✨.

     *
     * @return an {@link Optional} containing the list of goals, or empty if not specified
     */
    @Nonnull
    Optional<List<String>> goals();

    /**
     * Returns the target POM model version for upgrades.
     * Supported values include "4.0.0" and "4.1.0".
     *
     * @return an {@link Optional} containing the model version, or empty if not specified
     */
    @Nonnull

하지만 여기의 예시는 이런 사용 사례를 위해 만들어진 `PATCH`를 사용합니다.

///

/// note | 참고

입력 모델은 여전히 검증된다는 점에 유의하세요.

따라서 모든 속성을 생략할 수 있는 부분 업데이트를 받으려면, 모든 속성이 optional로 표시된(기본값을 가지거나 `None`을 기본값으로 가지는) 모델이 필요합니다.

**업데이트**를 위한 “모든 값이 optional인” 모델과, **생성**을 위한 “필수 값이 있는” 모델을 구분하려면 [추가 모델](extra-models.md)에 설명된 아이디어를 사용할 수 있습니다.

  }

  @AndroidIncompatible
  public void testJavaOptional() {
    FreshValueGenerator generator = new FreshValueGenerator();
    assertEquals(Optional.empty(), generator.generateFresh(new TypeToken<Optional<String>>() {}));
    assertEquals(Optional.of("2"), generator.generateFresh(new TypeToken<Optional<String>>() {}));

			Key:         apiRequestsMax,
			Description: `set the maximum number of concurrent requests (default: auto)`,
			Optional:    true,
			Type:        "number",
		},
		config.HelpKV{
			Key:         apiClusterDeadline,
			Description: `set the deadline for cluster readiness check` + defaultHelpPostfix(apiClusterDeadline),
			Optional:    true,
			Type:        "duration",
		},
		config.HelpKV{
			Key:         apiCorsAllowOrigin,

    private ProtoLookup(Map<Class<?>, Object> components) {
        this.components = components;
    }

    @Override
    public <T> T lookup(Class<T> type) {
        Optional<T> optional = lookupOptional(type);
        if (optional.isPresent()) {
            return optional.get();
        } else {
            throw new LookupException("No mapping for key: " + type.getName());
        }
    }

    @Override

            .add("field11", Arrays.asList("Hello"))
            .add("field12", new ArrayList<>())
            .add("field13", new HashMap<>())
            // Optionals
            .add("field26", Optional.of("World"))
            .add("field27", Optional.absent())
            // Arrays
            .add("field31", new Object[] {"!!!"})
            .add("field32", new boolean[0])
            .add("field33", new byte[0])