Java多态指的是同一个方法调用在不同对象上会产生不同的执行结果，这种特性让代码具备更好的灵活性和扩展性，也是很多设计模式实现的核心支撑。设计模式的核心是解耦和复用，多态正好能很好地满足这些需求，下面介绍几种典型的应用场景。
工厂模式中的多态应用
工厂模式的核心是通过工厂类统一创建对象，而不需要调用方直接依赖具体的产品类。多态在这里的作用是让工厂返回的产品父类引用指向不同的子类实例，调用方只需要面向父类接口编程即可。
首先定义产品接口：
// 产品接口
public interface Product {
void use();
}
// 具体产品A
public class ProductA implements Product {
@Override
public void use() {
System.out.println("使用产品A");
}
}
// 具体产品B
public class ProductB implements Product {
@Override
public void use() {
System.out.println("使用产品B");
}
}
然后是工厂类的实现，工厂方法返回Product类型的引用，实际指向不同的子类实例：
public class ProductFactory {
public static Product createProduct(String type) {
if ("A".equals(type)) {
return new ProductA();
} else if ("B".equals(type)) {
return new ProductB();
}
return null;
}
}
调用方不需要关心具体产品类的实现，只需要通过工厂获取Product引用，调用use方法即可，后续新增产品只需要新增实现类，修改工厂逻辑，不需要修改调用方代码。
策略模式中的多态应用
策略模式定义了一系列算法，并且将每个算法封装起来，让它们可以相互替换。多态在这里的作用是让上下文类持有策略接口的引用，运行时可以动态切换不同的策略实现。
先定义策略接口和具体策略类：
// 策略接口
public interface Strategy {
int calculate(int a, int b);
}
// 加法策略
public class AddStrategy implements Strategy {
@Override
public int calculate(int a, int b) {
return a + b;
}
}
// 减法策略
public class SubtractStrategy implements Strategy {
@Override
public int calculate(int a, int b) {
return a - b;
}
}
上下文类持有策略引用，运行时可以动态设置不同的策略：
public class Context {
private Strategy strategy;
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
public int execute(int a, int b) {
if (strategy == null) {
throw new RuntimeException("未设置策略");
}
return strategy.calculate(a, b);
}
}
使用时只需要切换不同的策略实现，上下文的执行逻辑不需要修改，符合开闭原则。
观察者模式中的多态应用
观察者模式定义了对象之间的一对多依赖，当一个对象状态发生改变时，所有依赖它的对象都会收到通知并自动更新。多态在这里的作用是让主题类持有观察者接口的引用集合，不需要依赖具体的观察者实现。
定义观察者接口和主题接口：
// 观察者接口
public interface Observer {
void update(String message);
}
// 主题接口
public interface Subject {
void addObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}
具体主题和观察者的实现：
import java.util.ArrayList;
import java.util.List;
// 具体主题
public class ConcreteSubject implements Subject {
private List<Observer> observers = new ArrayList<>();
private String message;
@Override
public void addObserver(Observer observer) {
observers.add(observer);
}
@Override
public void removeObserver(Observer observer) {
observers.remove(observer);
}
@Override
public void notifyObservers() {
for (Observer observer : observers) {
observer.update(message);
}
}
public void setMessage(String message) {
this.message = message;
notifyObservers();
}
}
// 具体观察者A
public class ObserverA implements Observer {
@Override
public void update(String message) {
System.out.println("观察者A收到消息：" + message);
}
}
// 具体观察者B
public class ObserverB implements Observer {
@Override
public void update(String message) {
System.out.println("观察者B收到消息：" + message);
}
}
主题类只需要面向Observer接口操作，新增观察者只需要实现Observer接口并注册到主题中，不需要修改主题的代码，这也是多态带来的扩展性优势。
其他设计模式中的多态应用
除了上述三种模式，很多其他设计模式也依赖多态特性。比如模板方法模式中，父类定义算法的骨架，子类通过重写父类的方法来实现具体步骤，父类调用子类重写的方法就是多态的体现。还有装饰器模式中，装饰器和被装饰对象都实现同一个接口，装饰器持有接口的引用，通过多态可以嵌套装饰不同的对象，扩展功能而不改变原有对象的代码。
总的来说，Java多态是很多设计模式能够实现高扩展、低耦合的核心原因，理解多态在设计模式中的应用，能帮助开发者更深刻地理解设计模式的设计思想，也能在实际开发中更合理地运用设计模式优化代码结构。