向上转型多态是Java面向对象编程中提升代码灵活性的重要特性，指的是将子类对象的引用赋值给父类类型的变量，这种写法可以让程序在运行时根据实际对象类型执行对应的方法逻辑，是很多框架和通用代码设计的基础。
向上转型的基础概念
向上转型的本质是子类对象可以自动转换为父类类型，不需要额外的强制转换操作。这是因为子类继承了父类的所有非私有成员，天然具备父类的特征，所以父类引用可以指向子类实例。比如定义一个父类Animal和两个子类Dog、Cat，就可以写出如下代码：
// 定义父类
class Animal {
// 父类成员变量
String name = "动物";
// 父类普通方法
public void eat() {
System.out.println("动物吃东西");
}
// 父类静态方法
public static void sleep() {
System.out.println("动物睡觉");
}
}
// 定义子类Dog
class Dog extends Animal {
// 子类成员变量
String name = "狗";
// 重写父类eat方法
@Override
public void eat() {
System.out.println("狗吃骨头");
}
// 子类独有方法
public void bark() {
System.out.println("狗汪汪叫");
}
// 隐藏父类静态方法
public static void sleep() {
System.out.println("狗趴着睡觉");
}
}
// 定义子类Cat
class Cat extends Animal {
// 重写父类eat方法
@Override
public void eat() {
System.out.println("猫吃鱼");
}
}
向上转型的语法形式
向上转型的写法非常简单，直接将子类实例赋值给父类类型的变量即可：
public class Test {
public static void main(String[] args) {
// 向上转型：父类引用指向子类对象
Animal animal1 = new Dog();
Animal animal2 = new Cat();
}
}
这里animal1和animal2都是Animal类型的引用，但实际指向的是Dog和Cat的实例对象。
向上转型后的执行规则
1. 普通方法的执行逻辑
当通过父类引用调用普通方法时，会触发动态绑定机制，程序在运行时才会确定实际要执行的方法版本，规则是：如果子类重写了该方法，就执行子类的方法；如果子类没有重写，就执行父类的方法。
我们运行上面的Test类的main方法，添加方法调用代码：
public class Test {
public static void main(String[] args) {
Animal animal1 = new Dog();
Animal animal2 = new Cat();
// 调用eat方法
animal1.eat(); // 输出：狗吃骨头
animal2.eat(); // 输出：猫吃鱼
}
}
可以看到，虽然animal1和animal2都是Animal类型，但调用的eat方法分别是Dog和Cat中重写的版本，这就是多态的核心体现。
2. 成员变量的访问规则
成员变量的访问和方法是不同的，成员变量不存在动态绑定，访问时看的是引用变量的类型，而不是实际对象的类型。我们测试成员变量的访问：
public class Test {
public static void main(String[] args) {
Animal animal1 = new Dog();
// 访问成员变量name
System.out.println(animal1.name); // 输出：动物
}
}
这里animal1实际指向的是Dog对象，但name属性访问的是Animal父类中定义的name，因为引用类型是Animal。
3. 静态方法的访问规则
静态方法属于类，不属于对象，所以也不存在动态绑定，访问时同样看引用变量的类型。我们测试静态方法的调用：
public class Test {
public static void main(String[] args) {
Animal animal1 = new Dog();
// 调用静态方法sleep
animal1.sleep(); // 输出：动物睡觉
// 推荐用类名调用静态方法，更清晰
Animal.sleep(); // 输出：动物睡觉
Dog.sleep(); // 输出：狗趴着睡觉
}
}
可以看到，通过animal1调用sleep方法时，执行的是Animal类的静态方法，而不是Dog类中定义的版本。
4. 子类独有方法的访问限制
父类引用只能调用父类中定义过的方法，子类独有的方法无法通过父类引用直接调用，如果强行调用会编译报错。比如Dog类的bark方法是独有的，下面的代码会编译失败：
Animal animal1 = new Dog(); animal1.bark(); // 编译错误：找不到符号bark
如果需要调用子类独有方法，必须先将父类引用强制向下转型为子类类型：
Animal animal1 = new Dog();
// 向下转型，需要先判断类型避免转换异常
if (animal1 instanceof Dog) {
Dog dog = (Dog) animal1;
dog.bark(); // 输出：狗汪汪叫
}
向上转型多态的应用场景
向上转型多态最常见的应用场景是方法参数设计，比如定义一个通用的方法，接收父类类型的参数，就可以传入任意子类对象，提升代码的复用性：
public class Test {
// 通用方法，接收Animal类型参数
public static void feed(Animal animal) {
animal.eat();
}
public static void main(String[] args) {
Dog dog = new Dog();
Cat cat = new Cat();
// 传入子类对象，自动向上转型
feed(dog); // 输出：狗吃骨头
feed(cat); // 输出：猫吃鱼
}
}
这种方式不需要为每种动物单独写feed方法，后续新增Animal的子类也不需要修改feed方法的逻辑，符合开闭原则。
常见误区说明
- 误区1：向上转型后对象变成了父类对象。实际上对象本身还是子类实例，只是引用类型被限制为父类，只是不能访问子类独有成员而已。
- 误区2：所有方法都会执行子类版本。只有被子类重写的普通实例方法才会执行子类版本，静态方法、成员变量、私有方法都不会。
- 误区3：向上转型需要强制转换。向上转型是自动完成的，不需要写强制转换符，只有向下转型才需要强制转换。
向上转型多态的核心逻辑可以总结为：编译看左边（引用类型），运行看右边（实际对象），但仅针对普通重写的实例方法，成员变量和静态方法始终看左边。