告别NPE噩梦：彻底解决Java NullPointerException的根源与实践（附代码）

public class NpeDefinition {
    public static void main(String[] args) {
        String myString = null; // myString 引用现在是null
        System.out.println(myString.length()); // 尝试调用null对象的length()方法，NPE发生！
    }
}

public class NpeScene1 {
    public static void main(String[] args) {
        // 场景一：直接赋null
        String text = null;
        try {
            System.out.println(text.toUpperCase()); // NPE! text 是 null
        } catch (NullPointerException e) {
            System.err.println("NPE caught: " + e.getMessage());
        }

        // 场景二：未初始化引用
        User user; // 引用声明了，但没有初始化，默认是null (局部变量不会自动初始化，编译错误；成员变量默认是null)
        // System.out.println(user.getName()); // 如果user是局部变量，这里会是编译错误 "variable user might not have been initialized"
                                             // 如果user是类成员变量，则这里会是NPE
    }
}

class User {
    private String name;
    public String getName() { return name; }
}

import java.util.HashMap;
import java.util.Map;

public class NpeScene2 {
    public static void main(String[] args) {
        Map<String, String> config = new HashMap<>();
        config.put("timeout", "5000");

        String port = config.get("port"); // "port" 不存在，get() 返回 null
        try {
            System.out.println("Port length: " + port.length()); // NPE! port 是 null
        } catch (NullPointerException e) {
            System.err.println("NPE caught: " + e.getMessage());
        }
    }
}

public class NpeScene3 {
    public void processName(String name) {
        // 如果 name 是 null，这里就会抛出 NPE
        System.out.println("Processed name: " + name.toLowerCase());
    }

    public static void main(String[] args) {
        NpeScene3 processor = new NpeScene3();
        try {
            processor.processName(null); // 传入 null
        } catch (NullPointerException e) {
            System.err.println("NPE caught: " + e.getMessage());
        }
    }
}

import java.util.List;
import java.util.ArrayList;

public class NpeScene4 {
    public static void main(String[] args) {
        List<String> items = null; // 集合引用是 null
        try {
            items.add("new item"); // NPE! 试图向 null 集合添加元素
        } catch (NullPointerException e) {
            System.err.println("NPE caught: " + e.getMessage());
        }

        List<String> anotherList = new ArrayList<>(); // 正确初始化
        // items.addAll(anotherList); // 如果 items 是 null，这里也会 NPE
    }
}

public class NpeScene5 {
    public static void main(String[] args) {
        Integer count = null; // 包装类型为 null
        try {
            int primitiveCount = count; // 自动拆箱时，尝试将 null 转换为 int
            System.out.println(primitiveCount); // NPE!
        } catch (NullPointerException e) {
            System.err.println("NPE caught: " + e.getMessage());
        }

        // 另一个例子：比较
        Integer value1 = null;
        Integer value2 = 10;
        try {
            if (value1 < value2) { // 比较时触发自动拆箱，value1为null，NPE
                System.out.println("value1 is less than value2");
            }
        } catch (NullPointerException e) {
            System.err.println("NPE caught during comparison: " + e.getMessage());
        }
    }
}

public class NpeScene6 {
    static class User {
        Address address;
        public Address getAddress() { return address; }
    }

    static class Address {
        String street;
        public String getStreet() { return street; }
    }

    public static void main(String[] args) {
        User user = new User(); // user 实例存在
        // user.address = null; // 默认就是 null

        try {
            // 如果 user.getAddress() 返回 null，再调用 .getStreet() 就会NPE
            String streetName = user.getAddress().getStreet(); // NPE! user.address 是 null
            System.out.println(streetName);
        } catch (NullPointerException e) {
            System.err.println("NPE caught in chained call: " + e.getMessage());
        }
    }
}

public class NpeSolution1 {
    // 方法参数进行null检查
    public String safeProcessName(String name) {
        if (name == null) {
            System.out.println("Error: Name cannot be null.");
            // 可以选择抛出 IllegalArgumentException，或者返回默认值，或做其他逻辑处理
            throw new IllegalArgumentException("Name cannot be null");
        }
        return name.toLowerCase();
    }

    // 外部API返回结果的null检查
    public String getUserStatus(Map<String, String> userData) {
        String status = userData.get("status"); // Map.get() 可能返回 null
        if (status == null) {
            return "UNKNOWN"; // 返回一个默认值或抛出异常
        }
        return status.toUpperCase();
    }

    public static void main(String[] args) {
        NpeSolution1 app = new NpeSolution1();
        try {
            app.safeProcessName(null);
        } catch (IllegalArgumentException e) {
            System.err.println("Exception: " + e.getMessage());
        }

        Map<String, String> user1 = new HashMap<>();
        user1.put("id", "123");
        System.out.println("User 1 status: " + app.getUserStatus(user1)); // 输出 UNKNOWN

        Map<String, String> user2 = new HashMap<>();
        user2.put("status", "active");
        System.out.println("User 2 status: " + app.getUserStatus(user2)); // 输出 ACTIVE
    }
}

import java.util.Objects;

public class NpeSolution2 {
    public void processOrder(Order order) {
        Objects.requireNonNull(order, "Order object cannot be null"); // 如果order是null，直接抛NPE
        // 继续处理 order...
        System.out.println("Processing order with ID: " + order.getOrderId());
    }

    public static void main(String[] args) {
        NpeSolution2 app = new NpeSolution2();
        try {
            app.processOrder(null);
        } catch (NullPointerException e) {
            System.err.println("NPE caught: " + e.getMessage());
        }
    }
}

class Order {
    private String orderId = "ABC123";
    public String getOrderId() { return orderId; }
}

import java.util.Optional;

public class NpeSolution3 {
    static class User {
        Address address;
        public Optional<Address> getAddress() {
            return Optional.ofNullable(address); // 返回 Optional
        }
    }

    static class Address {
        String street;
        public Optional<String> getStreet() {
            return Optional.ofNullable(street); // 返回 Optional
        }
    }

    public static void main(String[] args) {
        User user1 = new User(); // address 为 null

        // 传统方式处理链式调用，易NPE
        // if (user1 != null && user1.getAddress() != null && user1.getAddress().getStreet() != null) {
        //     System.out.println(user1.getAddress().getStreet());
        // }

        // 使用 Optional 优雅处理链式调用
        String streetName = user1.getAddress() // Optional<Address>
                                 .flatMap(Address::getStreet) // Optional<String>
                                 .orElse("Unknown Street"); // 如果最终为空，提供默认值

        System.out.println("Street Name (user1): " + streetName); // 输出: Unknown Street

        // 另一个场景：有值的情况
        User user2 = new User();
        user2.address = new Address();
        user2.address.street = "Java Road";

        String streetName2 = user2.getAddress()
                                  .flatMap(Address::getStreet)
                                  .orElse("Unknown Street");
        System.out.println("Street Name (user2): " + streetName2); // 输出: Java Road

        // Optional 还可以用于执行某些操作（如果存在值）
        Optional.ofNullable("Hello World").ifPresent(s -> System.out.println("Value exists: " + s));
        Optional.ofNullable(null).ifPresent(s -> System.out.println("This won't print"));
    }
}

import java.util.Collections;
import java.util.List;
import java.util.ArrayList;

public class NpeSolution4 {
    public List<String> getActiveUsers(boolean hasActiveUsers) {
        if (hasActiveUsers) {
            List<String> users = new ArrayList<>();
            users.add("Alice");
            users.add("Bob");
            return users;
        } else {
            // 不要返回 null，而是返回一个空的、不可修改的List
            return Collections.emptyList();
        }
    }

    public static void main(String[] args) {
        NpeSolution4 service = new NpeSolution4();
        List<String> users = service.getActiveUsers(false);
        // 调用者无需检查 users 是否为 null，直接安全地进行迭代
        System.out.println("Number of active users: " + users.size()); // 0
        for (String user : users) {
            System.out.println(user); // 不会执行，也不会NPE
        }

        List<String> activeUsers = service.getActiveUsers(true);
        System.out.println("Number of active users: " + activeUsers.size()); // 2
    }
}

public class NpeSolution5 {
    public static void main(String[] args) {
        // 场景一：确定不会为null时使用基本类型
        int count = 0; // 而不是 Integer count = 0;
        System.out.println("Initial count: " + count);

        // 场景二：如果必须使用包装类型，在拆箱前务必检查null
        Integer nullableValue = null;
        int safeValue;
        if (nullableValue != null) {
            safeValue = nullableValue;
            System.out.println("Safe value: " + safeValue);
        } else {
            System.out.println("nullableValue was null, cannot convert to primitive.");
        }
    }
}

public class NpeSolution6 {
    // 启用断言: 运行Java程序时添加 -ea 或 -enableassertions 参数
    public void processData(String data) {
        assert data != null : "Data input cannot be null!"; // 如果 data 为 null 则抛 AssertionError
        System.out.println("Processing data: " + data.trim());
    }

    public static void main(String[] args) {
        NpeSolution6 app = new NpeSolution6();
        try {
            app.processData("  Hello  ");
            app.processData(null); // 如果启用断言，这里会抛 AssertionError
        } catch (AssertionError e) {
            System.err.println("Assertion Error: " + e.getMessage());
        }
    }
}

// 假设你有一个UserService
public class UserService {
    public String getUserEmail(User user) {
        // 假设这里在某些情况下 user.getEmail() 会返回 null
        // 例如，如果 User 对象本身是 null，或者 email 字段是 null
        if (user == null) {
            return null; // 或者抛出 IllegalArgumentException
        }
        return user.getEmail();
    }
}

// 对应的 JUnit 5 单元测试
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

class UserServiceTest {

    private UserService userService = new UserService();

    @Test
    void getUserEmail_whenUserIsNull_shouldReturnNull() {
        assertNull(userService.getUserEmail(null)); // 测试传入null用户时是否返回null
    }

    @Test
    void getUserEmail_whenEmailIsNull_shouldReturnNull() {
        User userWithNullEmail = new User(); // 假设User类构造函数或set方法不强制email非空
        userWithNullEmail.setEmail(null);
        assertNull(userService.getUserEmail(userWithNullEmail)); // 测试Email字段为null的情况
    }

    @Test
    void getUserEmail_whenUserAndEmailAreValid_shouldReturnEmail() {
        User validUser = new User();
        validUser.setEmail("test@example.com");
        assertEquals("test@example.com", userService.getUserEmail(validUser));
    }
}

// 模拟 User 类
class User {
    private String email;
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}