Java多态性向上转型与向下转型案例详解

目录

1、向上转型案例：

2、向下转型案例：

3、多态的优点（向上转型、向下转型）

---

1、向上转型案例：

// 父类Animal
public class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

// 子类Dog
public class Dog extends Animal {
    public void eat() {
        System.out.println("Dog is eating.");
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat();   // 输出 Dog is eating.
        // animal.bark();  // 编译报错，无法调用子类特有的方法
    }
}

在上述例子中，我们创建了一个 Animal 父类和一个 Dog 子类。由于 Dog 是 Animal 的一个子类，因此我们可以将 Dog 对象向上转型为 Animal 类型。通过向上转型，我们可以实现多态性，即在运行时调用子类重写的方法。

2、向下转型案例：

// 父类Animal
public class Animal {
    public void eat() {
        System.out.println("Animal is eating.");
    }
}

// 子类Dog
public class Dog extends Animal {
    public void eat() {
        System.out.println("Dog is eating.");
    }

    public void bark() {
        System.out.println("Dog is barking.");
    }
}

// 测试类
public class Test {
    public static void main(String[] args) {
        Animal animal = new Dog();
        animal.eat();   // 输出 Dog is eating.
        
        // 向下转型
        Dog dog = (Dog) animal;
        dog.bark();     // 输出 Dog is barking.
    }
}

在上述例子中，我们仍然创建了一个 Animal 父类和一个 Dog 子类。但是，在测试类中，我们将 Dog 对象向上转型为了 Animal 类型。然后，我们在进行向下转型之前，需要先判断该对象是否是 Dog 类型的。只有当对象确实是 Dog 类型时，才能进行向下转型。通过向下转型，我们可以调用子类特有的方法。

3、多态的优点（向上转型、向下转型）

多态性是面向对象编程中的一个重要概念，它为程序带来了很多优点，包括灵活性、可扩展性和可维护性。

下面通过一个实例讲解一下多态的优点：

假设我们有一个动物园管理系统，需要对动物园中的动物进行喂食。这个系统需要具备灵活性，以便将来可以容易地添加新的动物种类。

1. 首先，我们创建一个Animal抽象类，表示所有动物的共性：

public abstract class Animal {
    public abstract void eat();
}

2. 接下来，我们创建具体的动物类（如Lion、Tiger和Bear），继承Animal类并实现`eat()`方法：

public class Lion extends Animal {
    @Override
    public void eat() {
        System.out.println("The lion is eating meat.");
    }
}

public class Tiger extends Animal {
    @Override
    public void eat() {
        System.out.println("The tiger is eating meat.");
    }
}

public class Bear extends Animal {
    @Override
    public void eat() {
        System.out.println("The bear is eating honey.");
    }
}

3. 创建一个Zoo类，负责喂食动物：

public class Zoo {
    public void feedAnimal(Animal animal) {
        animal.eat();
    }
}

4. 在主类中，创建具体的动物对象，并将它们传递给Zoo类的`feedAnimal()`方法：

public class ZooExample {
    public static void main(String[] args) {
        Zoo zoo = new Zoo();

        Lion lion = new Lion();
        Tiger tiger = new Tiger();
        Bear bear = new Bear();

        zoo.feedAnimal(lion); // 输出：The lion is eating meat.
        zoo.feedAnimal(tiger); // 输出：The tiger is eating meat.
        zoo.feedAnimal(bear); // 输出：The bear is eating honey.
    }
}

在这个例子中，我们利用多态性轻松地添加了新的动物类型（如Lion、Tiger和Bear），同时确保了Zoo类的`feedAnimal()`方法的灵活性。如果将来需要添加新的动物，我们只需创建一个新的子类，继承Animal类并实现`eat()`方法。这种灵活性大大提高了代码的可扩展性和可维护性。

以上实例其实是用到了向上转型，那么向下转型有什么作用呢？

比如在这个案例中，每个动物需要人喊一声吃饭才能喂，这是子类特有的方法，父类中没有，这时就需要向下转型。具体代码在此就不实现了。