数组是数据的容器，类是对象的蓝图，成员变量是对象的状态。本文带你彻底理清这三者的核心概念、内存模型和实战陷阱。
一、Java数组：存储同类型数据的利器
1. 数组的声明与初始化
// 声明（推荐方式）
int[] arr1; // 首选
int arr2[]; // 也合法，但不推荐
// 动态初始化（指定长度，默认值）
int[] arr3 = new int[5]; // 每个元素默认为0
String[] arr4 = new String[3]; // 默认null
// 静态初始化（直接赋值）
int[] arr5 = {1, 2, 3, 4};
int[] arr6 = new int[]{10, 20, 30}; // 显式写法
2. 数组的内存模型（重要！）
· 数组变量存储在栈中，指向堆内存中的数组对象。
· 数组对象存储在堆中，包含长度和所有元素。
· 基本类型数组：元素值直接存储在堆中。
· 引用类型数组：元素存储的是对象的引用（地址）。
int[] a = new int[3]; // a在栈，数组对象在堆，元素默认0
String[] s = new String[2]; // s在栈，数组对象在堆，元素默认null
3. 数组的遍历
// 普通for
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
// 增强for（foreach）
for (int num : arr) {
System.out.println(num);
}
// 使用Arrays工具类
import java.util.Arrays;
System.out.println(Arrays.toString(arr)); // 打印数组内容
4. 多维数组（以二维为例）
// 声明与初始化
int[][] matrix = new int[3][4]; // 3行4列，默认0
int[][] matrix2 = {{1,2},{3,4,5},{6}}; // 不规则数组（每行长度可变）
// 遍历
for (int i = 0; i < matrix2.length; i++) {
for (int j = 0; j < matrix2[i].length; j++) {
System.out.print(matrix2[i][j] + " ");
}
System.out.println();
}
5. 常见陷阱 ⚠️
错误操作 后果 正确做法
int[] arr = new int[-1]; 运行时异常 NegativeArraySizeException 长度必须非负
访问 arr[arr.length] 数组越界 IndexOutOfBoundsException 最大索引为 length-1
未初始化直接使用 编译报错（局部变量）或空指针 先 new 或赋值
二维数组未初始化内层 NullPointerException 每行都要 new 或直接赋值
---
二、类（Class）：对象的模具
1. 类的定义
// 一个简单的学生类
public class Student {
// 成员变量（属性）
String name;
int age;
String studentId;
// 构造方法（无参）
public Student() {
}
// 有参构造
public Student(String name, int age, String studentId) {
this.name = name;
this.age = age;
this.studentId = studentId;
}
// 成员方法（行为）
public void study() {
System.out.println(name + " 正在学习...");
}
public void showInfo() {
System.out.println("学号：" + studentId + "，姓名：" + name + "，年龄：" + age);
}
}
2. 对象的创建与使用
// 使用无参构造
Student s1 = new Student();
s1.name = "张三";
s1.age = 20;
s1.studentId = "2024001";
// 使用有参构造
Student s2 = new Student("李四", 22, "2024002");
s1.study(); // 输出：张三 正在学习...
s2.showInfo(); // 输出学号、姓名、年龄
```
3. 构造方法要点
· 构造方法名必须与类名相同，无返回值（连void都不能有）。
· 若未定义任何构造方法，编译器会提供默认无参构造。
· 若定义了有参构造，默认无参构造将不再提供，建议显式写出无参构造。
· 构造方法可以重载（多个参数列表不同的构造）。
---
三、成员变量（字段/属性）
1. 实例变量 vs 类变量（静态变量）
类型 关键字 归属 存储位置 访问方式 生命周期
实例变量 无static 每个对象独立 堆内存（对象内） 对象引用.变量名 随对象创建而存在，回收而消亡
类变量 static 类本身，所有对象共享 方法区（JDK8后元空间） 类名.变量名（或对象.但不推荐） 随类加载而初始化，类卸载才消亡
class Person {
String name; // 实例变量
static String species = "人类"; // 类变量（静态）
}
public class Test {
public static void main(String[] args) {
Person p1 = new Person();
p1.name = "小明";
Person p2 = new Person();
p2.name = "小红";
System.out.println(p1.name); // 小明
System.out.println(Person.species); // 人类（推荐类名访问）
System.out.println(p1.species); // 人类（不推荐，但合法）
}
}
2. 访问修饰符与封装
修饰符 同类 同包 子类（不同包） 任意位置
private ✅ ❌ ❌ ❌
默认（无） ✅ ✅ ❌ ❌
protected ✅ ✅ ✅ ❌
public ✅ ✅ ✅ ✅
最佳实践：成员变量通常设为 private，通过 getter/setter 对外暴露，以实现封装。
public class Student {
private String name;
private int age;
public String getName() { return name; }
public void setName(String name) { this.name = name; }
public int getAge() { return age; }
public void setAge(int age) {
if (age >= 0 && age <= 150) {
this.age = age;
} else {
System.out.println("年龄不合法");
}
}
}
3. 成员变量的初始化顺序
· 类变量（static）：在类加载时按声明顺序初始化（先静态代码块，后静态变量，但按顺序执行）。
· 实例变量：在创建对象时，先执行默认初始化（赋零值/null），再执行显式赋值或构造方法。
· 完整顺序（同一个类）：
① 静态变量/静态代码块（按源文件顺序） → ② 实例变量/实例代码块（按顺序） → ③ 构造方法
class InitOrder {
static int a = 10; // 1. 静态变量
static { a = 20; } // 2. 静态代码块（覆盖为20）
int b = 5; // 3. 实例变量
{ b = 15; } // 4. 实例代码块（覆盖为15）
public InitOrder() { // 5. 构造方法
b = 25;
}
}
// 最终 a=20, b=25
4. final 成员变量
· final 修饰的成员变量必须在构造方法结束前完成赋值（显式赋值或构造中赋值）。
· 静态 final 变量必须在静态代码块或声明时赋值。
· 一旦赋值，不可修改，通常用作常量（如 public static final double PI = 3.14159;）。
---
四、综合实战：图书管理系统简单建模
public class Book {
private String title;
private String author;
private double price;
private static int totalBooks = 0; // 统计图书总数
public Book(String title, String author, double price) {
this.title = title;
this.author = author;
this.price = price;
totalBooks++;
}
public void display() {
System.out.printf("《%s》 作者：%s 价格：%.2f\n", title, author, price);
}
public static int getTotalBooks() {
return totalBooks;
}
public static void main(String[] args) {
Book[] library = new Book[3];
library[0] = new Book("Java核心技术", "Cay Horstmann", 129.0);
library[1] = new Book("Effective Java", "Joshua Bloch", 99.0);
library[2] = new Book("深入理解Java虚拟机", "周志明", 149.0);
for (Book b : library) {
b.display();
}
System.out.println("总图书数：" + Book.getTotalBooks()); // 输出3
}
}
五、最常见的 5 个错误与建议
1. 数组越界：使用 <= 而非 < 导致访问 arr[length]。
✅ 解决：循环条件统一用 i < arr.length。
2. 空指针异常：引用变量未初始化或指向 null 却调用方法/访问成员。
✅ 解决：使用前检查 if (obj != null)。
3. 将数组当成方法参数时，方法内修改数组会影响原数组（因为传递的是引用）。
✅ 注意：若想避免修改，可复制数组或使用不可变集合。
4. 静态成员访问实例成员：静态方法不能直接访问非静态成员，需要先创建对象。
✅ 理解：静态属于类，实例属于对象，类加载时实例尚不存在。
5. 类变量与实例变量命名冲突：局部变量、成员变量、静态变量同名时，就近原则。
✅ 建议：使用 this 区分实例变量，使用 类名. 区分静态变量。
---
六、总结（思维导图）
Java核心基础
├── 数组
│ ├── 一维：声明（int[] arr）、初始化（new / {}）
│ ├── 多维：不规则数组、遍历
│ ├── 内存：栈引用 + 堆对象
│ └── 工具：Arrays.toString() / sort()
├── 类
│ ├── 定义：class 关键字
│ ├── 构造方法：重载，默认构造
│ ├── 对象创建：new
│ └── 方法：成员行为
└── 成员变量
├── 分类：实例变量（非static） vs 类变量（static）
├── 修饰符：private（封装） / public / protected
├── 初始化顺序：静态→实例→构造
└── final：常量，不可变
数组是容器，类是模板，成员变量是属性。三者配合，构成了Java面向对象编程的基石。熟练运用它们，你就能构建出结构清晰、可维护性强的程序。下一期我们将深入探讨继承与多态，敬请期待！
如果觉得这篇笔记对你有帮助，请点赞、收藏、评论三连！
