0Pricing
Java Academy · 课时

基本类型与引用类型

理解 Java 中基本类型与引用类型之间的根本区别

基本类型与引用类型 是 CoddyKit 上的免费 Java Academy 课时。 这是第 1 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 Java Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 Java Academy 课程共包含 4 节课。

基本类型与引用类型

Java 有两大基本数据类型类别：基本类型和引用类型。理解两者的区别对于编写正确且高效的 Java 代码至关重要。

八种基本类型

Java 恰好有八种基本类型：

  • byte（8 位整数）
  • short（16 位整数）
  • int（32 位整数）
  • long（64 位整数）
  • float（32 位小数）
  • double（64 位小数）
  • char（16 位 Unicode 字符）
  • boolean（真/假）

基本类型直接在内存中保存值，不产生对象开销。

int age = 25;
double price = 19.99;
boolean active = true;
char grade = 'A';
long population = 8_000_000_000L;

System.out.println(age);       // 25
System.out.println(price);     // 19.99
System.out.println(active);    // true

引用类型

引用类型存储一个指向堆中对象的内存地址（引用）。它包括：

  • 类（例如 String、Scanner）
  • 数组（例如 int[]）
  • 接口
  • 枚举和记录

变量并不保存对象本身，而是保存指向对象的指针。

String name = "Alice";       // reference to a String object
int[] scores = {90, 85, 92}; // reference to an array object

// name holds a reference, not the characters directly
System.out.println(name.length());   // 5
System.out.println(scores.length);   // 3

栈内存与堆内存

基本类型变量存储在栈上。栈是速度快、生命周期短，并与方法调用相关联的内存。

引用类型对象存储在堆上。堆是容量更大、生命周期更长，并由垃圾回收机制管理的内存。引用（地址）本身存储在栈上。

// Stack: holds the int value directly
int x = 42;

// Stack: holds reference; Heap: holds the Person object
class Person {
    String name;
    int age;
}

Person p = new Person(); // p is a reference on stack, object on heap
p.name = "Bob";
p.age = 30;

null：不存在的引用

引用变量可以被赋值为 null，表示它不指向任何对象。基本类型不能为 null，它们始终有值。

访问 null 引用会导致 NullPointerException（NPE），这是 Java 中最常见的运行时错误之一。

String s = null;
// int n = null; // Compile error — primitives can't be null

try {
    System.out.println(s.length()); // NullPointerException!
} catch (NullPointerException e) {
    System.out.println("Caught NPE: reference was null");
}

复制语义：基本类型

将一个基本类型变量赋值给另一个变量时，Java 会复制值。修改其中一个变量不会影响另一个变量；两者完全独立。

int a = 10;
int b = a;  // b gets a copy of the value 10

b = 20;     // changing b does NOT affect a

System.out.println(a); // 10
System.out.println(b); // 20

复制语义：引用类型

将一个引用变量赋值给另一个变量时，两个变量都指向同一个对象。通过其中一个引用修改对象后，可以通过另一个引用看到修改结果。

int[] arr1 = {1, 2, 3};
int[] arr2 = arr1; // arr2 points to the SAME array

arr2[0] = 99; // modifies the shared array

System.out.println(arr1[0]); // 99 — arr1 sees the change too!
System.out.println(arr2[0]); // 99

包装类：封装基本类型

每种基本类型在 java.lang 中都有对应的包装类：

  • int → Integer
  • double → Double
  • boolean → Boolean
  • char → Character

包装类让您可以将基本类型作为对象使用，这是 List<Integer> 等集合所要求的。

Integer boxed = Integer.valueOf(42); // explicit boxing
int unboxed = boxed.intValue();       // explicit unboxing

// Autoboxing / auto-unboxing (Java does this automatically)
Integer auto = 100;  // autoboxed
int val = auto;      // auto-unboxed

System.out.println(Integer.MAX_VALUE);  // 2147483647
System.out.println(Double.MIN_VALUE);   // 5.0E-324

自动装箱的陷阱

自动装箱虽然方便，但可能导致不易察觉的错误。Integer 会缓存 -128 到 127 范围内的值；超出该范围时，== 比较的是引用，而不是值。

比较包装类对象时，请始终使用 .equals()。

Integer a = 127;
Integer b = 127;
System.out.println(a == b);      // true (cached)

Integer c = 200;
Integer d = 200;
System.out.println(c == d);      // false (different objects!)
System.out.println(c.equals(d)); // true (correct comparison)

传递给方法：值传递

Java 始终采用值传递。对于基本类型，传递的是值的副本；对于引用类型，传递的是引用（地址）的副本。两个引用仍然指向同一个对象，但您无法在方法内部重新赋值调用方的变量。

static void doubleValue(int n) {
    n = n * 2; // only modifies the local copy
}

static void clearArray(int[] arr) {
    arr[0] = 0; // modifies the shared object
}

int x = 5;
doubleValue(x);
System.out.println(x); // still 5

int[] nums = {10, 20, 30};
clearArray(nums);
System.out.println(nums[0]); // 0 — object was mutated

实用对照表

以下是基本类型与引用类型的快速对照：

  • 存储：基本类型 → 栈上的值；引用类型 → 栈上的地址 + 堆中的对象
  • 默认值：基本类型 → 0/false/\u0000；引用类型 → null
  • 可以为 null：基本类型 → 否；引用类型 → 是
  • 赋值复制：基本类型 → 值；引用类型 → 地址
  • 在集合中：基本类型需要使用包装类

快速检查

执行以下代码会发生什么？

Integer x = 200;
Integer y = 200;
System.out.println(x == y);

回顾：基本类型与引用类型

本课的要点：

  • Java 有 8 种直接存储在栈上的基本类型
  • 引用类型存储堆中对象的地址；变量保存该地址
  • 基本类型按值复制；引用类型按地址复制
  • 引用变量可以为 null；基本类型不能为 null
  • 包装类（Integer、Double 等）将基本类型封装为对象
  • Java 始终采用值传递，即使传递的是引用也是如此

常见问题解答

「基本类型与引用类型」课时是免费的吗？

是的 — 「基本类型与引用类型」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 Java Academy 课程的其余内容，请升级到 CoddyKit PRO。 Java Academy 课程共包含 4 节课。

「基本类型与引用类型」这节课中我会学到什么？

理解 Java 中基本类型与引用类型之间的根本区别 你通过在浏览器中直接运行的动手代码来练习 Java Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。

学习 Java Academy 需要有经验吗？

无需任何先前经验。CoddyKit 上的 Java Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 1 节课，共 4 节。

「基本类型与引用类型」课时需要多长时间？

大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。

我能在这节 Java Academy 课中编写并运行代码吗？

能。每节 Java Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。

此课程中的所有课时

  1. 基本类型与引用类型
  2. 扩大转换与缩小转换
  3. instanceof 运算符
  4. 实际应用中的类型转换
← 返回 Java Academy