如果尝试在 null 对象上调用方法或访问其属性，就会抛出著名的 NullPointerException (NPE),导致程序崩溃。

下面我将从多个方面详细解释这个问题，包括原因、后果、解决方案和最佳实践。

为什么会出现属性对象为空？

根本原因在于：你创建了一个对象，但没有为它的某个引用类型的属性创建并赋值一个具体的对象实例。

让我们看一个经典的例子：

public class User {
    private String name; // 引用类型
    private Address address; // 引用类型，也是一个对象
    // 构造函数、getter 和 setter
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Address getAddress() {
        return address;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
}
public class Address {
    private String city;
    private String street;
    // getter 和 setter
    public String getCity() {
        return city;
    }
    public void setCity(String city) {
        this.city = city;
    }
    // ... 其他 getter/setter
}

场景分析：

public class Main {
    public static void main(String[] args) {
        // 1. 创建了 User 对象
        User user = new User();
        // 2. 给 name 赋了值
        user.setName("张三");
        // 3. 忘记给 address 赋值！
        // user.setAddress(new Address()); // 如果这行代码被注释掉或忘记执行
        // 4. 尝试使用 address 对象
        // user.getAddress() 此时返回的是 null
        String city = user.getAddress().getCity(); // 这里会抛出 NullPointerException！
    }
}

在上面的 main 方法中，我们创建了 User 对象，并设置了 name，但没有为 address 属性创建一个 Address 对象并赋给它。user.getAddress() 返回的就是 null，紧接着，我们尝试在 null 上调用 .getCity() 方法，JVM 找不到要执行的方法，于是程序终止并抛出 NullPointerException。

如何避免和处理 NullPointerException？

处理这个问题主要有两大思路：防御性编程 和 使用现代 Java 特性。

防御性编程（传统方法）

这是最基本也是最可靠的方法，核心思想是“永远不要相信外部输入”。

在使用前进行 null 检查

这是最直接的方式，在访问可能为 null 的对象前，先判断它是否为 null。

public String getUserCity(User user) {
    // 1. 检查 user 对象本身是否为 null
    if (user == null) {
        return "用户不存在";
    }
    // 2. 检查 address 对象是否为 null
    Address address = user.getAddress();
    if (address == null) {
        return "地址信息不存在";
    }
    // 3. 检查 city 对象是否为 null (String 也可能为 null)
    String city = address.getCity();
    if (city == null) {
        return "城市信息不存在";
    }
    return city;
}

• 优点：逻辑清晰，简单易懂，适用于所有 Java 版本。
• 缺点：代码会变得冗长，出现“嵌套的 if-else”（也称为“金字塔代码”）,影响可读性。

使用 Objects.requireNonNull

java.util.Objects 类提供了一个 requireNonNull 工具方法，它可以在 null 出现时立即抛出 NullPointerException,并且可以自定义异常信息。

import java.util.Objects;
public String getUserCity(User user) {
    // user 为 null，立即抛出 NPE，信息更清晰
    user = Objects.requireNonNull(user, "User 对象不能为空");
    // address 为 null，立即抛出 NPE
    Address address = Objects.requireNonNull(user.getAddress(), "Address 对象不能为空");
    // city 为 null，立即抛出 NPE
    String city = Objects.requireNonNull(address.getCity(), "City 不能为空");
    return city;
}

• 优点：将 null 检查提前，使后续代码可以“无脑”地使用对象，避免了重复的 if 判断,错误信息更明确。
• 缺点：仍然会抛出异常，只是让异常更早发生，如果希望返回默认值而不是抛出异常,则不适用。

返回默认值

如果某个属性可以为空，但在业务逻辑中需要一个默认值，可以使用 if-else 或者 Objects.requireNonNullElse (Java 9+)。

// 使用 if-else
String city = user.getAddress() == null ? "未知城市" : user.getAddress().getCity();
// 使用 Java 9+ 的 Objects.requireNonNullElse
String city = Objects.requireNonNullElse(user.getAddress().getCity(), "未知城市");

使用现代 Java 特性（推荐）

现代 Java 引入了许多旨在从根源上减少 NullPointerException 的特性。

使用 Optional 类 (Java 8+)

Optional 是一个容器对象，它可以包含或者不包含非 null 的值，它被设计用来更好地表示一个“可能为空”的值,强制开发者思考如何处理空值情况。

import java.util.Optional;
public Optional<String> getUserCitySafely(User user) {
    // 使用 Optional.ofNullable() 包装可能为 null 的对象
    // user.getAddress() 返回 null，则 Optional 为 empty()
    return Optional.ofNullable(user)
                   .map(User::getAddress)      // user 不为 null，则执行此映射
                   .map(Address::getCity);     // address 不为 null，则执行此映射
}
// 如何使用这个方法
public void printUserCity(User user) {
    // get() 方法在 Optional 为 empty 时会抛出 NoSuchElementException
    // 所以通常推荐使用 orElse, orElseGet, orElseThrow 等
    String city = getUserCitySafely(user).orElse("未知城市");
    System.out.println("城市是: " + city);
    // 或者提供一个 Supplier 来延迟生成默认值
    String city2 = getUserCitySafely(user).orElseGet(() -> getDefaultCity());
    System.out.println("城市是: " + city2);
}

• 优点：代码非常优雅、函数式，将“空值”处理逻辑显式化，避免了 if-else 的嵌套。Optional 强制你处理 empty() 的情况。
• 缺点：有一定的学习成本。不要将 Optional 用作方法参数或集合元素,它只应作为方法的返回类型。

使用 @NonNull 和 @Nullable 注解

通过静态分析工具（如 IntelliJ IDEA, Eclipse, 或构建工具插件），可以在编译时发现潜在的 NullPointerException。

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class UserService {
    // 使用注解明确表示：此方法返回的 User 对象绝不会为 null
    @Nonnull
    public User findUserById(String id) {
        // ... 查找逻辑
        return user; // 如果查找失败，这里应该抛异常而不是返回 null
    }
    // 使用注解明确表示：此方法的 address 参数可以为 null
    public void updateUserAddress(@Nullable Address address) {
        // ... 更新逻辑
        if (address != null) {
            // 安全地使用 address
        }
    }
}

• 优点：提高了代码的可读性和可维护性，静态分析工具可以在你编码时甚至编译前就发现问题,将运行时错误提前到编译时。
• 缺点：需要配合工具使用,并且需要团队开发规范来保证注解的正确使用。

最佳实践总结

1. 优先使用对象工厂或构建器：创建复杂对象时，使用工厂模式或构建器模式，确保对象在创建时就是完整、有效的，而不是创建一个“半成品”对象。

   // 好的实践
   User user = User.builder()
                   .name("张三")
                   .address(new Address("北京", "中关村"))
                   .build();

2. 尽早失败：在方法入口处对参数进行 null 检查，如果为 null，立即抛出异常,这比在方法深处抛出异常更容易定位问题。

3. Optional 是你的朋友：当一个方法可能返回“没有结果”时（而不是返回 null），让它的返回类型为 Optional<T>，这是处理“可能为空”的现代标准。

4. 避免不必要的 null 返回：如果一个方法找不到结果，考虑抛出一个特定的业务异常，而不是返回 null，这样调用方就必须处理这个异常，而不是忘记检查 null。

5. 拥抱注解：在项目中统一使用 @Nonnull 和 @Nullable 注解，并配置好静态分析工具，这是预防 NPE 最有效的手段之一。

6. 保持代码简洁：如果逻辑允许，使用 Objects.requireNonNullElse 或 Optional.orElse() 来避免冗长的 if-else 块。

通过结合这些策略，你可以大大减少 NullPointerException 的发生，写出更健壮、更易读的 Java 代码。