正文

从程序员凌晨三点修bug吐槽变量名写反空指针报错数组越界闪退说起这些常见编程易错点用大白话讲解新手老手都能看懂

/0 浏览量
0903

从程序员凌晨三点修bug吐槽变量名写反空指针报错数组越界闪退说起这些常见编程易错点用大白话讲解新手老手都能看懂

凌晨三点，办公室的灯还亮着那一盏。你盯着屏幕上那行”NullPointerException”已经看了四十分钟，眼睛干得跟沙漠似的，脑子里只剩一个念头：这变量名到底谁写的？

然后你发现，是你自己写的。而且你把userName赋值给了userAge。

别笑，这事儿太常见了。今天咱们就聊聊这些让程序员头发掉光的坑，用大白话讲清楚，顺便让老手也能笑一笑，找回当初写代码的那种”简单快乐”。

一、变量名写反：你的名字被我叫成了我的名字

先说最经典的那个——变量名写反了。

这事儿听起来低级，但实际上坑死过无数人。包括那些写了十几年代码的老程序员。

想象一下这个场景：

User user = new User();
user.setUserName("张三");
user.setUserAge("李四"); // 等等，年龄怎么是名字？

你运行程序，一切正常，没报错。然后用户问：”我今年叫李四？”

你懵了。

再比如这个，更隐蔽：

let isLogin = false;
let isLoggedIn = true;

// 某处代码判断登录状态
if (isLogin) {
    // 你以为判断的是"已登录"，但实际上判断的是"登录状态变量"
    // 两个变量名长得太像了，眼睛一花就搞混
    console.log("欢迎回来！");
}

这种问题为什么防不胜防？因为人脑对相似的东西会自动脑补。当你快速扫代码的时候，userName和userAge在你眼里就是同一类东西，大脑自动把它们归类为”用户信息”，然后手就开始自动乱写了。

怎么避免？

第一个办法：起名字的时候多花五秒钟

别管什么”简洁”了，你的变量名越清楚越好：

// 别这样写
u.setName("张三");
u.setAge("李四");

// 这样写
userModel.setDisplayName("张三");
userModel.setAccountAge("李四");

第二个办法：写完代码之后自己读一遍

不是用眼睛扫，是用嘴巴念出来。念一念，你可能会说：”哎？这个用户叫什么名字？哦，叫李四？不对啊，他叫张三啊！”

这个办法特别管用，比任何代码审查都有效。

第三个办法：写单元测试

这是终极方案。你写一个简单的测试：

@Test
public void testUserCreation() {
    User user = new User();
    user.setUserName("张三");
    user.setUserAge("18");
    
    assertEquals("张三", user.getUserName());
    assertEquals("18", user.getUserAge());
    
    // 如果你写反了，这个测试直接失败
    // 凌晨三点再也不用盯着空指针发愁了
}

测试跑不过，你就知道有bug。测试跑过了，你就可以安心睡觉。

二、空指针报错：你访问了一个不存在的东西

“NullPointerException”——Java程序员最怕看到的那行字。

用大白话来说，空指针就是你在和一个不存在的东西说话。

想象你去办公室找张三，但是张三根本没来。你跟空气说：”张三，这个文件怎么办？”空气不会回答你，你站在那里对着空气说话，最后大家都尴尬。

在代码里，这个”空气”就是一个值为null的对象。

String userName = null;

// 你试图访问这个null的值
System.out.println(userName.length()); // 崩了！

你问null有多长，null根本不存在，你怎么能问它有多长呢？程序不知道该怎么回答，就直接崩溃给你看。

为什么null这么烦人？

因为你可能根本不知道哪里返回了null。

比如这个例子：

public class UserService {
    
    public User findById(int id) {
        // 假设这个方法去数据库查用户
        // 如果找不到，返回null
        User user = database.query("SELECT * FROM users WHERE id = ?", id);
        return user; // 可能返回null！
    }
}

// 使用这个方法的人
User user = userService.findById(999); // 999号用户不存在，返回null

// 然后下面这段代码直接崩了
System.out.println(user.getName()); // NullPointerException！

你调用findById的时候，代码没报错，一切正常。结果跑到下面getName()才崩了。你追bug的时候根本不知道null是从哪儿来的。

怎么避免？

办法一：用现代语言特性，或者库来处理

如果你用Java 8+，可以用Optional：

public Optional<User> findById(int id) {
    User user = database.query("SELECT * FROM users WHERE id = ?", id);
    return Optional.ofNullable(user);
}

// 使用的时候
Optional<User> userOpt = userService.findById(999);
userOpt.ifPresent(user -> System.out.println(user.getName()));
// 用户不存在，直接跳过，不会崩

如果你用Kotlin，根本不会有这个问题，因为Kotlin的类型系统就杜绝了null：

// 这个变量不能是null
val userName: String = "张三"

// 如果可能是null，必须这样写
val userName: String? = null

// 使用的时候必须处理null的情况
userName?.length ?: 0

办法二：每个方法调用前都检查一下

这是最朴素但最靠谱的办法：

if (user != null) {
    System.out.println(user.getName());
} else {
    System.out.println("用户不存在");
}

虽然啰嗦，但是安全。尤其是新手，别嫌麻烦，先保证程序不崩。

办法三：用注解告诉编译器

Java有@Nullable和@NonNull注解，很多IDE（比如IntelliJ IDEA）能识别它们：

@Nullable
public User findById(int id) {
    // 标注了这个方法可能返回null
    // IDE会提醒你：返回值可能是null，记得检查！
}

IDE会给你标黄、标红，提醒你这里可能有坑。比你自己翻代码找bug强多了。

三、数组越界：你伸手去拿不存在的抽屉里的东西

数组越界，就像你去餐厅点菜，菜单上只有10道菜，你点了第11道。服务员懵了，厨房也懵了，最后只能跟你说：”抱歉，我们没有这道菜。”

在编程里，数组越界就是你访问了一个不存在的下标。

int[] scores = new int[5]; // 只能放5个数，下标是0-4

scores[0] = 90;   // 没问题
scores[4] = 100;  // 没问题，最后一个
scores[5] = 85;   // 崩了！下标5不存在！

很多新手会疑惑：数组不是从1开始数的吗？为什么是0到4？

这就好比你问：”一层楼不是一楼吗，为什么叫0楼？”——这是计算机世界的规则，从0开始计数。所以长度为5的数组，下标就是0、1、2、3、4。

为什么数组越界特别烦人？

因为有时候它不崩，有时候崩。

int[] scores = new int[5];

// 在开发环境，运行正常
// 但是到了生产环境，数据多了，某处调用了scores[5]
// 突然就崩了

// 更可怕的是：
for (int i = 0; i <= scores.length; i++) {
    System.out.println(scores[i]); // 最后一轮i=5，越界！
}

注意那个<=，应该是<才对。这个错误太常见了，常见到每个程序员都犯过。

怎么避免？

办法一：用foreach循环

这是最简单也最有效的办法：

int[] scores = {90, 85, 78, 92, 88};

// 安全！不会越界
for (int score : scores) {
    System.out.println(score);
}

foreach循环让你不用操心下标，系统会自动遍历每一个元素。

办法二：永远用<而不是<=

记住这个口诀：数组长度是几，循环就到几，永远小于不取等。

for (int i = 0; i < scores.length; i++) { // 对！
for (int i = 0; i <= scores.length; i++) { // 错！最后一个会越界

办法三：用List代替数组

如果你不确定数据有多少，用ArrayList：

List<Integer> scores = new ArrayList<>();
scores.add(90);
scores.add(85);
scores.add(78);

// 这样你不用担心下标问题
for (int score : scores) {
    System.out.println(score);
}

四、这些坑的共性：你犯的错，前人都犯过

说了这么多，你有没有发现一个规律？这些错误都不是因为你不聪明，而是因为你太自信了。

你以为变量名写对了，其实写反了。 你以为对象不为null，其实它是null。 你以为循环不会越界，其实你少写了一个”<“。

程序不会骗你，但你的眼睛会骗你。

一个老程序员的经验

我认识的一个写了十五年代码的老哥，有一次在代码审查的时候指出了一个问题：

if (condition == true) {
    // 做点什么
}

他问写这段代码的新手：”为什么要写== true？”

新手说：”这样看起来更明确啊，我是判断condition是否等于true。”

老哥笑了笑，说：“你写了十五年代码，见过最蠢的bug是什么？”

新手想了很久，说：”不知道。”

老哥说：“最常见的bug，就是你自己写的。因为你太相信自己了，所以没检查。”

五、给新手的具体建议：让bug少一点，头发多一点

好了，说了这么多，给新手几个实用的建议：

1. 起名字要认真

别用a、b、temp这种名字。除非你真的只是写个临时变量。

// 不好
int a = 10;
int b = 20;
int temp = a;
a = b;
b = temp;

// 好
int firstNumber = 10;
int secondNumber = 20;
int swapTemp = firstNumber;
firstNumber = secondNumber;
secondNumber = swapTemp;

2. 写完代码先跑一遍测试

别等用户发现问题。自己先跑一遍，特别是边界情况：数组为空怎么办？用户不存在怎么办？网络断了怎么办？

3. 学会看报错信息

报错不是敌人，报错是程序在帮你。它告诉你问题在哪儿，你照着找就行。

java.lang.NullPointerException: Cannot invoke "String.length()" because "userName" is null
    at com.example.UserService.greet(UserService.java:15)

看到了吗？第15行，userName是null。直接在IDE里跳到那一行，问题就清楚了。

4. 别怕写注释

不是让你每行都写注释，而是在容易出错的地方写。

// 注意：这里传入的userId不能为null，否则会抛NullPointerException
public User getUserById(Integer userId) {
    if (userId == null) {
        throw new IllegalArgumentException("userId不能为null");
    }
    return database.findById(userId);
}

5. 学会用工具

IDE的自动提示、代码检查、静态分析工具——这些都是你的盟友。别嫌它们啰嗦，它们帮你挡住了很多坑。

六、写到最后

说了这么多，其实就想告诉你一件事：

编程就是跟自己的粗心较劲。

那些凌晨三点修bug的时刻，那些对着屏幕发呆的尴尬，那些”我怎么又犯了这个错误”的叹息——这些是每个程序员都经历过的。

新手会犯这些错，老手也会犯。区别只是老手写代码更快、改bug更快、以及头发更少。

别害怕犯错，可怕的是不犯错但也不思考。每一次踩坑，都是成长的机会。把今天说的这些记住，下次遇到类似的问题，你就能笑着说：”哦，这个我见过。”

好了，现在去睡觉吧。明天又是新的一天，新的bug在等着你——但这一次，你已经准备好了。

-- 展开阅读全文 --