第34章 Java多态

面包屑导航章节标题多态概念介绍

什么是多态？

多态（Polymorphism）是面向对象编程的三大特性之一，它允许不同类的对象对同一消息做出不同的响应。在Java中，多态主要通过方法重写和动态绑定来实现。

多态的核心思想"同一个接口，不同的实现"。通过父类引用指向子类对象，在运行时根据对象的实际类型来决定调用哪个方法。

多态的实现条件

继承关系：子类继承父类
方法重写：子类重写父类的方法
向上转型：父类引用指向子类对象

// 多态的基本示例
Animal animal1 = new Dog("旺财", 3, "金毛");  // 向上转型
Animal animal2 = new Cat("咪咪", 2, "橘色");
Animal animal3 = new Bird("小黄", 1, true);

// 动态绑定 - 运行时决定调用哪个方法
animal1.makeSound();  // 调用Dog的makeSound方法
animal2.makeSound();  // 调用Cat的makeSound方法
animal3.makeSound();  // 调用Bird的makeSound方法

多态的类型

编译时多态（静态多态）

方法重载（Overloading）
运算符重载
在编译时确定调用哪个方法

// 方法重载示例
public void print(int num) { }
public void print(String str) { }
public void print(double num) { }

运行时多态（动态多态）

方法重写（Overriding）
动态绑定
在运行时确定调用哪个方法

// 方法重写示例
@Override
public void makeSound() {
    System.out.println("汪汪汪!");
}

向上转型和向下转型

向上转型（Upcasting）

将子类对象赋值给父类引用，这是自动进行的，无需强制转换。

// 向上转型示例
Animal animal = new Dog("旺财", 3, "金毛");  // 自动向上转型

// 特点：
// 1. 自动进行，无需强制转换
// 2. 只能访问父类中定义的方法
// 3. 实际调用的是子类重写的方法（动态绑定）
animal.makeSound();  // 调用Dog重写的makeSound方法
animal.move();       // 调用Dog重写的move方法
// animal.wagTail(); // 编译错误！无法访问子类特有方法

向下转型（Downcasting）

将父类引用转换为子类引用，需要强制转换，并且必须先检查类型。

// 向下转型示例
Animal animal = new Dog("旺财", 3, "金毛");

// 安全的向下转型
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;  // 强制转换
    dog.wagTail();           // 现在可以调用子类特有方法
    dog.guard();
}

// 错误示例（会抛出ClassCastException）
// Cat cat = (Cat) animal;  // 运行时异常！

向下转型注意事项必须使用instanceof关键字检查类型如果类型不匹配会抛出ClassCastException只有在确实需要访问子类特有方法时才使用

动态绑定

动态绑定是指在运行时根据对象的实际类型来决定调用哪个方法，这是多态的核心机制。

// 动态绑定演示
Animal[] animals = {
    new Dog("大黄", 4, "土狗"),
    new Cat("小白", 3, "白色"),
    new Bird("小红", 2, true),
    new Dog("小黑", 2, "拉布拉多"),
    new Cat("花花", 1, "花色")
};

// 同一个循环，不同的行为
for (Animal animal : animals) {
    animal.makeSound();  // 运行时决定调用哪个类的方法
    animal.move();       // 每种动物都有不同的移动方式
}

动态绑定的工作原理编译时：检查父类中是否有该方法运行时：根据对象的实际类型查找方法如果子类重写了该方法，调用子类的版本如果子类没有重写，调用父类的版本

instanceof关键字

instanceof关键字用于在运行时检查对象是否是特定类的实例，这在向下转型时非常重要。

// instanceof使用示例
Animal animal = new Dog("旺财", 3, "金毛");

// 类型检查
if (animal instanceof Dog) {
    System.out.println("这是一只狗");
    Dog dog = (Dog) animal;
    dog.wagTail();
} else if (animal instanceof Cat) {
    System.out.println("这是一只猫");
    Cat cat = (Cat) animal;
    cat.climbTree();
} else if (animal instanceof Bird) {
    System.out.println("这是一只鸟");
    Bird bird = (Bird) animal;
    bird.sing();
}

// 检查继承关系
if (animal instanceof Animal) {
    System.out.println("确认是Animal类型");  // 总是true
}

instanceof的使用场景

向下转型前的类型检查
根据对象类型执行不同的逻辑
在处理混合类型集合时进行类型判断
实现类型安全的操作

完整代码示例

以下是一个完整的多态演示程序，展示了动物类层次结构中的多态应用：

// Animal.java - 动物基类
public class Animal {
    protected String name;
    protected int age;
    
    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public void makeSound() {
        System.out.println(name + "发出了声音");
    }
    
    public void move() {
        System.out.println(name + "正在移动");
    }
    
    public String getInfo() {
        return "动物: " + name + ", 年龄: " + age + "岁";
    }
    
    // getter和setter方法...
}

// Dog.java - 狗类
public class Dog extends Animal {
    private String breed;
    
    public Dog(String name, int age, String breed) {
        super(name, age);
        this.breed = breed;
    }
    
    @Override
    public void makeSound() {
        System.out.println(name + "(狗)发出声音: 汪汪汪!");
    }
    
    @Override
    public void move() {
        System.out.println(name + "(狗)正在奔跑");
    }
    
    public void wagTail() {
        System.out.println(name + "正在摇尾巴，表示开心!");
    }
    
    public void guard() {
        System.out.println(name + "正在看家护院");
    }
}

// 多态演示
public class PolymorphismDemo {
    public static void main(String[] args) {
        // 创建不同类型的动物
        Animal[] animals = {
            new Dog("旺财", 3, "金毛"),
            new Cat("咪咪", 2, "橘色"),
            new Bird("小黄", 1, true)
        };
        
        // 多态调用
        for (Animal animal : animals) {
            animal.makeSound();  // 动态绑定
            animal.move();
            
            // 根据类型执行特殊行为
            if (animal instanceof Dog) {
                ((Dog) animal).wagTail();
            } else if (animal instanceof Cat) {
                ((Cat) animal).climbTree();
            } else if (animal instanceof Bird) {
                ((Bird) animal).sing();
            }
        }
    }
}

💻 查看完整代码 - 在线IDE体验多态的优势

多态的优势

代码复用性

一个方法可以处理多种类型的对象
减少代码重复
提高开发效率

扩展性

添加新的子类不需要修改现有代码
符合开闭原则
支持插件式架构

维护性

统一的接口使代码更容易理解
降低模块间的耦合度
便于代码维护和修改

灵活性

运行时决定具体行为
支持动态配置
适应不同的业务需求

实际应用场景

1. 图形界面编程

// 不同的组件有不同的绘制方法
Component[] components = {
    new Button("确定"),
    new TextField("输入框"),
    new Label("标签")
};

for (Component comp : components) {
    comp.paint();  // 多态调用，每个组件有不同的绘制方式
}

2. 数据库操作

// 不同数据库的连接方式
Connection[] connections = {
    new MySQLConnection(),
    new OracleConnection(),
    new PostgreSQLConnection()
};

for (Connection conn : connections) {
    conn.connect();  // 多态调用，每种数据库有不同的连接方式
}

3. 游戏开发

// 不同角色有不同的攻击方式
Character[] characters = {
    new Warrior("战士"),
    new Mage("法师"),
    new Archer("弓箭手")
};

for (Character character : characters) {
    character.attack();  // 多态调用，每个角色有不同的攻击方式
}

注意事项

多态使用注意事项静态方法不支持多态：静态方法在编译时绑定私有方法不能被重写：private方法不支持多态构造方法不支持多态：构造方法不能被重写向下转型需谨慎：必须先用instanceof检查类型方法重写规则：访问修饰符不能更严格

// 静态方法不支持多态
Animal animal = new Dog();
animal.staticMethod();  // 调用Animal的静态方法，不是Dog的

// 私有方法不能被重写
private void privateMethod() {
    // 这个方法不支持多态
}

// 安全的向下转型
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;  // 安全转换
    dog.wagTail();
} else {
    System.out.println("不是Dog类型");
}

本章小结

多态是面向对象编程的三大特性之一，允许不同类的对象对同一消息做出不同的响应
多态的实现需要三个条件：继承关系、方法重写、向上转型
向上转型是自动的，向下转型需要强制转换并使用instanceof检查
动态绑定是多态的核心机制，在运行时决定调用哪个方法
instanceof关键字用于类型检查，确保向下转型的安全性
多态提高了代码的复用性、扩展性、维护性和灵活性
多态在图形界面、数据库操作、游戏开发等领域有广泛应用
静态方法、私有方法和构造方法不支持多态

导航链接上一章：Java继承章节测试下一章：抽象类和接口 JavaScript