Java多态 #

一、多态概述 #

多态是面向对象三大特性之一，指同一操作作用于不同对象，产生不同的执行结果。

1.1 多态的好处 #

提高代码灵活性
降低耦合度
实现接口与实现分离

1.2 多态实现条件 #

继承关系
方法重写
父类引用指向子类对象

二、多态基础 #

2.1 基本示例 #

java

public class Animal {
    public void eat() {
        System.out.println("动物在吃东西");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }
}

public class Cat extends Animal {
    @Override
    public void eat() {
        System.out.println("猫在吃鱼");
    }
}

// 多态
Animal a1 = new Dog();  // 父类引用指向子类对象
Animal a2 = new Cat();

a1.eat();  // 狗在吃骨头
a2.eat();  // 猫在吃鱼

2.2 方法调用 #

java

Animal animal = new Dog();

// 编译时：检查Animal类是否有eat方法
// 运行时：调用Dog类的eat方法（动态绑定）
animal.eat();  // 狗在吃骨头

三、向上转型 #

3.1 概念 #

向上转型：子类对象赋给父类引用。

java

Animal animal = new Dog();  // 向上转型

3.2 特点 #

java

public class Animal {
    public void eat() {
        System.out.println("动物在吃东西");
    }
}

public class Dog extends Animal {
    @Override
    public void eat() {
        System.out.println("狗在吃骨头");
    }
    
    public void bark() {
        System.out.println("狗在叫");
    }
}

Animal animal = new Dog();
animal.eat();    // 正确：调用重写的方法
// animal.bark(); // 错误：父类没有此方法

3.3 应用场景 #

java

public void feed(Animal animal) {
    animal.eat();  // 多态调用
}

feed(new Dog());  // 狗在吃骨头
feed(new Cat());  // 猫在吃鱼

四、向下转型 #

4.1 概念 #

向下转型：父类引用转回子类引用。

java

Animal animal = new Dog();
Dog dog = (Dog) animal;  // 向下转型
dog.bark();  // 正确

4.2 类型检查 #

java

Animal animal = new Dog();

// 错误：ClassCastException
// Cat cat = (Cat) animal;

// 正确：先检查类型
if (animal instanceof Dog) {
    Dog dog = (Dog) animal;
    dog.bark();
}

if (animal instanceof Cat) {
    Cat cat = (Cat) animal;
    cat.meow();
}

4.3 instanceof模式匹配（Java 16+） #

java

Animal animal = new Dog();

// Java 16+ 简化写法
if (animal instanceof Dog dog) {
    dog.bark();
}

if (animal instanceof Cat cat) {
    cat.meow();
}

五、动态绑定 #

5.1 方法绑定 #

java

public class Parent {
    public void method() {
        System.out.println("父类方法");
    }
}

public class Child extends Parent {
    @Override
    public void method() {
        System.out.println("子类方法");
    }
}

Parent p = new Child();
p.method();  // 子类方法（运行时绑定）

5.2 成员变量不绑定 #

java

public class Parent {
    public String name = "父类";
}

public class Child extends Parent {
    public String name = "子类";
}

Parent p = new Child();
System.out.println(p.name);  // 父类（变量不动态绑定）

Child c = new Child();
System.out.println(c.name);  // 子类

六、多态应用 #

6.1 参数多态 #

java

public class ShapeCalculator {
    public double calculateArea(Shape shape) {
        return shape.getArea();
    }
}

// 使用
ShapeCalculator calc = new ShapeCalculator();
calc.calculateArea(new Circle(5));
calc.calculateArea(new Rectangle(4, 6));

6.2 集合多态 #

java

List<Animal> animals = new ArrayList<>();
animals.add(new Dog());
animals.add(new Cat());

for (Animal animal : animals) {
    animal.eat();  // 多态调用
}

6.3 返回值多态 #

java

public class AnimalFactory {
    public static Animal createAnimal(String type) {
        switch (type) {
            case "dog":
                return new Dog();
            case "cat":
                return new Cat();
            default:
                throw new IllegalArgumentException("未知类型");
        }
    }
}

Animal animal = AnimalFactory.createAnimal("dog");
animal.eat();

七、多态示例 #

7.1 支付系统 #

java

public abstract class Payment {
    protected double amount;
    
    public Payment(double amount) {
        this.amount = amount;
    }
    
    public abstract void pay();
}

public class CreditCardPayment extends Payment {
    private String cardNumber;
    
    public CreditCardPayment(double amount, String cardNumber) {
        super(amount);
        this.cardNumber = cardNumber;
    }
    
    @Override
    public void pay() {
        System.out.println("信用卡支付: " + amount + "元");
    }
}

public class WechatPayment extends Payment {
    public WechatPayment(double amount) {
        super(amount);
    }
    
    @Override
    public void pay() {
        System.out.println("微信支付: " + amount + "元");
    }
}

// 使用
Payment payment1 = new CreditCardPayment(100, "1234567890");
Payment payment2 = new WechatPayment(50);

payment1.pay();  // 信用卡支付: 100.0元
payment2.pay();  // 微信支付: 50.0元

7.2 图形绘制 #

java

public abstract class Shape {
    public abstract void draw();
}

public class Circle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

public class Rectangle extends Shape {
    @Override
    public void draw() {
        System.out.println("绘制矩形");
    }
}

public class Canvas {
    public void drawShape(Shape shape) {
        shape.draw();
    }
    
    public void drawShapes(List<Shape> shapes) {
        for (Shape shape : shapes) {
            shape.draw();
        }
    }
}

八、总结 #

概念	说明
向上转型	子类引用赋给父类变量
向下转型	父类引用转为子类引用
动态绑定	运行时确定调用哪个方法
instanceof	检查对象类型

多态要点：

父类引用指向子类对象
方法动态绑定，变量不绑定
向下转型前用instanceof检查
多态提高代码灵活性和扩展性