Java多态机制深度解析：从原理到实践应用

1. Java多态的本质与实现原理

多态是面向对象编程的三大特性之一，也是Java开发者面试必问的核心知识点。我在实际开发中发现，很多初学者对多态的理解停留在"父类引用指向子类对象"的表面认知，而忽视了其底层实现机制和设计价值。

Java多态的实现主要依赖于JVM的方法调用机制。当调用一个实例方法时，JVM会根据对象的实际类型（而非引用类型）来决定调用哪个方法实现。这个动态绑定过程是通过虚方法表（vtable）实现的：

java复制class Animal {
    void speak() { System.out.println("Animal sound"); }
}

class Dog extends Animal {
    @Override
    void speak() { System.out.println("Bark"); }
}

public class Main {
    public static void main(String[] args) {
        Animal myPet = new Dog();  // 多态引用
        myPet.speak();  // 输出"Bark"而非"Animal sound"
    }
}

关键点：编译时检查引用类型的方法是否存在，运行时根据实际对象类型调用具体实现

2. 多态的类型与使用场景

2.1 编译时多态（静态多态）

通过方法重载实现，在编译阶段就能确定具体调用哪个方法：

java复制class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; }
}

2.2 运行时多态（动态多态）

通过方法重写和继承体系实现，是面试中最常考察的类型：

java复制interface Payment {
    void pay(double amount);
}

class CreditCard implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paying $" + amount + " via Credit Card");
    }
}

class PayPal implements Payment {
    @Override
    public void pay(double amount) {
        System.out.println("Paying $" + amount + " via PayPal");
    }
}

实际应用场景：

• 支付系统多种支付方式切换
• 游戏开发中不同角色的行为差异
• 插件式架构的扩展实现

3. 多态的高级特性与陷阱

3.1 方法重写的限制条件

• 子类方法访问权限不能比父类更严格
• 返回类型在Java5+可以是父类方法返回类型的子类（协变返回）
• 抛出的异常类型不能比父类更宽泛

3.2 构造方法与多态

构造方法调用顺序：

1. 父类静态代码块
2. 子类静态代码块
3. 父类实例代码块
4. 父类构造方法
5. 子类实例代码块
6. 子类构造方法

警告：在构造方法中调用可重写方法是危险操作，因为此时子类可能尚未初始化

3.3 字段访问的特殊性

字段访问不具多态性，始终取决于引用类型：

java复制class Parent {
    String name = "Parent";
}

class Child extends Parent {
    String name = "Child";
}

Parent obj = new Child();
System.out.println(obj.name);  // 输出"Parent"

4. 多态在框架设计中的应用

4.1 Spring框架的依赖注入

通过接口声明依赖，运行时注入具体实现：

java复制@Service
public class OrderService {
    @Autowired
    private Payment payment;  // 可能是CreditCard或PayPal实现
}

4.2 Java集合框架的多态设计

java复制List<String> list = new ArrayList<>();  // 多态典型应用
list = new LinkedList<>();  // 实现可替换

4.3 模板方法模式

定义算法骨架，具体步骤由子类实现：

java复制abstract class Game {
    // 模板方法
    final void play() {
        initialize();
        startPlay();
        endPlay();
    }
    
    abstract void initialize();
    abstract void startPlay();
    abstract void endPlay();
}

5. 面试常见问题解析

5.1 经典八股文问题

1. 重载和重写的区别？

   • 重载：同类同名不同参，编译时绑定
   • 重写：父子类间同名同参，运行时绑定

2. 能否重写static/private/final方法？

   • static：隐藏而非重写
   • private：不可见无法重写
   • final：禁止重写

5.2 实际开发中的坑点记录

1. 使用多态集合时的类型擦除问题：

java复制List<Animal> animals = new ArrayList<Dog>();  // 编译错误
List<? extends Animal> animals = new ArrayList<Dog>();  // 正确

2. 性能考虑：

• 虚方法调用比静态方法调用稍慢
• 现代JVM通过内联缓存优化，热点代码性能差异可忽略

3. 设计建议：

• 优先使用接口定义类型
• 遵循里氏替换原则
• 避免在构造方法中调用可重写方法

6. 多态性能优化实践

6.1 JVM方法调用优化

• 内联缓存（Inline Cache）
• 虚方法表（vtable）查找优化
• 热点代码的即时编译（JIT）优化

6.2 设计模式中的性能权衡

1. 策略模式 vs 条件语句：

java复制// 条件语句版
double calculate(PaymentType type, double amount) {
    switch(type) {
        case CREDIT_CARD: return amount * 1.02;
        case PAYPAL: return amount * 1.01;
        default: throw new IllegalArgumentException();
    }
}

// 策略模式版
interface PaymentStrategy {
    double calculate(double amount);
}

class CreditCardStrategy implements PaymentStrategy {
    @Override
    public double calculate(double amount) {
        return amount * 1.02;
    }
}

策略模式更灵活但可能增加对象创建开销，应根据实际场景选择

6.3 内存占用分析

• 每个类维护一个虚方法表（约几十字节）
• 每个对象包含指向虚方法表的指针（通常4或8字节）
• 接口方法表（itable）带来的额外开销

7. 现代Java中的多态演进

7.1 默认方法带来的变化

Java8引入接口默认方法，使得接口也能提供方法实现：

java复制interface Logger {
    default void log(String message) {
        System.out.println("LOG: " + message);
    }
}

class FileLogger implements Logger {
    // 可选择重写或使用默认实现
}

7.2 密封类（Sealed Class）的约束

Java17引入密封类，可以精确控制哪些类能继承父类：

java复制public sealed class Shape 
    permits Circle, Square, Rectangle { ... }

7.3 记录类（Record）的多态特性

记录类隐式final，不支持继承，但可以实现接口：

java复制record Point(int x, int y) implements Drawable {
    @Override
    public void draw() { ... }
}

8. 多态在并发编程中的应用

8.1 线程安全的多态实现

1. 不可变对象模式：

java复制abstract class ImmutableShape {
    abstract double area();
}

final class Circle extends ImmutableShape {
    private final double radius;
    
    Circle(double r) { this.radius = r; }
    
    @Override
    double area() { return Math.PI * radius * radius; }
}

2. 同步控制策略：

java复制interface Counter {
    void increment();
    int get();
}

class SynchronizedCounter implements Counter {
    private int count = 0;
    
    @Override
    public synchronized void increment() { count++; }
    
    @Override
    public synchronized int get() { return count; }
}

class AtomicCounter implements Counter {
    private final AtomicInteger count = new AtomicInteger();
    
    @Override
    public void increment() { count.incrementAndGet(); }
    
    @Override
    public int get() { return count.get(); }
}

8.2 异步编程中的回调模式

java复制interface Callback {
    void onComplete(String result);
    void onError(Exception e);
}

class AsyncTask {
    void execute(Callback callback) {
        new Thread(() -> {
            try {
                // 模拟耗时操作
                Thread.sleep(1000);
                callback.onComplete("Done");
            } catch (Exception e) {
                callback.onError(e);
            }
        }).start();
    }
}

9. 多态与设计原则的关联

9.1 开闭原则（OCP）

通过多态实现扩展开放，修改封闭：

java复制abstract class ReportGenerator {
    public final void generateReport() {
        prepareData();
        formatReport();
        outputReport();
    }
    
    protected abstract void prepareData();
    protected abstract void formatReport();
    
    private void outputReport() {
        // 通用输出逻辑
    }
}

9.2 依赖倒置原则（DIP）

高层模块不应依赖低层模块，二者都应依赖抽象：

java复制// 不符合DIP
class OrderService {
    private MySQLDatabase db;
    
    public OrderService() {
        this.db = new MySQLDatabase();
    }
}

// 符合DIP
class OrderService {
    private Database db;
    
    public OrderService(Database db) {
        this.db = db;
    }
}

9.3 接口隔离原则（ISP）

客户端不应被迫依赖它不使用的接口：

java复制// 违反ISP
interface Worker {
    void work();
    void eat();
}

// 符合ISP
interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

10. 多态在测试中的应用

10.1 Mock对象的多态实现

java复制interface UserRepository {
    User findById(String id);
}

class RealUserRepository implements UserRepository {
    @Override
    public User findById(String id) {
        // 实际数据库查询
    }
}

class MockUserRepository implements UserRepository {
    @Override
    public User findById(String id) {
        return new User("test", "Test User");
    }
}

10.2 测试替身策略

1. Stub：提供预设响应
2. Mock：验证交互行为
3. Fake：简化功能实现
4. Spy：记录调用信息

java复制@Test
void testPayment() {
    Payment mockPayment = mock(Payment.class);
    when(mockPayment.pay(anyDouble())).thenReturn(true);
    
    OrderService service = new OrderService(mockPayment);
    assertTrue(service.processOrder(100.0));
    
    verify(mockPayment).pay(100.0);
}

11. 多态与泛型的结合

11.1 泛型中的类型边界

java复制class Sorter<T extends Comparable<T>> {
    void sort(List<T> items) {
        Collections.sort(items);
    }
}

11.2 通配符的多态应用

java复制// 生产者使用extends
void processList(List<? extends Number> numbers) {
    for (Number n : numbers) {
        System.out.println(n.doubleValue());
    }
}

// 消费者使用super
void addNumbers(List<? super Integer> list) {
    list.add(1);
    list.add(2);
}

11.3 类型擦除的应对策略

运行时类型信息丢失的解决方案：

1. 显式传递Class对象
2. 使用类型令牌模式
3. 通过反射获取实际类型

java复制class GenericType<T> {
    private final Class<T> type;
    
    public GenericType(Class<T> type) {
        this.type = type;
    }
    
    public Class<T> getType() {
        return type;
    }
}

12. 多态与函数式编程

12.1 Lambda表达式作为多态实现

java复制interface Condition {
    boolean test(Employee emp);
}

List<Employee> filter(List<Employee> employees, Condition cond) {
    List<Employee> result = new ArrayList<>();
    for (Employee emp : employees) {
        if (cond.test(emp)) {
            result.add(emp);
        }
    }
    return result;
}

// 使用Lambda
filter(employees, emp -> emp.getAge() > 30);

12.2 方法引用简化多态代码

java复制// 替代匿名类
Collections.sort(employees, Comparator.comparing(Employee::getName));

// 替代Lambda
employees.forEach(System.out::println);

12.3 函数式接口的多态组合

java复制Function<String, Integer> parser = Integer::parseInt;
Function<Integer, String> formatter = Object::toString;

Function<String, String> pipeline = parser.andThen(formatter);
String result = pipeline.apply("123");  // "123"

13. 多态在反射中的应用

13.1 动态方法调用

java复制Method method = obj.getClass().getMethod("methodName", paramTypes);
Object result = method.invoke(obj, args);

13.2 代理模式实现

java复制interface Service {
    void serve();
}

class RealService implements Service {
    @Override
    public void serve() {
        System.out.println("Real service");
    }
}

class ServiceProxy implements InvocationHandler {
    private Object target;
    
    public ServiceProxy(Object target) {
        this.target = target;
    }
    
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before service");
        Object result = method.invoke(target, args);
        System.out.println("After service");
        return result;
    }
}

Service proxy = (Service) Proxy.newProxyInstance(
    Service.class.getClassLoader(),
    new Class[]{Service.class},
    new ServiceProxy(new RealService())
);
proxy.serve();

14. 多态与注解处理

14.1 注解处理器中的多态

java复制@SupportedAnnotationTypes("com.example.MyAnnotation")
public class MyProcessor extends AbstractProcessor {
    @Override
    public boolean process(Set<? extends TypeElement> annotations, 
                          RoundEnvironment roundEnv) {
        for (Element element : roundEnv.getElementsWithAnnotation(MyAnnotation.class)) {
            // 处理注解元素
        }
        return true;
    }
}

14.2 运行时注解处理

java复制class AnnotationProcessor {
    static void processAnnotations(Object obj) {
        Class<?> clazz = obj.getClass();
        for (Method method : clazz.getDeclaredMethods()) {
            if (method.isAnnotationPresent(MyAnnotation.class)) {
                MyAnnotation anno = method.getAnnotation(MyAnnotation.class);
                // 根据注解内容执行操作
            }
        }
    }
}

15. 多态在序列化中的应用

15.1 多态对象的序列化

java复制class Animal implements Serializable {
    private String name;
    // getters/setters
}

class Dog extends Animal {
    private String breed;
    // getters/setters
}

// 序列化
Animal pet = new Dog();
ObjectOutputStream oos = new ObjectOutputStream(...);
oos.writeObject(pet);

// 反序列化
ObjectInputStream ois = new ObjectInputStream(...);
Animal pet = (Animal) ois.readObject();  // 实际是Dog实例

15.2 自定义序列化策略

java复制class CustomSerializer {
    String serialize(Animal animal) {
        if (animal instanceof Dog) {
            Dog dog = (Dog) animal;
            return "Dog:" + dog.getName() + ":" + dog.getBreed();
        } else {
            return "Animal:" + animal.getName();
        }
    }
    
    Animal deserialize(String data) {
        String[] parts = data.split(":");
        if (parts[0].equals("Dog")) {
            Dog dog = new Dog();
            dog.setName(parts[1]);
            dog.setBreed(parts[2]);
            return dog;
        } else {
            Animal animal = new Animal();
            animal.setName(parts[1]);
            return animal;
        }
    }
}

16. 多态与模块化系统

16.1 Java模块系统中的服务加载

java复制module service.provider {
    provides com.example.Service with com.example.MyServiceImpl;
}

module service.consumer {
    requires service.api;
    uses com.example.Service;
}

// 使用ServiceLoader加载实现
ServiceLoader<Service> loader = ServiceLoader.load(Service.class);
for (Service service : loader) {
    service.execute();
}

16.2 插件架构实现

java复制interface Plugin {
    String getName();
    void execute();
}

class PluginManager {
    private List<Plugin> plugins = new ArrayList<>();
    
    void loadPlugins() {
        ServiceLoader<Plugin> loader = ServiceLoader.load(Plugin.class);
        loader.forEach(plugins::add);
    }
    
    void runAll() {
        plugins.forEach(Plugin::execute);
    }
}

17. 多态在图形界面开发中的应用

17.1 Swing/AWT中的事件处理

java复制button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Button clicked");
    }
});

// 使用Lambda简化
button.addActionListener(e -> System.out.println("Button clicked"));

17.2 JavaFX中的多态绑定

java复制interface Validator {
    boolean validate(String input);
}

class LengthValidator implements Validator {
    @Override
    public boolean validate(String input) {
        return input.length() >= 8;
    }
}

TextField textField = new TextField();
Validator validator = new LengthValidator();
BooleanBinding isValid = Bindings.createBooleanBinding(
    () -> validator.validate(textField.getText()),
    textField.textProperty()
);

18. 多态与设计模式深度结合

18.1 工厂方法模式

java复制interface Product {
    void use();
}

abstract class Creator {
    abstract Product createProduct();
    
    void someOperation() {
        Product product = createProduct();
        product.use();
    }
}

class ConcreteCreator extends Creator {
    @Override
    Product createProduct() {
        return new ConcreteProduct();
    }
}

18.2 观察者模式

java复制interface Observer {
    void update(String event);
}

class ConcreteObserver implements Observer {
    @Override
    public void update(String event) {
        System.out.println("Received event: " + event);
    }
}

class Subject {
    private List<Observer> observers = new ArrayList<>();
    
    void addObserver(Observer observer) {
        observers.add(observer);
    }
    
    void notifyObservers(String event) {
        for (Observer observer : observers) {
            observer.update(event);
        }
    }
}

18.3 访问者模式

java复制interface Visitor {
    void visit(ElementA element);
    void visit(ElementB element);
}

interface Element {
    void accept(Visitor visitor);
}

class ElementA implements Element {
    @Override
    public void accept(Visitor visitor) {
        visitor.visit(this);
    }
}

class ConcreteVisitor implements Visitor {
    @Override
    public void visit(ElementA element) {
        System.out.println("Processing ElementA");
    }
    
    @Override
    public void visit(ElementB element) {
        System.out.println("Processing ElementB");
    }
}

19. 多态在分布式系统中的应用

19.1 RPC调用中的多态

java复制interface UserService {
    User getUser(String id);
}

class UserServiceImpl implements UserService {
    @Override
    public User getUser(String id) {
        // 实际实现
    }
}

// 客户端代理
class UserServiceProxy implements UserService {
    @Override
    public User getUser(String id) {
        // 网络通信逻辑
        return remoteCall("getUser", id);
    }
}

19.2 消息处理的多态路由

java复制interface MessageHandler {
    void handle(Message message);
}

class OrderHandler implements MessageHandler {
    @Override
    public void handle(Message message) {
        // 处理订单消息
    }
}

class MessageRouter {
    private Map<String, MessageHandler> handlers = new HashMap<>();
    
    void registerHandler(String type, MessageHandler handler) {
        handlers.put(type, handler);
    }
    
    void route(Message message) {
        MessageHandler handler = handlers.get(message.getType());
        if (handler != null) {
            handler.handle(message);
        }
    }
}

20. 多态与元编程

20.1 动态代码生成

java复制interface Calculator {
    int calculate(int a, int b);
}

class DynamicCalculatorGenerator {
    static Calculator create(String operation) {
        return (a, b) -> {
            switch (operation) {
                case "add": return a + b;
                case "subtract": return a - b;
                default: throw new UnsupportedOperationException();
            }
        };
    }
}

20.2 基于注解的代码生成

java复制@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
@interface GenerateBuilder {
}

@GenerateBuilder
class Person {
    private String name;
    private int age;
    // getters/setters
}

// 注解处理器会生成PersonBuilder类
Person person = new PersonBuilder()
    .name("John")
    .age(30)
    .build();

21. 多态与领域驱动设计

21.1 领域事件的多态处理

java复制interface DomainEvent {
    LocalDateTime occurredOn();
}

class OrderPlaced implements DomainEvent {
    private final Order order;
    private final LocalDateTime occurredOn = LocalDateTime.now();
    
    @Override
    public LocalDateTime occurredOn() {
        return occurredOn;
    }
}

interface EventHandler<T extends DomainEvent> {
    void handle(T event);
}

class OrderPlacedHandler implements EventHandler<OrderPlaced> {
    @Override
    public void handle(OrderPlaced event) {
        // 处理订单创建逻辑
    }
}

21.2 策略模式实现业务规则

java复制interface PricingStrategy {
    BigDecimal calculatePrice(Order order);
}

class RegularPricing implements PricingStrategy {
    @Override
    public BigDecimal calculatePrice(Order order) {
        return order.getSubtotal();
    }
}

class DiscountPricing implements PricingStrategy {
    private final BigDecimal discount;
    
    public DiscountPricing(BigDecimal discount) {
        this.discount = discount;
    }
    
    @Override
    public BigDecimal calculatePrice(Order order) {
        return order.getSubtotal().multiply(BigDecimal.ONE.subtract(discount));
    }
}

22. 多态与性能监控

22.1 代理模式实现性能统计

java复制interface DataService {
    String fetchData(String key);
}

class DataServiceImpl implements DataService {
    @Override
    public String fetchData(String key) {
        // 实际数据获取逻辑
        return "Data for " + key;
    }
}

class TimingProxy implements DataService {
    private final DataService delegate;
    
    public TimingProxy(DataService delegate) {
        this.delegate = delegate;
    }
    
    @Override
    public String fetchData(String key) {
        long start = System.nanoTime();
        String result = delegate.fetchData(key);
        long duration = System.nanoTime() - start;
        System.out.println("Method took " + duration + " ns");
        return result;
    }
}

22.2 多态指标收集

java复制interface MetricCollector {
    void record(String metric, long value);
}

class LoggingCollector implements MetricCollector {
    @Override
    public void record(String metric, long value) {
        System.out.println(metric + ": " + value);
    }
}

class StatsDCollector implements MetricCollector {
    @Override
    public void record(String metric, long value) {
        // 发送到StatsD服务器
    }
}

class Metrics {
    private static MetricCollector collector = new LoggingCollector();
    
    public static void setCollector(MetricCollector collector) {
        Metrics.collector = collector;
    }
    
    public static void time(String name, Runnable operation) {
        long start = System.nanoTime();
        operation.run();
        long duration = System.nanoTime() - start;
        collector.record(name, duration);
    }
}

23. 多态与安全编程

23.1 权限检查的多态实现

java复制interface PermissionChecker {
    boolean check(User user, Resource resource);
}

class RoleBasedChecker implements PermissionChecker {
    @Override
    public boolean check(User user, Resource resource) {
        return user.getRoles().contains(resource.getRequiredRole());
    }
}

class SecurityManager {
    private PermissionChecker checker;
    
    public SecurityManager(PermissionChecker checker) {
        this.checker = checker;
    }
    
    public void secureAccess(User user, Resource resource) {
        if (!checker.check(user, resource)) {
            throw new SecurityException("Access denied");
        }
    }
}

23.2 加密策略的多态切换

java复制interface EncryptionStrategy {
    String encrypt(String data);
    String decrypt(String encrypted);
}

class AESStrategy implements EncryptionStrategy {
    @Override
    public String encrypt(String data) {
        // AES加密实现
    }
    
    @Override
    public String decrypt(String encrypted) {
        // AES解密实现
    }
}

class EncryptionService {
    private EncryptionStrategy strategy;
    
    public EncryptionService(EncryptionStrategy strategy) {
        this.strategy = strategy;
    }
    
    public String encrypt(String data) {
        return strategy.encrypt(data);
    }
    
    public String decrypt(String encrypted) {
        return strategy.decrypt(encrypted);
    }
}

24. 多态与国际化

24.1 多语言消息处理

java复制interface MessageResolver {
    String resolve(String code, Locale locale);
}

class DatabaseMessageResolver implements MessageResolver {
    @Override
    public String resolve(String code, Locale locale) {
        // 从数据库查询消息
    }
}

class ResourceBundleResolver implements MessageResolver {
    @Override
    public String resolve(String code, Locale locale) {
        ResourceBundle bundle = ResourceBundle.getBundle("messages", locale);
        return bundle.getString(code);
    }
}

class I18nService {
    private MessageResolver resolver;
    
    public I18nService(MessageResolver resolver) {
        this.resolver = resolver;
    }
    
    public String getMessage(String code, Locale locale) {
        return resolver.resolve(code, locale);
    }
}

24.2 格式化策略的多态实现

java复制interface Formatter {
    String format(Date date, Locale locale);
}

class ShortDateFormatter implements Formatter {
    @Override
    public String format(Date date, Locale locale) {
        DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT, locale);
        return df.format(date);
    }
}

class I18nFormatter {
    private Formatter dateFormatter;
    
    public I18nFormatter(Formatter dateFormatter) {
        this.dateFormatter = dateFormatter;
    }
    
    public String formatDate(Date date, Locale locale) {
        return dateFormatter.format(date, locale);
    }
}

25. 多态与缓存策略

25.1 缓存实现的多态设计

java复制interface Cache {
    void put(String key, Object value);
    Object get(String key);
}

class MemoryCache implements Cache {
    private final Map<String, Object> store = new HashMap<>();
    
    @Override
    public void put(String key, Object value) {
        store.put(key, value);
    }
    
    @Override
    public Object get(String key) {
        return store.get(key);
    }
}

class RedisCache implements Cache {
    private final Jedis jedis;
    
    public RedisCache(Jedis jedis) {
        this.jedis = jedis;
    }
    
    @Override
    public void put(String key, Object value) {
        jedis.set(key, serialize(value));
    }
    
    @Override
    public Object get(String key) {
        return deserialize(jedis.get(key));
    }
}

25.2 缓存策略的多态切换

java复制interface CacheStrategy {
    Object get(String key, Supplier<Object> loader);
}

class WriteThroughStrategy implements CacheStrategy {
    private final Cache cache;
    
    public WriteThroughStrategy(Cache cache) {
        this.cache = cache;
    }
    
    @Override
    public Object get(String key, Supplier<Object> loader) {
        Object value = cache.get(key);
        if (value == null) {
            value = loader.get();
            cache.put(key, value);
        }
        return value;
    }
}

class CacheManager {
    private CacheStrategy strategy;
    
    public CacheManager(CacheStrategy strategy) {
        this.strategy = strategy;
    }
    
    public Object get(String key, Supplier<Object> loader) {
        return strategy.get(key, loader);
    }
}

26. 多态与测试替身

26.1 测试替身的类型选择

1. Dummy：仅用于填充参数
2. Stub：提供预设响应
3. Spy：记录调用信息
4. Mock：验证交互行为
5. Fake：简化功能实现

26.2 多态测试替身示例

java复制interface UserRepository {
    User findById(String id);
    void save(User user);
}

// 测试用的Fake实现
class FakeUserRepository implements UserRepository {
    private Map<String, User> users = new HashMap<>();
    
    @Override
    public User findById(String id) {
        return users.get(id);
    }
    
    @Override
    public void save(User user) {
        users.put(user.getId(), user);
    }
}

// 测试用的Mock实现
class MockUserRepository implements UserRepository {
    private User expectedUser;
    private boolean saveCalled = false;
    
    public void expectFindById(User user) {
        this.expectedUser = user;
    }
    
    public void verifySaveCalled() {
        assertTrue(saveCalled);
    }
    
    @Override
    public User findById(String id) {
        return expectedUser;
    }
    
    @Override
    public void save(User user) {
        saveCalled = true;
    }
}

27. 多态与设计模式组合

27.1 装饰器模式增强多态

java复制interface DataSource {
    String readData();
}

class FileDataSource implements DataSource {
    @Override
    public String readData() {
        // 从文件读取
    }
}

class EncryptionDecorator implements DataSource {
    private DataSource wrapped;
    
    public EncryptionDecorator(DataSource wrapped) {
        this.wrapped = wrapped;
    }
    
    @Override
    public String readData() {
        String encrypted = wrapped.readData();
        return decrypt(encrypted);
    }
}

// 使用
DataSource source = new EncryptionDecorator(new FileDataSource());
String data = source.readData();

27.2 组合模式实现多态树结构

java复制interface Component {
    void operation();
}

class Leaf implements Component {
    @Override
    public void operation() {
        System.out.println("Leaf operation");
    }
}

class Composite implements Component {
    private List<Component> children = new ArrayList<>();
    
    void add(Component component) {
        children.add(component);
    }
    
    @Override
    public void operation() {
        for (Component child : children) {
            child.operation();
        }
    }
}

28. 多态与状态管理

28.1 状态模式实现多态行为

java复制interface State {
    void handle(Context context);
}

class ConcreteStateA implements State {
    @Override
    public void handle(Context context) {
        System.out.println("State A handling");
        context.setState(new ConcreteStateB());
    }
}

class ConcreteStateB implements State {
    @Override
    public void handle(Context context) {
        System.out.println("State B handling");
        context.setState(new ConcreteStateA());
    }
}

class Context {
    private State state;
    
    public Context(State initialState) {
        this.state = initialState;
    }
    
    void setState(State state) {
        this.state = state;
    }
    
    void request() {
        state.handle(this);
    }
}

28.2 有限状态机实现

java复制interface TransitionHandler {
    void handle(Event event);
}

class StateMachine {
    private Map<State, Map<Event, Transition>> transitions = new HashMap<>();
    private State current;
    
    void addTransition(State from, Event event, State to, TransitionHandler handler) {
        transitions.computeIfAbsent(from, k -> new HashMap<>())
                  .put(event, new Transition(to, handler));
    }
    
    void process(Event event) {
        Transition transition = transitions.get(current).get(event);
        if (transition != null) {
            transition.handler.handle(event);
            current = transition.to;
        }
    }
    
    private static class Transition {
        final State to;
        final TransitionHandler handler;
        
        Transition(State to, TransitionHandler handler) {
            this.to = to;
            this.handler = handler;
        }
    }
}

29. 多态与算法策略

29.1 排序算法的多态实现

java复制interface SortStrategy {
    void sort(int[] array);
}

class BubbleSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // 冒泡排序实现
    }
}

class QuickSort implements SortStrategy {
    @Override
    public void sort(int[] array) {
        // 快速排序实现
    }
}

class Sorter {
    private SortStrategy strategy;
    
    public Sorter(SortStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void sort(int[] array) {
        strategy.sort(array);
    }
}

29.2 搜索算法的多态切换

java复制interface SearchAlgorithm {
    int search(int[] array, int key);
}

class LinearSearch implements SearchAlgorithm {
    @Override
    public int search(int[] array, int key) {
        for (int i = 0; i < array.length; i++) {
            if (array[i] == key) {
                return i;
            }
        }
        return -1;
    }
}

class BinarySearch implements SearchAlgorithm {
    @Override
    public int search(int[] array, int key) {
        // 二分查找实现
    }
}

class SearchContext {
    private SearchAlgorithm algorithm;
    
    public SearchContext(SearchAlgorithm algorithm) {
        this.algorithm = algorithm;
    }
    
    public int executeSearch(int[] array, int key) {
        return algorithm.search(array, key);
    }
}

30. 多态与设计原则实践

30.1 单一职责原则（SRP）

java复制// 违反SRP
class ReportGenerator {
    void generateReport() {
        // 获取数据
        // 格式化报告
        // 发送邮件
    }
}

// 符合SRP
interface DataFetcher {
    Data fetchData();
}

interface ReportFormatter {
    String format(Data data);
}

interface ReportSender {
    void send(String report);
}

class ReportProcessor {
    private DataFetcher fetcher;
    private ReportFormatter formatter;
    private ReportSender sender;
    
    void process() {
        Data data = fetcher.fetchData();
        String report = formatter.format(data);
        sender.send(report);
    }
}

30.2 组合优于继承原则

java复制// 不推荐：使用继承
class Stack extends ArrayList {
    void push(Object item) {
        add(item);
    }
    
    Object pop() {
        return remove(size() - 1);
    }
}

// 推荐：使用组合
class Stack {
    private List list = new ArrayList();
    
    void push(Object item) {
        list.add(item);
    }
    
    Object pop() {
        return list.remove(list.size() - 1);
    }
}

31. 多态与并发集合

31.1 并发集合接口设计

java复制interface ConcurrentCollection<T> {
    void add(T item);
    T remove();
    boolean isEmpty();
}

class ConcurrentQueue<T> implements ConcurrentCollection<T> {
    private final Queue<T> queue = new ConcurrentLinkedQueue<>();
    
    @