Java类型概览

Java 的类型系统（Type System） 是其语言设计的核心，它决定了变量如何声明、赋值、传递、转换，以及编译器和运行时如何保证类型安全。下面从多个维度系统性地为你梳理 Java 类型系统的全貌。

---

一、Java 类型系统的本质特征

Java 是一种 静态、强类型、面向对象、支持泛型和类型擦除 的编程语言。

特性	说明
静态类型（Static Typing）	变量类型在编译时确定，编译器做类型检查。
强类型（Strong Typing）	类型不兼容会编译报错。
面向对象类型系统	所有类形成继承树，支持多态、向上/向下转型。
支持泛型（Generics）	编译期提供类型安全容器（如 List），运行时类型擦除。
类型擦除（Type Erasure）	泛型信息在运行时被擦除，仅用于编译期检查。

---

二、Java 类型分类总览

Java 类型分为两大类：

基本类型（Primitive Types）

共 8 种，值不是对象：

类型	大小	默认值	包装类
boolean	未明确规定（通常 1 bit）	false	Boolean
byte	1 字节	0	Byte
short	2 字节	0	Short
int	4 字节	0	Integer
long	8 字节	0L	Long
float	4 字节	0.0f	Float
double	8 字节	0.0d	Double
char	2 字节（UTF-16）	'\u0000'	Character

💡 基本类型没有继承关系。

---

引用类型（Reference Types）

所有"对象"的类型，变量存储的是引用（指针）：

① 类（Class）

String s = new String("abc");

② 接口（Interface）

List<String> list = new ArrayList<>();

③ 数组（Array）

int[] arr = new int[10];
String[] strs = {"a", "b"};

④ 枚举（Enum）

enum Color { RED, GREEN, BLUE }

⑤ 注解（Annotation）

@Override
@Test

特殊类型

void​ 类型

• 表示"无返回值"
• 仅用于方法返回类型，不能声明变量
• 对应的包装类型是 Void

void doSomething() { } // 方法返回 void
// void x; // 错误！不能声明 void 变量

---

null​ ------ 特殊引用值

String s = null; // 可赋给任何引用类型

💡 所有引用类型最终继承自 Object（数组、接口、枚举、注解都是 Object 子类型）。

---

三、类型转换（Type Conversion）

基本类型转换

自动转换（Widening / Promotion）

小类型 → 大类型，无数据丢失

byte b = 10;
int i = b;     // ✅ 自动
long l = i;    // ✅ 自动
float f = l;   // ✅ 自动
double d = f;  // ✅ 自动
char c = 'A';
int x = c;     // ✅ char → int（ASCII值）

强制转换（Narrowing / Casting）

大类型 → 小类型，可能数据丢失或溢出

double d = 123.456;
int i = (int) d; // ✅ 强转，结果 123（小数部分截断）
long big = 9999999999L;
int small = (int) big; // ⚠ 溢出！结果不可预测

引用类型转换

向上转型（Upcasting）​✅ ​​ 自动

Dog dog = new Dog();
Animal animal = dog; // ✅ 自动，子类 → 父类

向下转型（Downcasting）​⚠️ ​​ 需强转，可能失败

Animal a = new Dog();
Dog d = (Dog) a; // ✅ 成功
Animal a2 = new Cat();
Dog d2 = (Dog) a2; // ❌ 运行时抛 ClassCastException

✅ 安全做法：

if (a instanceof Dog) {
    Dog d = (Dog) a;
}

Java 16+ 支持模式匹配：

if (a instanceof Dog d) {
    d.bark(); // 直接使用 d，无需强转
}

---

四、泛型（Generics）与类型擦除

1. 泛型提供编译期类型安全

List<String> list = new ArrayList<>();
list.add("hello");
String s = list.get(0); // ✅ 编译器知道是 String，无需强转
list.add(123); // ❌ 编译错误！

2. 类型擦除（Type Erasure）

泛型只存在于编译期，运行时被擦除为原始类型（Raw Type）

List<String> list1 = new ArrayList<>();
List<Integer> list2 = new ArrayList<>();
System.out.println(list1.getClass() == list2.getClass()); // ✅ true！

编译后都变成 List，泛型信息没了。

五、多态与动态绑定（运行时类型分派）

Java 方法调用是动态绑定（Dynamic Dispatch）：

class Animal { void speak() { System.out.println("Animal"); } }
class Dog extends Animal { void speak() { System.out.println("Dog"); } }
Animal a = new Dog();
a.speak(); // ✅ 输出 "Dog" ------ 根据实际类型调用

编译器检查"声明类型是否有 speak() 方法"，JVM 执行时找"实际类型的方法实现"。

---

六、编译时类型 vs 运行时类型

概念	编译时类型（声明类型）	运行时类型（实际类型）
定义	变量声明的类型（左边）	对象实际的类（右边 new）
作用	决定能访问哪些方法/字段	决定执行哪个方法实现
检查时机	编译期	运行期
获取方式	看代码	obj.getClass()
示例	Animal a = new Dog();→Animal	new Dog()→Dog.class

---

八、类型系统的"安全边界"

编译期安全（Compiler Enforced）

• 类型不匹配 → 编译错误
• 泛型类型错误 → 编译错误
• 访问不存在的方法 → 编译错误

运行时风险（Runtime Risks）

泛型类型擦除 + 反射 → ClassCastException

Java 的泛型是通过 类型擦除 实现的：

• 编译后，泛型类型信息被擦除（如 List<String> → List）
• 运行时 JVM 看不到泛型类型
• 反射可以操作运行时对象，绕过编译器检查
• 导致向泛型集合中插入错误类型的对象
• 最终在取出时抛出 ClassCastException

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
public class TypeErasureReflectionIssue {
    public static void main(String[] args) throws Exception {
        // 1. 创建一个只能存 String 的列表
        List<String> stringList = new ArrayList<>();
        stringList.add("Hello");
        // 2. 使用反射获取 List 的 add 方法
        Method add = List.class.getMethod("add", Object.class);
        // 3. 通过反射向 List<String> 中添加一个 Integer
        add.invoke(stringList, 42);  // ⚠ 绕过编译器检查！
        // 4. 正常遍历（自动类型转换）
        for (String s : stringList) {
            System.out.println(s.toUpperCase());
        }
    }
}

运行结果：

深色版本

Hello
Exception in thread "main" java.lang.ClassCastException: 
    java.lang.Integer cannot be cast to java.lang.String

发生了什么？

步骤	说明
List	编译期：只允许 String
编译后	类型擦除 → 实际是 List，元素是 Object
add.invoke(..., 42)	反射调用 add(Object)，JVM 允许
for (String s : ...)	编译器插入 (String) 强制转换
取出 42 时	(String)42→ClassCastException

---

为什么编译器不阻止？

因为：

• 反射是运行时操作
• 编译器无法预知 invoke 会传什么类型
• 所以 无法进行泛型类型检查

stringList.add(42);        // ❌ 编译错误！
add.invoke(stringList, 42); // ✅ 编译通过，运行时报错

---

数组协变后写入不兼容类型 → ArrayStoreException

Object[] arr = new String[10];
arr[0] = 123; // ❌ 运行时 ArrayStoreException（数组协变的代价）

---

九、Java 类型系统设计哲学

"尽可能在编译期发现错误，运行时保持高效和兼容。"

• 强类型 + 静态检查 → 减少运行时错误
• 类型擦除 → 兼容旧版本 JVM（无泛型时代）
• 多态 + 动态绑定 → 支持面向对象灵活扩展
• null 设计 → 简单但危险