目录
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()`方法。这种灵活性大大提高了代码的可扩展性和可维护性。
以上实例其实是用到了向上转型,那么向下转型有什么作用呢?
比如在这个案例中,每个动物需要人喊一声吃饭才能喂,这是子类特有的方法,父类中没有,这时就需要向下转型。具体代码在此就不实现了。