在 Java 中，不能直接将一个父类对象赋值给一个子类引用变量。 这会导致编译错误。

下面我们通过代码、原因、解决方案和正确用法来彻底搞懂这个问题。

为什么直接赋值会出错？（编译时类型检查）

Java 是一门静态类型语言，这意味着在编译时，编译器会检查变量的类型和赋给它对象的类型是否匹配。

// 定义父类
class Animal {
    void eat() {
        System.out.println("Animal is eating.");
    }
}
// 定义子类
class Dog extends Animal {
    void bark() {
        System.out.println("Dog is barking.");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal myAnimal = new Animal(); // 父类对象
        Dog myDog = new Dog();         // 子类对象
        // --- 错误的尝试 ---
        // 以下这行代码会编译失败！
        // myDog = myAnimal; 
        // 错误信息类似于： incompatible types: Animal cannot be converted to Dog
    }
}

编译器为什么会报错？

编译器会这样思考：

变量 myDog 的类型是 Dog，这意味着我期望它指向一个 Dog 对象。Dog 对象有什么特性？它有 Animal 的所有方法（eat），并且还有自己特有的方法（bark），你试图把一个 Animal 对象赋给我，这个 Animal 对象里没有 bark() 方法，如果允许你这么做，那么当后续代码调用 myDog.bark() 时，程序去哪里找这个方法？它会在一个根本不包含 bark() 方法的 Animal 对象上寻找，这显然是危险的，会导致运行时错误，为了防止这种潜在的错误，我必须在编译阶段就阻止你。

编译器阻止了这种“不安全”的赋值。

如何实现“父类对象”和“子类引用”的交互？（正确的方式）

虽然不能直接将父类对象赋给子类引用,但在 Java 中，我们经常使用向上转型和向下转型来实现多态和灵活的对象操作。

向上转型 (Upcasting) - 安全且常用

定义：将子类对象赋值给父类引用变量。

这不仅是允许的,而且是实现多态的核心。

Animal myAnimal = new Dog(); // 这是完全正确的！
// 等同于
Dog myDog = new Dog();
Animal myAnimal = myDog; // 子类对象赋给父类引用

发生了什么？

• myAnimal 是一个 Animal 类型的引用。
• 它指向的是一个在堆内存中创建的 new Dog() 对象。
• 因为 Dog 是 Animal 的一种，所以这个赋值是安全的。
• 通过 myAnimal，你只能访问 Animal 类中定义的方法（如 eat()），不能访问 Dog 特有的方法（如 bark()）。

Animal myAnimal = new Dog();
myAnimal.eat(); // 正确，可以调用
myAnimal.bark(); // 编译错误！因为编译器认为 myAnimal 是 Animal 类型，没有 bark 方法

向下转型 (Downcasting) - 不安全，需要检查

定义：将父类引用（指向子类对象）再转回子类引用。

这是实现“父类对象赋值给子类引用”功能的唯一正确途径，但这个过程是不安全的，必须使用 instanceof 操作符进行检查。

错误示例（不检查）：

Animal myAnimal = new Dog(); // 向上转型
Dog myDog = (Dog) myAnimal; // 直接强制向下转型，编译可以通过，但有风险
// myAnimal 指向的是一个纯粹的 Animal 对象呢？
Animal myAnimal2 = new Animal();
Dog myDog2 = (Dog) myAnimal2; // 这行代码编译通过，但运行时会抛出 ClassCastException
// Exception in thread "main" java.lang.ClassCastException: class Animal cannot be cast to class Dog

正确示例（使用 instanceof 检查）：

Animal myAnimal = new Dog(); // 可能是 Dog，也可能是 Cat...
if (myAnimal instanceof Dog) {
    // 只有在确认 myAnimal 确实是 Dog 或其子类的实例时，才进行强制转换
    Dog myDog = (Dog) myAnimal; 
    myDog.bark(); // 现在可以安全地调用 Dog 的特有方法了
} else {
    System.out.println("This animal is not a dog.");
}
// 另一种写法（Java 14+ 的模式匹配，更简洁）
if (myAnimal instanceof Dog myDog) {
    myDog.bark(); // myDog 在这里已经是 Dog 类型了
}

instanceof 的作用：

• 在运行时检查 myAnimal 引用的对象是否是 Dog 类的实例（或者是 Dog 的子类）。
• 如果是,instanceof 返回 true，强制转换是安全的。
• 如果不是,instanceof 返回 false，避免了 ClassCastException。

总结与最佳实践

核心思想：

1. is-a 关系：Dog is-a Animal，Dog 对象可以自然地被当作 Animal 来用（向上转型），但 Animal 不一定 is-a Dog，所以需要显式地、小心地转换（向下转型）。
2. 编译时 vs 运行时：
   • 编译时：编译器只关心引用变量的类型。Animal 引用不能调用 Dog 的特有方法。
   • 运行时：JVM 调用方法时，会根据对象实际的类型（new Dog()）来决定执行哪个版本的方法，这就是多态。

最佳实践：

• 优先使用向上转型：当你只需要处理一个对象的一般特性时，尽量使用父类引用，这会让你的代码更具扩展性（可以轻松地换成 Cat 对象）。
• 谨慎使用向下转型：只在确实需要访问子类特有方法时才使用，并且必须配合 instanceof 进行类型检查，以避免 ClassCastException。

一个完整的例子

// 父类
class Animal {
    String name;
    public Animal(String name) {
        this.name = name;
    }
    void makeSound() {
        System.out.println(name + " makes a generic sound.");
    }
}
// 子类 1
class Dog extends Animal {
    public Dog(String name) {
        super(name);
    }
    @Override
    void makeSound() {
        System.out.println(name + " says: Woof!");
    }
    void fetch() {
        System.out.println(name + " is fetching the ball.");
    }
}
// 子类 2
class Cat extends Animal {
    public Cat(String name) {
        super(name);
    }
    @Override
    void makeSound() {
        System.out.println(name + " says: Meow!");
    }
    void scratch() {
        System.out.println(name + " is scratching the furniture.");
    }
}
public class PolymorphismDemo {
    public static void main(String[] args) {
        // 1. 向上转型 (Upcasting)
        Animal myDog = new Dog("Buddy");   // 父类引用指向子类对象
        Animal myCat = new Cat("Whiskers");
        // 通过父类引用调用方法，会执行子类重写的方法（多态）
        myDog.makeSound(); // Buddy says: Woof!
        myCat.makeSound(); // Whiskers says: Meow!
        // 2. 向下转型 (Downcasting)
        // 假设我们有一个方法，需要让动物做特定的事情
        performAction(myDog); // Buddy says: Woof! Buddy is fetching the ball.
        performAction(myCat); // Whiskers says: Meow! Whiskers is scratching the furniture.
        // 3. 处理非 Dog 对象的情况
        performAction(new Animal("Generic Animal")); // Generic Animal makes a generic sound.
    }
    public static void performAction(Animal animal) {
        System.out.println("--- Performing action for " + animal.name + " ---");
        animal.makeSound(); // 总是可以调用
        // 只有当 animal 是 Dog 时，才能调用 fetch()
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal; // 向下转型
            dog.fetch();
        }
        // 只有当 animal 是 Cat 时，才能调用 scratch()
        if (animal instanceof Cat) {
            Cat cat = (Cat) animal; // 向下转型
            cat.scratch();
        }
    }
}

这个例子清晰地展示了向上转型、多态、向下转型以及 instanceof 检查的完整流程。