类实现多接口的依赖注入问题：兼顾面向接口编程与多方法调用

这是个非常常见的面向接口编程场景里的痛点——既要保持接口的单一职责，又要在依赖注入时能访问到实例的多接口能力。我给你几个按推荐度排序的可行方案：

方案1：按职责拆分依赖（最推荐） #

如果你的TreeManager确实需要同时使用Tree和IBalancedTree的方法，那说明它的职责其实依赖两个不同的抽象角色，不如直接在构造函数中注入这两个接口的实例。如果传入的是同一个BalancedTree对象，完全可以把同一个实例注入两次，既符合面向接口的原则，又能清晰表达依赖关系。

修改后的代码示例（顺便修正了你Java代码里的语法错误：类实现接口要用implements而非extends）：

public interface Tree {
    int findMin();
    int findMax();
}

public interface IBalancedTree {
    int rightRotation();
}

class NormalTree implements Tree {
    @Override
    public int findMin() { /* 实现逻辑 */ return 0; }
    @Override
    public int findMax() { /* 实现逻辑 */ return 0; }
}

class BalancedTree implements Tree, IBalancedTree {
    @Override
    public int findMin() { /* 实现逻辑 */ return 0; }
    @Override
    public int findMax() { /* 实现逻辑 */ return 0; }
    @Override
    public int rightRotation() { /* 实现逻辑 */ return 0; }
}

class TreeManager {
    private final Tree tree;
    private final IBalancedTree balancedTree;

    // 注入两个接口实例，实际使用时传同一个BalancedTree对象即可
    public TreeManager(Tree tree, IBalancedTree balancedTree) {
        this.tree = tree;
        this.balancedTree = balancedTree;
    }

    public void doTreeOperations() {
        // 调用Tree的基础方法
        int min = tree.findMin();
        // 调用IBalancedTree的平衡操作方法
        int rotationResult = balancedTree.rightRotation();
    }
}

// 使用示例
BalancedTree balancedTree = new BalancedTree();
TreeManager manager = new TreeManager(balancedTree, balancedTree);

这个方案完全遵循单一职责和面向接口的原则，依赖关系清晰，后续维护也很方便。

方案2：创建组合接口（谨慎使用） #

如果你的业务中确实存在一类「既具备基础树能力又具备平衡树能力」的稳定组件，可以创建一个组合接口来整合两个接口的方法，然后让对应的实现类实现这个组合接口。

⚠️ 注意：不要为了图方便就随意合并接口，只有当这个组合接口确实代表一个独立的业务角色时才用，避免破坏接口的单一职责，导致接口膨胀。

示例代码：

// 组合接口，仅代表同时具备两种能力的特定角色
public interface IBalancedFullTree extends Tree, IBalancedTree {}

// 修改BalancedTree实现这个组合接口
class BalancedTree implements IBalancedFullTree {
    // 实现所有方法...
}

// TreeManager如果只处理这类组合角色，就注入组合接口
class TreeManager {
    private final IBalancedFullTree balancedTree;

    public TreeManager(IBalancedFullTree balancedTree) {
        this.balancedTree = balancedTree;
    }

    public void doOperations() {
        balancedTree.findMin();
        balancedTree.rightRotation();
    }
}

这个方案适合那些明确需要同时使用两种接口能力的场景，但一定要控制使用范围，避免滥用。

方案3：类型转换（应急方案，不推荐） #

如果实在不想修改现有的依赖结构，可以在需要调用IBalancedTree方法时，对Tree实例进行类型转换，但一定要加类型检查，避免运行时异常。

示例代码：

class TreeManager {
    private final Tree tree;

    public TreeManager(Tree tree) {
        this.tree = tree;
    }

    public void doBalancedOperations() {
        if (tree instanceof IBalancedTree) {
            IBalancedTree balancedTree = (IBalancedTree) tree;
            balancedTree.rightRotation();
        } else {
            // 处理非平衡树的情况，比如抛出异常或跳过
            throw new UnsupportedOperationException("This tree doesn't support balanced operations");
        }
    }
}

这个方案的缺点很明显：它破坏了面向接口的封装性，把具体实现类的细节暴露到了上层逻辑中，后期如果接口或实现类变化，容易引发问题，所以只建议在临时应急时使用。

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