【Java】向上转型和向下转型

先用一个生动形象的例子来解释向上转型和向下转型

向上转型（Upcasting）

想象你有一个动物园，里面有各种不同类型的动物，如狮子、大象、长颈鹿等。动物园的管理员为了方便管理，给每种动物都发放了一个“动物身份证”。这个身份证上并没有详细标明是哪种动物，只是简单地标明“动物”。当管理员查看这些身份证时，他并不关心具体是哪种动物，只要知道它们是动物园里的“动物”就足够了。这就是向上转型的概念。

例子：

假设你有一个Lion类（狮子类），它是Animal类（动物类）的子类。当你创建一个Lion对象，并将其赋值给一个Animal类型的引用时，就发生了向上转型。

Animal animal = new Lion(); // Lion对象被向上转型为Animal类型

在这个例子中，animal引用变量只知道它引用的是一个“动物”，而不知道具体是哪种动物。你可以通过animal引用调用Animal类中定义的方法，但不能调用Lion类中特有的方法。

向下转型（Downcasting）

现在，假设动物园的管理员需要对某种特定的动物进行特殊照顾，比如给狮子喂食特定的食物。这时，管理员需要从一堆“动物身份证”中找到狮子的身份证，并将其视为“狮子身份证”。这就是向下转型的概念。

例子：

继续上面的例子，如果你想通过animal引用调用Lion类中特有的方法（比如roar()方法，表示狮子吼叫），你需要先将animal引用向下转型为Lion类型。

if (animal instanceof Lion) { // 先检查animal引用是否确实指向Lion对象  
    Lion lion = (Lion) animal; // Animal类型被向下转型为Lion类型  
    lion.roar(); // 现在可以调用Lion类中特有的方法了  
}

在这个例子中，你首先使用instanceof运算符检查animal引用是否确实指向一个Lion对象。如果是，你就可以安全地进行向下转型，并调用Lion类中特有的方法。

向上转型

概念

向上转型（Upcasting）是 面向对象编程 中的一个概念，特指将一个子类对象赋值给一个父类类型的引用变量。

这是多态性的一种体现，因为子类对象是父类的一个特例。

在Java中，向上转型是安全的，因为子类继承了父类的所有属性和方法（除了私有方法和构造方法）。

例子

假设有一个父类 Fruit 和子类 Apple

class Fruit {  
    void eat() {  
        System.out.println("Eating fruit");  
    }  
}  
  
class Apple extends Fruit {  
    @Override  
    void eat() {  
        System.out.println("Eating an apple");  
    }  
}

现在，如果我们有一个 Apple 对象，我们可以将它向上转型为 Fruit 类型：

public class Main {  
    public static void main(String[] args) {  
        Apple apple = new Apple();  
        Fruit fruit = apple; // 向上转型  
        //也可写做：Fruit fruit = new Apple();
        fruit.eat(); // 输出 "Eating an apple"，因为实际调用的是 Apple 类的 eat 方法  
    }  
}

在这个例子中，Apple 类的实例 apple 被向上转型为 Fruit 类型，并赋值给 fruit 变量。

尽管 fruit 是 Fruit 类型，但由于多态性，调用 eat() 方法时实际上会执行 Apple 类中重写的 eat() 方法。

这就是向上转型和多态性的实际应用。

发生向上转型的情况

1.子类对象赋值给父类引用

当子类的实例直接赋值给父类类型的引用时，会发生向上转型。这是最常见的向上转型场景。

Apple apple = new Apple();  
Fruit fruit = apple; // 向上转型
//也可写为：Fruit fruit = new Apple();

2.方法参数传递

当向一个接受父类类型参数的方法传递一个子类对象时，也会发生向上转型。

void processFruit(Fruit fruit) {  
    // ...  
}  
 
Apple apple = new Apple();  
processFruit(apple); // 在这里，apple被向上转型为Fruit类型

3.返回值

如果一个方法返回一个子类对象，但是方法的返回类型是父类，那么在返回时也会发生向上转型。

Fruit getFruit() {  
    Apple apple = new Apple();  
    return apple; // 在这里，apple被向上转型为Fruit类型返回  
}

向下转型

概念

向下转型（Downcasting）是Java中类型转换的一种，它指的是将一个父类对象转换为子类类型的全过程。这个过程是显式的，需要使用强制类型转换操作符来完成。

在Java中，子类拥有父类的所有属性和方法（除了 private 修饰的属性和方法），同事还可以定义自己特有的属性和方法。

因此，当我们需要将一个父类对象当做子类对象来使用的时候，就需要进行向下转型。

注意事项

• 向下转型的语法格式如下：

子类类型 变量名 = (子类类型) 父类对象;

• 只能对已经进行过向上转型的对象进行向下转型：

在Java中，我们不能直接将一个父类对象强制转换为子类对象，除非这个父类对象实际上是子类对象的向上转型。也就是说，我们必须先创建一个子类对象，然后将其向上转型为父类对象，最后再进行向下转换。

• 向下转型时需要进行类型检查：

为了避免在运行时抛出 ClassCastException 异常，我们在进行向下转型之前，通常需要使用 instanceof 运算符来检查父类对象是否可以被转换为子类类型。

• 注意访问权限：

在向下转型后，我们可以访问子类特有的属性和方法。但是需要注意的是，如果子类中的某些属性或者方法时 private 的，那么即使进行了向下转型，也无法直接访问这些 private 成员。

例子

下面是一个简单的例子来说明向下转型的用法：

class Animal {  
    void makeSound() {  
        System.out.println("Animal makes a sound");  
    }  
}  
  
class Dog extends Animal {  
    void bark() {  
        System.out.println("Dog barks");  
    }  
}  
  
public class Main {  
    public static void main(String[] args) {  
        Animal animal = new Dog(); // 向上转型，将Dog对象转型为Animal类型  
        if (animal instanceof Dog) { // 使用instanceof进行类型检查  
            Dog dog = (Dog) animal; // 向下转型，将Animal对象转型为Dog类型  
            dog.bark(); // 调用Dog类特有的方法bark()  
        } else {  
            System.out.println("The animal is not a dog.");  
        }  
    }  
}

在这个例子中，我们首先创建了一个 Dog 对象，并将其向上转型为Animal 类型。然后，我们使用 Instanceof 运算符检查这个 Animal 对象是否可以被转换为 Dog 类型。如果可以转换，我们就进行向下转型，将 Animal 对象转换为 Dog 类型，并调用 Dog 类特有的方法 bark() 。

ClassCastException异常

概念

ClassCastException是Java中的一个运行时异常，它发生在试图将一个对象强制转换为不是其实际类型的类类型时。换句话说，当你尝试将一个对象转型为它不兼容的类型时，就会抛出此异常。

这个异常通常发生在向下转型时，如果你没有正确地检查对象的实际类型就进行转换，可能会引发ClassCastException。在Java中，向上转型是安全的，因为子类对象是父类类型的一个特例。但是，向下转型则需要显式的类型转换，并且如果不当使用，就可能导致 ClassCastException。

例子

下面是一个会导致 ClassCastException 异常的例子：

class Animal {}  
  
class Dog extends Animal {}  
  
class Cat extends Animal {}  
  
public class Main {  
    public static void main(String[] args) {  
        Animal animal = new Cat(); 
// 向上转型，Cat 是Animal的子类，所以这是安全的  
        Dog dog = (Dog) animal; 
// 尝试向下转型，但是 animal 实际上是 Cat 类型，所以会抛出 ClassCastException  
    }  
}

在这个例子中，我们创建了一个 Cat 对象，并将其赋值给 Animal 类型的变量 animal。然后，我们尝试将这个 Animal 类型的变量强制转换为 Dog 类型。但是，因为这个 Animal 对象实际上是 Cat 类型的，所以转换会失败，并抛出一个 ClassCastException。

为了避免这种异常，你可以在向下转型之前使用 instanceof 操作符来检查对象是否可以被安全地转换为目标类型：

if (animal instanceof Dog) {  
    Dog dog = (Dog) animal; // 这是安全的，因为已经检查了类型  
} else {  
    System.out.println("The animal is not a dog.");  
}