Java类如何实现多特性扩展？解决生物类继承冲突问题

针对你遇到的「无法同时继承敌对/被动生物类与飞行/非飞行特性」的问题，以下是三种无需布尔值逐帧检查的实用方案：

方案一：带默认方法的接口（Java 8+） #

利用Java 8新增的接口默认方法，将飞行/非飞行特性作为行为接口实现，既避免多继承，又能复用行为逻辑。核心思路是：用接口标记特性并实现默认行为，子类通过实现接口获得对应能力，无需逐帧判断布尔值——类型本身就决定了是否具备飞行能力。

示例代码：

// 基础生物抽象类
abstract class Creature {
    public abstract void update();
}

// 敌对生物子类
abstract class Hostile extends Creature {
    public abstract void attack();
}

// 被动生物子类
abstract class Passive extends Creature {
    public abstract void flee();
}

// 飞行特性接口，包含默认行为实现
interface Flying {
    default void fly() {
        // 飞行逻辑：比如更新位置、播放动画
        System.out.println("执行飞行动作");
    }

    default boolean canFly() {
        return true;
    }
}

// 具体生物：敌对飞行生物（龙）
class Dragon extends Hostile implements Flying {
    @Override
    public void update() {
        fly(); // 直接调用飞行行为，无需判断
        attack();
    }

    @Override
    public void attack() {
        System.out.println("龙发动攻击");
    }
}

// 具体生物：被动非飞行生物（羊）
class Sheep extends Passive {
    @Override
    public void update() {
        flee(); // 无飞行行为，直接执行被动逻辑
    }

    @Override
    public void flee() {
        System.out.println("羊逃跑");
    }
}

优势：代码简洁，无需额外类层级，支持多特性组合；处理时可直接通过instanceof Flying筛选飞行生物，或利用多态调用行为。
局限：默认方法无法访问类的私有属性，若飞行逻辑依赖生物内部状态，需子类额外实现。

方案二：组合+策略模式（高灵活性） #

将飞行/非飞行行为封装为独立的策略类，通过组合而非继承注入到生物类中。这种方式完全解耦行为与实体类，还支持动态切换行为（比如生物受伤后失去飞行能力）。

示例代码：

// 飞行行为策略接口
interface FlightBehavior {
    void performFlight();
    boolean canFly();
}

// 飞行行为实现
class FlyingBehavior implements FlightBehavior {
    @Override
    public void performFlight() {
        System.out.println("扇动翅膀飞行");
    }

    @Override
    public boolean canFly() {
        return true;
    }
}

// 非飞行行为实现
class NonFlyingBehavior implements FlightBehavior {
    @Override
    public void performFlight() {
        System.out.println("无法飞行");
    }

    @Override
    public boolean canFly() {
        return false;
    }
}

// 基础生物类，持有飞行行为策略
abstract class Creature {
    protected FlightBehavior flightBehavior;

    public Creature(FlightBehavior flightBehavior) {
        this.flightBehavior = flightBehavior;
    }

    public abstract void update();

    public void doFlightAction() {
        flightBehavior.performFlight();
    }

    public boolean canFly() {
        return flightBehavior.canFly();
    }
}

// 敌对生物子类
abstract class Hostile extends Creature {
    public Hostile(FlightBehavior flightBehavior) {
        super(flightBehavior);
    }

    public abstract void attack();
}

// 具体生物：龙（敌对飞行）
class Dragon extends Hostile {
    public Dragon() {
        super(new FlyingBehavior());
    }

    @Override
    public void update() {
        doFlightAction();
        attack();
    }

    @Override
    public void attack() {
        System.out.println("龙喷吐火焰");
    }
}

优势：行为可动态修改，符合开闭原则；飞行逻辑集中维护，无需重复编写。
局限：需要额外维护策略类，代码量略多。

方案三：抽象类分层（适合特性固定的场景） #

如果生物种类不多、特性组合固定，可以通过分层抽象类直接划分类型，比如「飞行敌对生物」「非飞行被动生物」等。这种方式类型最明确，处理时无需任何判断，效率最高，但会导致类数量翻倍。

示例代码：

// 基础生物类
abstract class Creature {
    public abstract void update();
}

// 飞行生物抽象类
abstract class FlyingCreature extends Creature {
    public abstract void fly();
}

// 非飞行生物抽象类
abstract class NonFlyingCreature extends Creature {
    public abstract void walk();
}

// 敌对飞行生物
abstract class HostileFlying extends FlyingCreature {
    public abstract void attack();
}

// 被动非飞行生物
abstract class PassiveNonFlying extends NonFlyingCreature {
    public abstract void flee();
}

// 具体生物：龙
class Dragon extends HostileFlying {
    @Override
    public void update() {
        fly();
        attack();
    }

    @Override
    public void fly() {
        System.out.println("龙在空中盘旋");
    }

    @Override
    public void attack() {
        System.out.println("龙发动俯冲攻击");
    }
}

优势：类型清晰，无需任何判断逻辑，调用直接高效。
局限：新增特性时类数量会指数增长，扩展性差。

内容的提问来源于stack exchange，提问作者Ender Hunter