核心结论（先说重点）
在标准的 Java 语法中，不能直接将一个父类对象赋值给一个子类引用变量。
（图片来源网络，侵删）
编译器会直接报错,因为这是不安全的。
为什么会这样？类型安全性的问题
让我们通过一个经典的例子来理解为什么这是不安全的。
// 父类
class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}
// 子类
class Dog extends Animal {
void bark() {
System.out.println("The dog barks.");
}
}
// 另一个子类
class Cat extends Animal {
void meow() {
System.out.println("The cat meows.");
}
}
我们尝试进行直接赋值：
Animal myAnimal = new Animal(); Dog myDog = new Dog(); // 尝试将父类对象赋值给子类引用 // myDog = myAnimal; // 这行代码在编译时会报错！ // Error: incompatible types: Animal cannot be converted to Dog
编译器为什么报错？
（图片来源网络，侵删）
想象一下,如果上面的代码是允许的，会发生什么：
// 假设编译器允许了 Animal myAnimal = new Animal(); // myAnimal 指向一个普通的 Animal 对象 Dog myDog = myAnimal; // 假设这行合法了，myDog 现在也指向了那个普通的 Animal 对象 // 我们通过 myDog 这个“狗”类型的引用来调用一个“狗”特有的方法 myDog.bark();
灾难发生了！
myAnimal实际上是一个Animal对象，它没有bark()方法。- 我们通过
Dog类型的引用myDog去调用bark()，程序期望的是一个Dog的行为。 - 但
myDog指向的内存里只是一个Animal，根本不知道如何“bark()”。 - 这会导致运行时错误,破坏了 Java 的类型安全系统。
为了防止这种在运行时才会暴露的严重错误,Java 编译器在编译阶段就阻止了这种不安全的操作。
如果我真的需要这么做，该怎么办？
虽然不能直接赋值,但在很多实际场景中，我们确实需要处理一个可能是父类也可能是子类的对象，这时，我们有以下几种标准做法：
（图片来源网络，侵删）
向上转型 - 安全且常用
这是最常见、最自然的操作，将一个子类对象赋值给一个父类引用变量。
Dog myDog = new Dog(); Animal myAnimal = myDog; // 这是完全合法的！ // myAnimal 引用的是 Dog 对象，但它只能访问 Animal 类中定义的方法 myAnimal.eat(); // 输出: This animal eats food. // myAnimal.bark(); // 编译错误！因为编译器认为 myAnimal Animal，不知道 bark 方法
为什么这是安全的？
因为 Dog 是 Animal 的一种，Dog 对象必然包含了 Animal 的所有属性和方法，用 Animal 的引用去指向一个 Dog 对象，是绝对安全的，这被称为“向上转型”（Upcasting），是 Java 多态性的基石。
向下转型 - 需要强制转换和检查
当我们需要访问子类特有的方法时,就需要将父类引用“转回”子类引用，这就是向下转型（Downcasting）。
向下转型是危险的，必须使用 instanceof 操作符进行运行时检查，以确保安全。
Animal myAnimal = new Dog(); // 一个向上转型的例子
// 尝试直接向下转型
// Dog myDog = myAnimal; // 编译错误！必须强制转换
// 正确的做法：先检查，再转换
if (myAnimal instanceof Dog) {
// 编译器知道，如果进入这个 if 语句，myAnimal 一定是一个 Dog 对象
Dog myDog = (Dog) myAnimal; // 强制类型转换
myDog.bark(); // 现在可以安全地调用 Dog 的特有方法了
// 输出: The dog barks.
} else {
System.out.println("myAnimal is not a Dog.");
}
instanceof 的作用：
instanceof 是一个二元操作符，用来检查一个对象是否是一个特定类（或其子类、或实现了特定接口）的实例，如果检查通过，它会返回 true，否则返回 false，这是进行向下转型前必不可少的安全步骤。
使用泛型 - 更安全、更现代的方案
如果你的父类和子类有共同的泛型接口,可以使用泛型来提供编译时的类型安全。
// 假设我们有一个泛型接口
class Box<T> {
private T content;
// ... constructor and methods
}
// 父类
class Animal {}
// 子类
class Dog extends Animal {}
public class Main {
public static void main(String[] args) {
// 创建一个存放 Dog 的 Box
Box<Dog> dogBox = new Box<>(new Dog());
// Dog 是 Animal 的一种，Box<Dog> 可以赋值给 Box<? extends Animal>
// 这被称为 "PECS" (Producer Extends Consumer Super) 原则中的 "Extends"
Box<? extends Animal> animalBox = dogBox; // 这是合法的泛型赋值
// 你不能通过 animalBox 来添加内容，因为编译器不确定它具体是哪种 Animal
// animalBox.setContent(new Animal()); // 编译错误！
// animalBox.setContent(new Dog()); // 编译错误！
// 你只能从中读取内容，并且知道取出来的一定是 Animal 或其子类
Animal a = animalBox.getContent();
}
}
泛型提供了一种更灵活且类型安全的方式来处理这种“父类引用指向子类对象”的场景，尤其在集合框架中应用广泛。
| 操作类型 | 描述 | 语法示例 | 安全性 | 常见场景 |
|---|---|---|---|---|
| 直接赋值 (非法) | 将父类对象赋给子类引用 | Child c = new Parent(); |
不安全 | 编译报错，Java 禁止。 |
| 向上转型 | 将子类对象赋给父类引用 | Parent p = new Child(); |
安全 | 多态、方法参数、返回值。 |
| 向下转型 | 将父类引用转回子类引用 | Child c = (Child) p; |
危险 | 必须配合 instanceof 检查。 |
| 泛型 (通配符) | 使用 <? extends T> 接收子类泛型 |
Box<? extends Parent> box = new Box<Child>(); |
安全 | 集合框架、泛型方法，提供编译时安全。 |
记住黄金法则：
- 子类对象可以当作父类对象来用（向上转型），这是安全的。
- 父类对象不能直接当作子类对象来用（直接赋值），这是危险的。
- 如果想把父类引用当作子类对象来用，必须先检查它是不是那个子类的实例（
instanceof），然后强制转换（向下转型）。
