核心概念：多态
在理解向上和向下转型之前，必须先理解 多态。
（图片来源网络，侵删）
多态 的字面意思是 “多种形态”，在 Java 中，它意味着同一个接口,使用不同的实例而执行不同操作。
多态的实现依赖于三个要素：
- 继承：必须有类之间的继承关系。
- 重写：子类必须重写父类的方法。
- 向上转型：父类引用指向子类对象。
向上转型
定义
将一个子类对象赋值给其父类（或接口）的引用变量，这个过程是 自动的、安全的。
语法
// 父类 引用 = new 子类(); Animal animal = new Dog(); // Dog 是 Animal 的子类
工作原理
这里的 animal 是一个 Animal 类型的引用，但它指向的是 Dog 这个对象在堆内存中的地址。
（图片来源网络，侵删）
特点
- 自动完成：编译器会自动处理,无需任何强制转换。
- 可以调用：
- 父类中定义的所有方法。
- 子类中 重写 的父类方法。
- 不可以调用：
- 子类 特有 的方法，因为这些方法在父类中不存在,编译器无法通过检查。
代码示例
class Animal {
public void eat() {
System.out.println("动物吃东西");
}
}
class Dog extends Animal {
// 重写父类的方法
@Override
public void eat() {
System.out.println("狗吃骨头");
}
// 子类特有的方法
public void bark() {
System.out.println("汪汪叫");
}
}
public class UpcastingDemo {
public static void main(String[] args) {
// 1. 向上转型
Animal animal = new Dog(); // 自动完成
// 2. 调用父类的方法 (可以被调用)
animal.eat(); // 输出: 狗吃骨头 (调用了子类重写的方法，体现了多态)
// 3. 调用子类特有的方法 (不能被调用)
// animal.bark(); // 编译错误！因为 Animal 类中没有 bark() 方法
}
}
向上转型的优点：
- 提高代码的扩展性和灵活性：你可以定义一个方法，接收
Animal类型的参数，这样无论是Dog、Cat还是其他Animal的子类对象都可以传入,非常通用。
public void makeAnimalEat(Animal animal) {
animal.eat();
}
// 在 main 方法中调用
makeAnimalEat(new Dog()); // 输出: 狗吃骨头
makeAnimalEat(new Cat()); // 输出: 猫吃鱼
向下转型
定义
将一个父类（或接口）的引用，再转回指向其子类对象，这个过程是 强制性的、有风险的。
语法
// 子类 引用 = (子类) 父类引用; Dog dog = (Dog) animal;
工作原理
它告诉编译器：“请相信我，这个 animal 引用实际上指向的是一个 Dog 对象，请把它当作 Dog 来处理。”
特点
- 强制转换：必须使用 进行显式类型转换。
- 有风险：如果父类引用指向的不是目标子类的对象，那么在运行时会抛出
ClassCastException（类型转换异常）。 - 前提条件：只有当父类引用 已经指向了目标子类的对象 时,向下转型才是安全的。
如何安全地进行向下转型？
Java 提供了 instanceof 操作符来检查一个对象是否是某个特定类的实例，在进行向下转型之前，强烈建议使用 instanceof 进行判断。
instanceof 语法：对象 instanceof 类
- 如果对象是指定类或其子类的实例，返回
true。 - 否则，返回
false。
代码示例
class Animal {
public void eat() {
System.out.println("动物吃东西");
}
}
class Dog extends Animal {
public void eat() {
System.out.println("狗吃骨头");
}
public void bark() {
System.out.println("汪汪叫");
}
}
class Cat extends Animal {
public void eat() {
System.out.println("猫吃鱼");
}
public void meow() {
System.out.println("喵喵叫");
}
}
public class DowncastingDemo {
public static void main(String[] args) {
// 向上转型
Animal animal1 = new Dog();
Animal animal2 = new Cat();
// --- 安全的向下转型 ---
// 1. 先用 instanceof 检查
if (animal1 instanceof Dog) {
// 2. 再进行强制转换
Dog dog = (Dog) animal1;
dog.bark(); // 现在可以安全地调用子类特有方法了
}
// --- 危险的向下转型 (会抛出异常) ---
try {
// animal2 指向的是 Cat 对象，不是 Dog 对象
Dog wrongDog = (Dog) animal2; // 编译通过，但运行时抛出 ClassCastException
wrongDog.bark();
} catch (ClassCastException e) {
System.out.println("错误：无法将 Cat 对象转换为 Dog 对象！");
}
// --- 另一种危险情况 ---
Animal animal3 = new Animal();
if (animal3 instanceof Dog) { // 这个判断为 false
Dog dog3 = (Dog) animal3; // 这行代码不会执行，所以不会报错
} else {
System.out.println("animal3 不是 Dog 的实例，不能向下转型。");
}
}
}
总结与最佳实践
| 特性 | 向上转型 | 向下转型 |
|---|---|---|
| 定义 | 子类对象赋值给父类引用 | 父类引用赋值给子类引用 |
| 语法 | Parent p = new Child(); (自动) |
Child c = (Child) p; (强制) |
| 安全性 | 安全，编译器保证 | 不安全，可能抛出 ClassCastException |
| 目的 | 实现多态，统一接口，提高代码灵活性 | 调用子类特有方法，访问子类扩展功能 |
| 使用场景 | 当你只需要使用父类共有的方法时 | 当你需要明确使用子类特有方法时 |
黄金法则
在进行向下转型之前，总是使用 instanceof 进行检查。
// 安全的向下转型模板
if (parentReference instanceof ChildClass) {
ChildClass childReference = (ChildClass) parentReference;
// 现在可以安全地使用 childReference 调用 ChildClass 的特有方法
}
通过掌握向上和向下转型，你可以写出更加灵活、可扩展和符合面向对象设计原则的 Java 代码。
