Java多态：七十二变的神通妙用
作者：会编程的吕洞宾
温馨提示：多态就像孙悟空的七十二变，一个对象可以"变身"成多种形态！
什么是多态？编程界的"变身术"
想象一下，你是一个修仙门派的掌门，面对一群弟子说："所有会御剑飞行的弟子，给我飞起来！" 你不需要知道具体是哪个弟子，只要他们都会御剑飞行这个技能就行。
这就是多态的精髓：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果。
多态的三要素：继承、重写、向上转型
多态的实现需要三个关键要素，就像修仙需要"法、侣、财、地"一样：
1. 继承：建立血脉联系
// 基类：修仙者
class Immortal {
public void cultivate() {
System.out.println("基础修炼功法");
}
}
// 派生类：剑修
class SwordImmortal extends Immortal {
@Override
public void cultivate() {
System.out.println("修炼剑道，人剑合一");
}
public void swordSkill() {
System.out.println("施展剑诀");
}
}
// 派生类：丹修
class AlchemyImmortal extends Immortal {
@Override
public void cultivate() {
System.out.println("炼丹悟道，炉火纯青");
}
public void makePill() {
System.out.println("炼制仙丹");
}
}
2. 向上转型：神奇的"变身术"
public class PolymorphismDemo {
public static void main(String[] args) {
// 向上转型：把具体类型当作基类处理
Immortal immortal1 = new SwordImmortal(); // 剑修"变身"为修仙者
Immortal immortal2 = new AlchemyImmortal(); // 丹修"变身"为修仙者
// 多态调用：同一个方法，不同行为
immortal1.cultivate(); // 输出：修炼剑道，人剑合一
immortal2.cultivate(); // 输出：炼丹悟道，炉火纯青
}
}
多态的魅力：编写"通用"代码
多态最大的好处是：代码不需要知道具体类型，却能正确工作！
// 一个通用的"修炼指导"方法
class TrainingMaster {
// 这个方法可以接受任何Immortal的子类！
public void guideCultivation(Immortal immortal) {
System.out.println("指导修炼开始：");
immortal.cultivate(); // 自动调用正确的修炼方法
System.out.println("指导修炼结束");
}
}
// 使用通用方法
public class ImmortalWorld {
public static void main(String[] args) {
TrainingMaster master = new TrainingMaster();
// 指导不同类型的修仙者
master.guideCultivation(new SwordImmortal());
master.guideCultivation(new AlchemyImmortal());
master.guideCultivation(new Immortal()); // 甚至基类自己
}
}
输出结果：
指导修炼开始：
修炼剑道，人剑合一
指导修炼结束
指导修炼开始：
炼丹悟道，炉火纯青
指导修炼结束
指导修炼开始：
基础修炼功法
指导修炼结束
动态绑定：多态的"魔法引擎"
多态的神奇之处在于动态绑定（后期绑定）。编译器不知道具体调用哪个方法，运行时才确定：
class Shape {
public void draw() {
System.out.println("绘制形状");
}
}
class Circle extends Shape {
@Override
public void draw() {
System.out.println("绘制圆形 ○");
}
}
class Square extends Shape {
@Override
public void draw() {
System.out.println("绘制方形 □");
}
}
public class DrawingDemo {
public static void drawShape(Shape shape) {
// 编译时：只知道shape是Shape类型
// 运行时：才知道具体是Circle还是Square
shape.draw(); // 魔法发生在这里！
}
public static void main(String[] args) {
drawShape(new Circle()); // 输出：绘制圆形 ○
drawShape(new Square()); // 输出：绘制方形 □
drawShape(new Shape()); // 输出：绘制形状
}
}
多态的实际应用：可扩展的系统设计
多态让系统更容易扩展，就像修仙门派可以不断招收新类型的弟子：
// 法宝系统 - 高度可扩展
class TreasureSystem {
// 可以处理任何类型的法宝
public static void useTreasure(MagicTreasure treasure) {
System.out.print("使用法宝：");
treasure.activate();
}
// 可以处理任何法宝数组
public static void useAllTreasures(MagicTreasure[] treasures) {
for (MagicTreasure treasure : treasures) {
useTreasure(treasure);
}
}
}
// 测试扩展性
public class ExpansionTest {
public static void main(String[] args) {
MagicTreasure[] treasures = {
new FlyingSword(), // 飞剑
new MagicMirror(), // 宝镜（新法宝！）
new AlchemyFurnace() // 丹炉
};
// 不需要修改TreasureSystem，就能处理新法宝！
TreasureSystem.useAllTreasures(treasures);
}
}
多态的限制：知道你的"变身"界限
1. 不能调用子类特有方法
Immortal immortal = new SwordImmortal();
immortal.cultivate(); // ✅ 可以，基类有这个方法
// immortal.swordSkill(); // ❌ 编译错误！基类没有这个方法
2. 向下转型需要小心
SwordImmortal swordImmortal = (SwordImmortal) immortal; // 向下转型
swordImmortal.swordSkill(); // ✅ 现在可以调用特有方法了
// 但转型错误会抛出ClassCastException
// AlchemyImmortal alchemy = (AlchemyImmortal) immortal; // 运行时错误！
3. 属性和静态方法没有多态
class Base {
public String name = "Base";
public static void staticMethod() {
System.out.println("Base static method");
}
}
class Derived extends Base {
public String name = "Derived"; // 隐藏了基类的name
public static void staticMethod() {
System.out.println("Derived static method");
}
}
public class PolymorphismLimit {
public static void main(String[] args) {
Base obj = new Derived();
System.out.println(obj.name); // 输出：Base（没有多态！）
obj.staticMethod(); // 输出：Base static method（没有多态！）
}
}
实战：完整的修仙多态系统
让我们构建一个完整的修仙世界来体验多态的强大：
// 基类接口
interface Cultivator {
void cultivate();
void fight();
}
// 具体实现类
class SwordMaster implements Cultivator {
@Override
public void cultivate() {
System.out.println("剑修：修炼无上剑道");
}
@Override
public void fight() {
System.out.println("剑修：万剑归宗！");
}
}
class AlchemyMaster implements Cultivator {
@Override
public void cultivate() {
System.out.println("丹修：炼制九转金丹");
}
@Override
public void fight() {
System.out.println("丹修：丹火焚天！");
}
}
class BeastMaster implements Cultivator {
@Override
public void cultivate() {
System.out.println("御兽修：驯服洪荒异兽");
}
@Override
public void fight() {
System.out.println("御兽修：百兽奔腾！");
}
}
// 多态的使用
class SectManager {
private List<Cultivator> cultivators = new ArrayList<>();
public void addCultivator(Cultivator cultivator) {
cultivators.add(cultivator);
}
public void dailyTraining() {
System.out.println("=== 门派日常修炼 ===");
for (Cultivator cultivator : cultivators) {
cultivator.cultivate(); // 多态调用！
}
}
public void sectWar() {
System.out.println("=== 门派大战 ===");
for (Cultivator cultivator : cultivators) {
cultivator.fight(); // 多态调用！
}
}
}
// 运行修仙世界
public class ImmortalSect {
public static void main(String[] args) {
SectManager sect = new SectManager();
// 招收各种类型的弟子
sect.addCultivator(new SwordMaster());
sect.addCultivator(new AlchemyMaster());
sect.addCultivator(new BeastMaster());
// 多态管理：不需要知道具体类型
sect.dailyTraining();
sect.sectWar();
}
}
吕洞宾的多态心法
记住这几条修仙要诀：
- "面向抽象"：编程时面向基类/接口，而不是具体实现
- "开放封闭"：对扩展开放，对修改封闭
- "里氏替换"：子类必须能够替换基类
- "依赖倒置"：依赖抽象，而不是具体实现
多态就像修仙界的"变化之道"，掌握了它，你的代码就能像孙悟空一样千变万化，应对各种复杂场景！
