如何结合Enum与BiFunction实现Java运行时多态？

问题说明 #

现有代码尝试通过枚举结合BiFunction实现运行时多态，但编译报错无法从静态上下文引用非静态方法：

public interface Animal {
}

public interface Birds extends Animal {
    boolean canFly(AnimalDetails animalDetails);
}

public interface Dog extends Animal {
    boolean canBark(AnimalDetails animalDetails);
}

enum AnimalTypes {
    CAN_BARK(Dog::canBark),
    CAN_FLY(Birds::canFly);
    private final BiFunction<Animal, AnimalDetails, Boolean> typeAlgo;
    AnimalTypes(BiFunction<Animal, AnimalDetails, Boolean> typeAlgo) {this.typeAlgo = typeAlgo;}
}

报错原因是Dog::canBark这类子接口的非静态方法引用，无法直接适配BiFunction<Animal, AnimalDetails, Boolean>的类型签名——编译器无法确认传入的Animal实例是Dog或Birds类型，也不允许从静态上下文直接引用非静态接口方法。

以下是几种保留接口分层、实现需求的解决方案：

方案1：父接口添加默认方法适配类型 #

在Animal接口中添加默认方法，子接口重写对应逻辑，让方法引用能直接适配BiFunction的参数要求：

public interface Animal {
    default boolean canBark(AnimalDetails details) {
        throw new UnsupportedOperationException("该动物不会吠叫");
    }

    default boolean canFly(AnimalDetails details) {
        throw new UnsupportedOperationException("该动物不会飞行");
    }
}

public interface Birds extends Animal {
    @Override
    default boolean canFly(AnimalDetails animalDetails) {
        // Birds专属飞行逻辑
        return true;
    }
}

public interface Dog extends Animal {
    @Override
    default boolean canBark(AnimalDetails animalDetails) {
        // Dog专属吠叫逻辑
        return true;
    }
}

enum AnimalTypes {
    CAN_BARK(Animal::canBark),
    CAN_FLY(Animal::canFly);
    
    private final BiFunction<Animal, AnimalDetails, Boolean> typeAlgo;

    AnimalTypes(BiFunction<Animal, AnimalDetails, Boolean> typeAlgo) {
        this.typeAlgo = typeAlgo;
    }

    public boolean execute(Animal animal, AnimalDetails details) {
        return typeAlgo.apply(animal, details);
    }
}

运行时会自动调用子接口的重写方法，同时保留了接口的分层设计。

方案2：枚举内显式处理类型转换 #

不修改原有接口结构，在枚举的方法引用中显式做类型转换，同时添加类型校验避免运行时异常：

enum AnimalTypes {
    CAN_BARK((animal, details) -> ((Dog) animal).canBark(details)),
    CAN_FLY((animal, details) -> ((Birds) animal).canFly(details));
    
    private final BiFunction<Animal, AnimalDetails, Boolean> typeAlgo;

    AnimalTypes(BiFunction<Animal, AnimalDetails, Boolean> typeAlgo) {
        this.typeAlgo = typeAlgo;
    }

    public boolean execute(Animal animal, AnimalDetails details) {
        // 提前校验类型，避免ClassCastException
        if (this == CAN_BARK && !(animal instanceof Dog)) {
            throw new IllegalArgumentException("CAN_BARK操作仅支持Dog类型");
        }
        if (this == CAN_FLY && !(animal instanceof Birds)) {
            throw new IllegalArgumentException("CAN_FLY操作仅支持Birds类型");
        }
        return typeAlgo.apply(animal, details);
    }
}

这种方式完全保留原有接口的设计，但需要手动处理类型转换和校验。

方案3：自定义泛型函数接口 #

定义泛型函数接口，让枚举的方法引用更贴合子接口的类型约束：

@FunctionalInterface
interface AnimalFunction<T extends Animal> {
    boolean apply(T animal, AnimalDetails details);
}

enum AnimalTypes {
    CAN_BARK((Dog dog, AnimalDetails details) -> dog.canBark(details)),
    CAN_FLY((Birds bird, AnimalDetails details) -> bird.canFly(details));
    
    private final AnimalFunction<? extends Animal> typeAlgo;

    AnimalTypes(AnimalFunction<? extends Animal> typeAlgo) {
        this.typeAlgo = typeAlgo;
    }

    @SuppressWarnings("unchecked")
    public <T extends Animal> boolean execute(T animal, AnimalDetails details) {
        return ((AnimalFunction<T>) typeAlgo).apply(animal, details);
    }
}

该方案在编译期就能匹配子接口的方法签名，需要处理泛型的unchecked警告，同样建议添加类型校验。

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