Java多态概念、实现机制与实践应用详解-QQ沐编程

一、多态：面向对象编程的灵魂

1.1 什么是多态？

多态（Polymorphism）是面向对象编程的三大核心特性之一，源自希腊语”poly”（多）和”morph”（形态），意为”多种形态”。在Java中，多态允许不同类的对象对同一消息作出响应，但具体实现方式各异。

核心定义：父类引用指向子类对象，且引用在运行时能够根据实际对象类型调用相应的方法。

1.2 多态的分类

编译时多态（静态多态）

方法重载（Overloading）：同一类中方法名相同但参数列表不同
实现方式：编译器在编译时根据方法签名确定调用哪个方法

运行时多态（动态多态）

方法重写（Overriding）：子类重新定义父类中的方法
实现方式：JVM在运行时根据对象的实际类型确定调用哪个方法

// 编译时多态示例：方法重载
class Calculator {
    // 方法重载：同名方法，参数不同
    public int add(int a, int b) {
        return a + b;
    }

    public double add(double a, double b) {
        return a + b;
    }

    public int add(int a, int b, int c) {
        return a + b + c;
    }
}

// 运行时多态示例：方法重写
class Animal {
    public void makeSound() {
        System.out.println("Animal makes sound");
    }
}

class Dog extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Dog barks");
    }
}

class Cat extends Animal {
    @Override
    public void makeSound() {
        System.out.println("Cat meows");
    }
}

二、多态的实现机制深度解析

2.1 方法重载的实现原理

方法重载在编译阶段通过静态分派实现，编译器根据方法调用时传递的静态类型和参数列表确定具体调用哪个方法。

class OverloadDemo {
    // 重载方法的选择基于参数类型和数量
    public void process(String str) {
        System.out.println("Processing String: " + str);
    }

    public void process(int num) {
        System.out.println("Processing int: " + num);
    }

    public void process(String str, int num) {
        System.out.println("Processing String and int: " + str + ", " + num);
    }

    public static void main(String[] args) {
        OverloadDemo demo = new OverloadDemo();
        demo.process("Hello");      // 调用process(String)
        demo.process(100);          // 调用process(int)
        demo.process("Test", 50);   // 调用process(String, int)
    }
}

2.2 方法重写的实现原理

方法重写通过动态分派实现，JVM在运行时根据对象的实际类型（而不是引用类型）确定调用哪个方法。

JVM底层实现机制

方法表（Method Table）：每个类都有一个方法表，存储该类所有方法的入口地址
虚方法（Virtual Method）：非private、非final、非static的方法都是虚方法
invokevirtual指令：JVM执行方法调用时使用的字节码指令

class DynamicDispatchExample {
    static abstract class Human {
        protected abstract void sayHello();
    }

    static class Man extends Human {
        @Override
        protected void sayHello() {
            System.out.println("Man says hello");
        }
    }

    static class Woman extends Human {
        @Override
        protected void sayHello() {
            System.out.println("Woman says hello");
        }
    }

    public static void main(String[] args) {
        Human man = new Man();
        Human woman = new Woman();

        // 运行时根据实际类型确定调用哪个方法
        man.sayHello();     // 输出: Man says hello
        woman.sayHello();   // 输出: Woman says hello

        // 以下代码展示动态分派的本质
        Human[] humans = new Human[] {new Man(), new Woman(), new Man()};
        for (Human human : humans) {
            human.sayHello();  // 运行时动态决定调用哪个实现
        }
    }
}

2.3 方法分派机制对比

特性	静态分派（重载）	动态分派（重写）
决定时机	编译时	运行时
依据	参数类型和数量	对象实际类型
JVM指令	invokevirtual/invokestatic	invokevirtual
性能	较高（编译时确定）	稍低（运行时查找）
典型应用	方法重载	方法重写、接口实现

三、多态的核心实现方式

3.1 继承与多态

继承是实现多态的基础，子类可以重写父类方法，父类引用可以指向子类对象。

class Shape {
    public void draw() {
        System.out.println("Drawing a shape");
    }

    public double getArea() {
        return 0.0;
    }
}

class Circle extends Shape {
    private double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a circle with radius " + radius);
    }

    @Override
    public double getArea() {
        return Math.PI * radius * radius;
    }
}

class Rectangle extends Shape {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    @Override
    public void draw() {
        System.out.println("Drawing a rectangle " + width + "x" + height);
    }

    @Override
    public double getArea() {
        return width * height;
    }
}

class PolymorphismDemo {
    public static void main(String[] args) {
        // 父类引用指向子类对象
        Shape shape1 = new Circle(5.0);
        Shape shape2 = new Rectangle(4.0, 6.0);

        // 运行时多态：调用实际对象的方法
        shape1.draw();      // Drawing a circle with radius 5.0
        shape2.draw();      // Drawing a rectangle 4.0x6.0

        System.out.println("Circle area: " + shape1.getArea());     // 78.5398...
        System.out.println("Rectangle area: " + shape2.getArea());  // 24.0

        // 多态在集合中的应用
        List<Shape> shapes = new ArrayList<>();
        shapes.add(new Circle(3.0));
        shapes.add(new Rectangle(2.0, 5.0));
        shapes.add(new Circle(7.0));

        double totalArea = 0;
        for (Shape shape : shapes) {
            totalArea += shape.getArea();  // 统一接口，不同实现
        }
        System.out.println("Total area: " + totalArea);
    }
}

3.2 接口与多态

接口提供更灵活的多态实现方式，一个类可以实现多个接口。

// 定义接口
interface Flyable {
    void fly();

    // Java 8+ 默认方法
    default void takeOff() {
        System.out.println("Taking off...");
    }

    // Java 8+ 静态方法
    static int getMaxAltitude() {
        return 10000;
    }
}

interface Swimmable {
    void swim();
}

// 实现多个接口
class Duck implements Flyable, Swimmable {
    @Override
    public void fly() {
        System.out.println("Duck is flying");
    }

    @Override
    public void swim() {
        System.out.println("Duck is swimming");
    }
}

class Airplane implements Flyable {
    @Override
    public void fly() {
        System.out.println("Airplane is flying");
    }
}

class InterfacePolymorphismDemo {
    public static void main(String[] args) {
        // 接口引用指向实现类对象
        Flyable flyer1 = new Duck();
        Flyable flyer2 = new Airplane();
        Swimmable swimmer = new Duck();

        // 同一接口，不同实现
        flyer1.fly();  // Duck is flying
        flyer2.fly();  // Airplane is flying
        flyer1.takeOff();  // 调用默认方法

        // Duck对象的多种形态
        Duck duck = new Duck();
        processFlyable(duck);
        processSwimmable(duck);

        // 使用接口作为方法参数
        performFlight(flyer1);
        performFlight(flyer2);
    }

    public static void processFlyable(Flyable flyable) {
        flyable.fly();
    }

    public static void processSwimmable(Swimmable swimmable) {
        swimmable.swim();
    }

    public static void performFlight(Flyable flyer) {
        System.out.println("Preparing for flight...");
        flyer.takeOff();
        flyer.fly();
        System.out.println("Flight completed.");
    }
}

3.3 抽象类与多态

抽象类介于具体类和接口之间，可以提供部分实现。

abstract class Employee {
    private String name;
    private int id;

    public Employee(String name, int id) {
        this.name = name;
        this.id = id;
    }

    // 抽象方法，子类必须实现
    public abstract double calculateSalary();

    // 具体方法，子类可以继承或重写
    public String getDetails() {
        return "ID: " + id + ", Name: " + name;
    }

    // 模板方法模式：定义算法骨架
    public final void processSalary() {
        System.out.println("Processing salary for: " + name);
        double salary = calculateSalary();
        System.out.println("Calculated salary: " + salary);
        applyDeductions(salary);
        System.out.println("Salary processed successfully.");
    }

    protected void applyDeductions(double salary) {
        // 默认实现，子类可以重写
        double tax = salary * 0.1;
        System.out.println("Tax deducted: " + tax);
    }
}

class FullTimeEmployee extends Employee {
    private double monthlySalary;

    public FullTimeEmployee(String name, int id, double monthlySalary) {
        super(name, id);
        this.monthlySalary = monthlySalary;
    }

    @Override
    public double calculateSalary() {
        return monthlySalary;
    }
}

class PartTimeEmployee extends Employee {
    private double hourlyRate;
    private int hoursWorked;

    public PartTimeEmployee(String name, int id, double hourlyRate, int hoursWorked) {
        super(name, id);
        this.hourlyRate = hourlyRate;
        this.hoursWorked = hoursWorked;
    }

    @Override
    public double calculateSalary() {
        return hourlyRate * hoursWorked;
    }

    @Override
    protected void applyDeductions(double salary) {
        // 兼职员工税收不同
        double tax = salary * 0.05;
        System.out.println("Part-time tax deducted: " + tax);
    }
}

class Contractor extends Employee {
    private double contractAmount;

    public Contractor(String name, int id, double contractAmount) {
        super(name, id);
        this.contractAmount = contractAmount;
    }

    @Override
    public double calculateSalary() {
        return contractAmount;
    }

    @Override
    public String getDetails() {
        return super.getDetails() + " (Contractor)";
    }
}

class AbstractClassPolymorphismDemo {
    public static void main(String[] args) {
        Employee[] employees = {
            new FullTimeEmployee("Alice", 101, 5000),
            new PartTimeEmployee("Bob", 102, 20, 80),
            new Contractor("Charlie", 103, 10000)
        };

        // 多态处理不同类型的员工
        for (Employee emp : employees) {
            System.out.println("\n" + emp.getDetails());
            emp.processSalary();  // 模板方法，具体实现由子类提供
        }

        // 计算总薪资
        double totalSalary = 0;
        for (Employee emp : employees) {
            totalSalary += emp.calculateSalary();
        }
        System.out.println("\nTotal monthly salary: " + totalSalary);
    }
}

四、多态的高级特性与实践

4.1 协变返回类型

Java 5+支持协变返回类型，允许子类重写方法时返回更具体的类型。

class Vehicle {
    public Vehicle getInstance() {
        return new Vehicle();
    }
}

class Car extends Vehicle {
    // 协变返回类型：返回更具体的Car类型
    @Override
    public Car getInstance() {
        return new Car();
    }

    public void drive() {
        System.out.println("Car is driving");
    }
}

class CovariantReturnDemo {
    public static void main(String[] args) {
        Vehicle vehicle = new Car();
        // 虽然引用类型是Vehicle，但返回的是Car实例
        Vehicle instance = vehicle.getInstance();

        if (instance instanceof Car) {
            Car car = (Car) instance;  // 需要强制转换
            car.drive();
        }

        // 使用Car引用可以直接调用Car的方法
        Car carRef = new Car();
        Car carInstance = carRef.getInstance();  // 不需要强制转换
        carInstance.drive();
    }
}

4.2 访问修饰符与多态

子类重写方法时，访问权限不能比父类更严格。

class AccessModifierBase {
    protected void protectedMethod() {
        System.out.println("Base protected method");
    }

    public void publicMethod() {
        System.out.println("Base public method");
    }
}

class AccessModifierDerived extends AccessModifierBase {
    // 正确：可以扩大访问权限（protected -> public）
    @Override
    public void protectedMethod() {
        System.out.println("Derived public method (overridden from protected)");
    }

    // 错误：不能缩小访问权限
    // @Override
    // protected void publicMethod() {  // 编译错误
    //     System.out.println("Derived protected method");
    // }
}

4.3 静态方法与多态

静态方法不支持多态，它们与类绑定而非对象。

class StaticMethodBase {
    public static void staticMethod() {
        System.out.println("Base static method");
    }

    public void instanceMethod() {
        System.out.println("Base instance method");
    }
}

class StaticMethodDerived extends StaticMethodBase {
    // 这不是重写，而是隐藏（hide）
    public static void staticMethod() {
        System.out.println("Derived static method");
    }

    @Override
    public void instanceMethod() {
        System.out.println("Derived instance method");
    }
}

class StaticMethodPolymorphismDemo {
    public static void main(String[] args) {
        StaticMethodBase baseRef = new StaticMethodDerived();

        // 静态方法：根据引用类型调用
        baseRef.staticMethod();  // 输出: Base static method

        // 实例方法：根据实际对象类型调用
        baseRef.instanceMethod();  // 输出: Derived instance method

        // 正确调用静态方法的方式
        StaticMethodBase.staticMethod();  // Base static method
        StaticMethodDerived.staticMethod();  // Derived static method
    }
}

五、多态在设计模式中的应用

5.1 策略模式

策略模式使用多态实现算法的动态替换。

// 策略接口
interface PaymentStrategy {
    void pay(double amount);
    String getStrategyName();
}

// 具体策略实现
class CreditCardPayment implements PaymentStrategy {
    private String cardNumber;

    public CreditCardPayment(String cardNumber) {
        this.cardNumber = cardNumber;
    }

    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " using Credit Card ending with " 
                         + cardNumber.substring(cardNumber.length() - 4));
    }

    @Override
    public String getStrategyName() {
        return "Credit Card";
    }
}

class PayPalPayment implements PaymentStrategy {
    private String email;

    public PayPalPayment(String email) {
        this.email = email;
    }

    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " using PayPal: " + email);
    }

    @Override
    public String getStrategyName() {
        return "PayPal";
    }
}

class CryptoPayment implements PaymentStrategy {
    private String walletAddress;

    public CryptoPayment(String walletAddress) {
        this.walletAddress = walletAddress;
    }

    @Override
    public void pay(double amount) {
        System.out.println("Paid $" + amount + " using Crypto to address: " 
                         + walletAddress.substring(0, 8) + "...");
    }

    @Override
    public String getStrategyName() {
        return "Cryptocurrency";
    }
}

// 上下文类
class ShoppingCart {
    private PaymentStrategy paymentStrategy;
    private List<Double> items = new ArrayList<>();

    public void addItem(double price) {
        items.add(price);
    }

    public void setPaymentStrategy(PaymentStrategy strategy) {
        this.paymentStrategy = strategy;
        System.out.println("Payment method changed to: " + strategy.getStrategyName());
    }

    public void checkout() {
        if (paymentStrategy == null) {
            System.out.println("Please select a payment method first.");
            return;
        }

        double total = items.stream().mapToDouble(Double::doubleValue).sum();
        System.out.println("Checking out " + items.size() + " items. Total: $" + total);
        paymentStrategy.pay(total);
        items.clear();
    }
}

class StrategyPatternDemo {
    public static void main(String[] args) {
        ShoppingCart cart = new ShoppingCart();
        cart.addItem(19.99);
        cart.addItem(29.99);
        cart.addItem(9.99);

        // 动态切换支付策略
        cart.setPaymentStrategy(new CreditCardPayment("1234-5678-9012-3456"));
        cart.checkout();

        cart.addItem(49.99);
        cart.setPaymentStrategy(new PayPalPayment("user@example.com"));
        cart.checkout();

        cart.addItem(99.99);
        cart.setPaymentStrategy(new CryptoPayment("1A2b3C4d5E6f7G8h9I0j"));
        cart.checkout();
    }
}

5.2 工厂模式

工厂模式利用多态创建对象，隐藏具体实现。

// 产品接口
interface Logger {
    void log(String message);
    void error(String message);
    void warn(String message);
}

// 具体产品
class FileLogger implements Logger {
    private String filename;

    public FileLogger(String filename) {
        this.filename = filename;
        System.out.println("FileLogger initialized: " + filename);
    }

    @Override
    public void log(String message) {
        System.out.println("[LOG to " + filename + "]: " + message);
    }

    @Override
    public void error(String message) {
        System.out.println("[ERROR to " + filename + "]: " + message);
    }

    @Override
    public void warn(String message) {
        System.out.println("[WARN to " + filename + "]: " + message);
    }
}

class ConsoleLogger implements Logger {
    @Override
    public void log(String message) {
        System.out.println("[LOG]: " + message);
    }

    @Override
    public void error(String message) {
        System.err.println("[ERROR]: " + message);
    }

    @Override
    public void warn(String message) {
        System.out.println("[WARN]: " + message);
    }
}

class DatabaseLogger implements Logger {
    private String connectionString;

    public DatabaseLogger(String connectionString) {
        this.connectionString = connectionString;
        System.out.println("DatabaseLogger connected to: " + connectionString);
    }

    @Override
    public void log(String message) {
        // 模拟数据库插入
        System.out.println("[LOG to DB]: INSERT INTO logs VALUES('" + message + "')");
    }

    @Override
    public void error(String message) {
        System.out.println("[ERROR to DB]: INSERT INTO error_logs VALUES('" + message + "')");
    }

    @Override
    public void warn(String message) {
        System.out.println("[WARN to DB]: INSERT INTO warn_logs VALUES('" + message + "')");
    }
}

// 工厂类
class LoggerFactory {
    public enum LoggerType {
        FILE, CONSOLE, DATABASE
    }

    public static Logger createLogger(LoggerType type, String... params) {
        switch (type) {
            case FILE:
                return new FileLogger(params.length > 0 ? params[0] : "app.log");
            case DATABASE:
                return new DatabaseLogger(params.length > 0 ? params[0] : "jdbc:mysql://localhost/logs");
            case CONSOLE:
            default:
                return new ConsoleLogger();
        }
    }
}

class FactoryPatternDemo {
    public static void main(String[] args) {
        // 使用工厂创建不同的Logger，客户端代码只依赖Logger接口
        Logger consoleLogger = LoggerFactory.createLogger(LoggerType.CONSOLE);
        Logger fileLogger = LoggerFactory.createLogger(LoggerType.FILE, "application.log");
        Logger dbLogger = LoggerFactory.createLogger(LoggerType.DATABASE, "jdbc:mysql://prod/logs");

        // 多态：统一接口，不同实现
        Logger[] loggers = {consoleLogger, fileLogger, dbLogger};

        for (Logger logger : loggers) {
            logger.log("Application started");
            logger.warn("Memory usage high");
            logger.error("Failed to connect to database");
            System.out.println("---");
        }

        // 动态切换日志实现
        Logger currentLogger = consoleLogger;
        performBusinessLogic(currentLogger);

        // 切换到文件日志
        currentLogger = fileLogger;
        performBusinessLogic(currentLogger);
    }

    private static void performBusinessLogic(Logger logger) {
        logger.log("Starting business logic");
        // 模拟业务逻辑
        for (int i = 0; i < 3; i++) {
            logger.log("Processing item " + i);
        }
        logger.log("Business logic completed");
    }
}

5.3 观察者模式

观察者模式使用多态实现对象间的松耦合通信。

import java.util.*;

// 观察者接口
interface Observer {
    void update(String eventType, String data);
    String getName();
}

// 主题接口
interface Subject {
    void registerObserver(Observer observer);
    void removeObserver(Observer observer);
    void notifyObservers(String eventType, String data);
}

// 具体主题
class NewsAgency implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String latestNews;

    @Override
    public void registerObserver(Observer observer) {
        observers.add(observer);
        System.out.println(observer.getName() + " subscribed to news");
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
        System.out.println(observer.getName() + " unsubscribed from news");
    }

    @Override
    public void notifyObservers(String eventType, String data) {
        for (Observer observer : observers) {
            observer.update(eventType, data);
        }
    }

    public void publishNews(String news) {
        this.latestNews = news;
        System.out.println("\n=== News Agency Publishing: " + news + " ===");
        notifyObservers("NEWS_PUBLISHED", news);
    }

    public void publishBreakingNews(String news) {
        this.latestNews = news;
        System.out.println("\n!!! BREAKING NEWS: " + news + " !!!");
        notifyObservers("BREAKING_NEWS", news);
    }

    public void publishCorrection(String correction) {
        System.out.println("\n--- Correction: " + correction + " ---");
        notifyObservers("NEWS_CORRECTED", correction);
    }
}

// 具体观察者
class Newspaper implements Observer {
    private String name;
    private List<String> headlines = new ArrayList<>();

    public Newspaper(String name) {
        this.name = name;
    }

    @Override
    public void update(String eventType, String data) {
        switch (eventType) {
            case "NEWS_PUBLISHED":
                headlines.add(data);
                System.out.println(name + " newspaper added headline: " + data);
                break;
            case "BREAKING_NEWS":
                headlines.add(0, "[BREAKING] " + data);  // 置顶
                System.out.println(name + " newspaper received BREAKING NEWS: " + data);
                break;
            case "NEWS_CORRECTED":
                System.out.println(name + " newspaper issued correction: " + data);
                break;
        }
    }

    @Override
    public String getName() {
        return name;
    }

    public void printHeadlines() {
        System.out.println("\n=== " + name + " Headlines ===");
        for (String headline : headlines) {
            System.out.println(" - " + headline);
        }
    }
}

class TVChannel implements Observer {
    private String channelName;
    private String currentNews;

    public TVChannel(String channelName) {
        this.channelName = channelName;
    }

    @Override
    public void update(String eventType, String data) {
        switch (eventType) {
            case "NEWS_PUBLISHED":
                currentNews = data;
                System.out.println(channelName + " TV now showing: " + data);
                break;
            case "BREAKING_NEWS":
                currentNews = data;
                System.out.println(channelName + " TV INTERRUPTION: " + data);
                break;
            case "NEWS_CORRECTED":
                System.out.println(channelName + " TV correction announcement: " + data);
                break;
        }
    }

    @Override
    public String getName() {
        return channelName;
    }
}

class MobileApp implements Observer {
    private String appName;
    private List<String> notifications = new ArrayList<>();

    public MobileApp(String appName) {
        this.appName = appName;
    }

    @Override
    public void update(String eventType, String data) {
        String notification = "[" + eventType + "] " + data;
        notifications.add(notification);
        System.out.println(appName + " app sent push notification: " + notification);
    }

    @Override
    public String getName() {
        return appName;
    }

    public void showNotifications() {
        System.out.println("\n=== " + appName + " Notifications ===");
        for (String notification : notifications) {
            System.out.println(" • " + notification);
        }
    }
}

class ObserverPatternDemo {
    public static void main(String[] args) {
        // 创建主题
        NewsAgency agency = new NewsAgency();

        // 创建观察者
        Observer times = new Newspaper("The Times");
        Observer post = new Newspaper("The Post");
        Observer cnn = new TVChannel("CNN");
        Observer bbc = new TVChannel("BBC");
        Observer newsApp = new MobileApp("NewsAlert");

        // 注册观察者
        agency.registerObserver(times);
        agency.registerObserver(post);
        agency.registerObserver(cnn);
        agency.registerObserver(newsApp);

        // 发布新闻（多态：不同观察者以不同方式处理同一事件）
        agency.publishNews("New economic policy announced");
        agency.publishBreakingNews("Major earthquake hits coastal region");
        agency.publishNews("Sports team wins championship");

        // 动态添加观察者
        agency.registerObserver(bbc);
        agency.publishNews("Technology company launches new product");

        // 移除观察者
        agency.removeObserver(post);
        agency.publishCorrection("Previous news about earthquake was exaggerated");

        // 查看各个观察者的状态
        ((Newspaper) times).printHeadlines();
        ((MobileApp) newsApp).showNotifications();
    }
}

六、多态的最佳实践与注意事项

6.1 多态设计原则

里氏替换原则（LSP）：子类对象必须能够替换父类对象而不影响程序正确性
依赖倒置原则（DIP）：高层模块不应依赖低层模块，二者都应依赖抽象
开闭原则（OCP）：软件实体应对扩展开放，对修改关闭

6.2 多态使用的最佳实践

// 1. 优先使用接口编程
interface DataProcessor {
    void processData(String data);
    boolean validateData(String data);
}

// 2. 使用工厂方法创建对象
class ProcessorFactory {
    public static DataProcessor createProcessor(String type) {
        switch (type.toUpperCase()) {
            case "XML": return new XmlProcessor();
            case "JSON": return new JsonProcessor();
            case "CSV": return new CsvProcessor();
            default: throw new IllegalArgumentException("Unknown processor type: " + type);
        }
    }
}

// 3. 使用依赖注入
class DataService {
    private DataProcessor processor;

    // 构造函数注入
    public DataService(DataProcessor processor) {
        this.processor = processor;
    }

    // Setter注入
    public void setProcessor(DataProcessor processor) {
        this.processor = processor;
    }

    public void handleData(String data) {
        if (processor.validateData(data)) {
            processor.processData(data);
        }
    }
}

// 4. 避免使用instanceof和强制类型转换
class GoodPolymorphismExample {
    interface Animal {
        void makeSound();
        String getType();
    }

    // 正确做法：使用多态而非类型检查
    public static void processAnimals(List<Animal> animals) {
        for (Animal animal : animals) {
            // 直接调用多态方法
            animal.makeSound();
            System.out.println("Animal type: " + animal.getType());
        }
    }
}

// 错误做法示例
class BadPolymorphismExample {
    class Animal {
        void makeSound() {}
    }

    class Dog extends Animal {
        void bark() {}
    }

    class Cat extends Animal {
        void meow() {}
    }

    public void processAnimalBad(Animal animal) {
        // 避免这种代码！
        if (animal instanceof Dog) {
            ((Dog) animal).bark();
        } else if (animal instanceof Cat) {
            ((Cat) animal).meow();
        }
    }
}

6.3 性能考虑与优化

虚方法表查找：运行时多态需要查找方法表，有轻微性能开销
内联优化：JVM会对热点代码进行内联优化，部分消除多态开销
final方法：标记为final的方法不需要多态分派，性能更好
避免过度设计：在性能关键路径上谨慎使用多层继承

七、多态在实际项目中的应用场景

7.1 Web开发中的多态应用

// Spring风格的控制器示例
interface Controller {
    ResponseEntity<?> handleRequest(HttpRequest request);
}

class UserController implements Controller {
    @Override
    public ResponseEntity<?> handleRequest(HttpRequest request) {
        String path = request.getPath();

        switch (path) {
            case "/api/users":
                return getAllUsers();
            case "/api/users/{id}":
                return getUserById(request.getPathParameter("id"));
            default:
                return ResponseEntity.notFound().build();
        }
    }

    private ResponseEntity<List<User>> getAllUsers() {
        // 业务逻辑
        return ResponseEntity.ok(Collections.emptyList());
    }

    private ResponseEntity<User> getUserById(String id) {
        // 业务逻辑
        return ResponseEntity.ok(new User(id, "John Doe"));
    }
}

class ProductController implements Controller {
    @Override
    public ResponseEntity<?> handleRequest(HttpRequest request) {
        // 产品相关的处理逻辑
        return ResponseEntity.ok("Product data");
    }
}

// 路由分发器
class Router {
    private Map<String, Controller> routes = new HashMap<>();

    public void registerRoute(String path, Controller controller) {
        routes.put(path, controller);
    }

    public ResponseEntity<?> dispatch(HttpRequest request) {
        String path = request.getPath();
        for (Map.Entry<String, Controller> entry : routes.entrySet()) {
            if (path.startsWith(entry.getKey())) {
                return entry.getValue().handleRequest(request);
            }
        }
        return ResponseEntity.notFound().build();
    }
}

7.2 插件架构中的多态

// 插件接口
interface Plugin {
    String getName();
    String getVersion();
    void initialize();
    void execute(Context context);
    void cleanup();
}

// 插件管理器
class PluginManager {
    private List<Plugin> plugins = new ArrayList<>();

    public void loadPlugin(Plugin plugin) {
        plugin.initialize();
        plugins.add(plugin);
        System.out.println("Loaded plugin: " + plugin.getName() + " v" + plugin.getVersion());
    }

    public void executeAll(Context context) {
        for (Plugin plugin : plugins) {
            System.out.println("\nExecuting plugin: " + plugin.getName());
            plugin.execute(context);
        }
    }

    public void unloadAll() {
        for (Plugin plugin : plugins) {
            plugin.cleanup();
            System.out.println("Unloaded plugin: " + plugin.getName());
        }
        plugins.clear();
    }

    public <T extends Plugin> T getPlugin(Class<T> pluginClass) {
        for (Plugin plugin : plugins) {
            if (pluginClass.isInstance(plugin)) {
                return pluginClass.cast(plugin);
            }
        }
        return null;
    }
}

// 具体插件实现
class AnalyticsPlugin implements Plugin {
    @Override
    public String getName() {
        return "Analytics";
    }

    @Override
    public String getVersion() {
        return "1.0.0";
    }

    @Override
    public void initialize() {
        System.out.println("Initializing analytics plugin...");
    }

    @Override
    public void execute(Context context) {
        System.out.println("Collecting analytics data...");
        // 收集和分析数据
    }

    @Override
    public void cleanup() {
        System.out.println("Cleaning up analytics resources...");
    }

    // 插件特有方法
    public void generateReport() {
        System.out.println("Generating analytics report...");
    }
}

class SecurityPlugin implements Plugin {
    @Override
    public String getName() {
        return "Security";
    }

    @Override
    public String getVersion() {
        return "2.1.0";
    }

    @Override
    public void initialize() {
        System.out.println("Initializing security plugin...");
    }

    @Override
    public void execute(Context context) {
        System.out.println("Performing security checks...");
        // 安全检查逻辑
    }

    @Override
    public void cleanup() {
        System.out.println("Cleaning up security resources...");
    }

    public void scanForThreats() {
        System.out.println("Scanning for security threats...");
    }
}

// 上下文类
class Context {
    private Map<String, Object> data = new HashMap<>();

    public void put(String key, Object value) {
        data.put(key, value);
    }

    public Object get(String key) {
        return data.get(key);
    }
}