Java - NullPointerException 与变量未初始化

在 Java 中，变量的声明（定义） 和初始化是两个核心概念，理解它们的区别和规则，是避免空指针异常（NullPointerException ）的关键。尤其是引用类型变量（如TreeNode、String等），如果初始化不当，极易出现空指针错误。下面系统讲解相关知识：

一、先明确：变量的“声明”与“初始化”是什么？

1. 变量声明（定义）

指告诉编译器“有一个变量存在”，包括变量的类型和名称。
声明的目的是：让编译器知道这个变量的“类型”（占据多大内存空间）和“名字”（如何在代码中引用它）。
示例：

int a; // 声明一个 int 类型的变量 a
TreeNode node; // 声明一个 TreeNode 类型的变量 node（引用类型）
String str; // 声明一个 String 类型的变量 str（引用类型）

此时变量仅被“定义”，但没有具体的值（或处于“未初始化”状态）。

2. 变量初始化

指给已声明的变量赋予“具体的值”，让变量从“未可用”状态变为“可用”状态。
初始化的本质是：给变量分配内存空间并写入初始值。
示例：

int a = 10; // 声明并初始化 int 变量 a（基本类型）
TreeNode node = new TreeNode(5); // 声明并初始化 TreeNode 变量（引用类型，指向一个实际对象）
String str = "hello"; // 声明并初始化 String 变量（引用类型，指向字符串对象）

二、关键区别：基本类型 vs 引用类型

Java 变量分为基本数据类型和引用数据类型，它们的初始化规则和默认值完全不同，这是理解空指针的核心。

类型	包含的类型	初始化核心特点
基本数据类型	`int`、`boolean`、`char`、`double`等 8 种	初始化后直接存储“值”本身；未显式初始化时，有默认值（如`int`默认 0，`boolean`默认 false）。
引用数据类型	类（`TreeNode`）、接口、数组、`String`等	初始化后存储“对象的地址”（即“引用”）；未显式初始化时，默认值为`null`（表示“不指向任何对象”）。

三、不同场景下的变量初始化规则

变量的初始化规则与它的“作用域”（在哪里声明）密切相关，主要分为局部变量和成员变量（包括实例变量和静态变量）。

1. 局部变量（方法内、代码块内声明的变量）

定义：在方法体、for 循环、if 块等局部作用域中声明的变量。
初始化规则：必须显式初始化后才能使用，否则编译报错。
（原因：局部变量是“临时变量”，Java 编译器不提供默认值，强制开发者手动初始化，避免使用垃圾值。）

错误示例（编译不通过）：

public void test() {
    int a; 
    System.out.println(a); // 编译错误：变量 a 可能未初始化
    
    TreeNode node;
    node.val = 5; // 编译错误：变量 node 可能未初始化（即使通过编译，运行时也会空指针）
}

正确示例：

public void test() {
    int a = 0; // 显式初始化
    System.out.println(a); // 正确
    
    TreeNode node = new TreeNode(5); // 显式初始化（创建实际对象）
    node.val = 10; // 正确（node 指向实际对象，可访问 val）
}

2. 成员变量（类中声明的变量）

在类中声明的变量，分为实例变量（非 static）和静态变量（static），Java 会自动赋予默认值，无需显式初始化即可使用。

（1）实例变量（非 static 成员变量）

定义：类中声明，不带 static关键字，属于对象的属性。
默认初始化规则：
- 基本类型：按类型赋予默认值（如 int→0，boolean→false）；
- 引用类型：默认值为null（不指向任何对象）。

示例：

class MyClass {
    int a; // 实例变量，默认值 0
    boolean b; // 实例变量，默认值 false
    TreeNode node; // 实例变量，默认值 null（引用类型）
}

public class Test {
    public static void main(String[] args) {
        MyClass obj = new MyClass();
        System.out.println(obj.a); // 输出 0（默认值）
        System.out.println(obj.node); // 输出 null（默认值）
    }
}

（2）静态变量（static 成员变量）

定义：类中声明，带 static关键字，属于类本身，所有对象共享。
默认初始化规则：与实例变量相同（基本类型有默认值，引用类型默认 null），但初始化时机更早（类加载时）。

示例：

class MyClass {
    static int a; // 静态变量，默认值 0
    static TreeNode node; // 静态变量，默认值 null
}

public class Test {
    public static void main(String[] args) {
        System.out.println(MyClass.a); // 输出 0（无需创建对象即可访问）
        System.out.println(MyClass.node); // 输出 null
    }
}

四、空指针异常（`NullPointerException`）的根源

空指针异常只发生在引用类型变量上，本质是：当变量的值为null时，试图访问它的属性或调用它的方法。

常见场景（结合`TreeNode`举例）：

访问null对象的属性

TreeNode node = null; // 引用类型变量未指向任何对象（值为 null）
int val = node.val; // 空指针异常！node 是 null，没有 val 属性

调用 null对象的方法

TreeNode node = null;
node.left = new TreeNode(5); // 空指针异常！node 是 null，无法调用 left 属性（本质是访问属性）

局部变量未初始化（默认隐含 null）

public void test() {
    TreeNode node; // 局部变量，未初始化（编译时允许，但实际值为 null）
    node.val = 5; // 运行时空指针异常（node 是 null）
}

成员变量默认 null，未显式初始化

class MyClass {
    TreeNode node; // 实例变量，默认 null
}

public void test() {
    MyClass obj = new MyClass();
    obj.node.val = 5; // 空指针异常！obj.node 是 null
}

五、如何避免空指针异常？

核心原则：使用引用类型变量前，确保它指向一个实际的对象（即不为 null）。具体方法：

显式初始化引用类型变量
声明时或使用前，通过 new关键字创建对象，或指向一个已存在的对象：

TreeNode node = new TreeNode(5); // 显式创建对象，node 指向实际节点
TreeNode anotherNode = node; // 指向已存在的对象（非 null）

使用前检查是否为 null
不确定变量是否为 null时，用 if判断：

public void test(TreeNode node) {
    if(node!= null) { // 先检查，再使用
        node.val = 10; 
        System.out.println(node.left);
    } else {
        // 处理 null 的情况（如创建新对象或返回）
        node = new TreeNode(0);
    }
}

理解方法返回值可能为 null
调用方法时，若返回值是引用类型，需考虑返回 null的可能性：

TreeNode findNode() {
    return null; // 方法可能返回 null
}

public void test() {
    TreeNode node = findNode();
    if(node!= null) { // 必须检查，否则可能空指针
        node.val = 5;
    }
}

注意数组中的引用类型元素
数组初始化时，引用类型元素默认值为 null，需逐个初始化：

TreeNode[] nodes = new TreeNode[3]; // 数组长度 3，但每个元素都是 null
nodes[0] = new TreeNode(1); // 显式初始化第一个元素
nodes[0].val = 10; // 正确（已初始化）
nodes[1].val = 20; // 空指针异常（nodes[1]是 null）

六、总结

声明 vs 初始化：
- 声明是“告诉编译器有这个变量”；
- 初始化是“给变量赋值”，引用类型必须指向实际对象才可用。
核心区别：
- 基本类型：未显式初始化时，局部变量编译报错，成员变量有默认值；
- 引用类型：未显式初始化时，局部变量隐含 null（使用时报错），成员变量默认 null（使用时可能空指针）。
空指针根源：
引用类型变量的值为 null时，访问其属性或方法。
避免方法：
显式初始化引用变量，使用前检查 null，处理方法返回 null的情况。

结合你之前写的二叉树代码（如 TreeNode操作），只要记住：每次用 node.val、node.left之前，确保node不是 null，就能大幅减少空指针错误。