Android Java程序中通过rootList切换修改rootA/rootB的可行性问询

嘿，这个方案完全可行，这其实是面向对象里多态特性的经典应用场景，不过得先满足几个关键前提，让我给你一步步说清楚：

关键前提：让rootA和rootB属于同一类型体系 #

要实现“切换rootList指向就复用逻辑”，首先得保证rootA、rootB和rootList的引用类型是统一的——要么它们都继承同一个父类，要么都实现同一个接口。这个父类/接口里需要定义select()、func1()这些你要复用的方法签名。

举个最直接的Java代码例子：
首先定义统一的接口：

// 定义所有Root类需要实现的方法
public interface Root {
    void select();
    void func1();
    // 如果还有其他要复用的方法，也在这里声明
}

然后让RootA和RootB实现这个接口：

public class RootA implements Root {
    // 全局变量index可以在这里直接使用
    @Override
    public void select() {
        // RootA独有的select逻辑
        System.out.println("RootA select, index: " + index);
    }

    @Override
    public void func1() {
        // RootA独有的func1逻辑，直接修改自身属性
    }
}

public class RootB implements Root {
    @Override
    public void select() {
        // RootB独有的select逻辑
        System.out.println("RootB select, index: " + index);
    }

    @Override
    public void func1() {
        // RootB独有的func1逻辑
    }
}

然后把全局变量rootList的类型声明为Root：

// 全局变量
private Root rootList;
private Root rootA = new RootA();
private Root rootB = new RootB();
private int index;

复用f1函数的实现 #

现在f1函数完全不用关心rootList指向的是RootA还是RootB，直接调用统一接口的方法就行：

public void f1() {
    // 不管rootList是RootA还是RootB，都会执行对应类的实现
    rootList.select();
    rootList.func1();
    // 结合index做其他修改逻辑，比如修改rootList的属性
}

当你需要切换修改目标时，只需要做：

// 切换到修改rootA
rootList = rootA;
f1();

// 切换到修改rootB
rootList = rootB;
f1();

完美复用同一个f1函数，完全符合你的需求！

如果rootA和rootB是完全无关的类怎么办？ #

要是因为历史原因，RootA和RootB没法直接继承/实现同一类型，那可以用适配器模式来做兼容，把它们包装成统一接口的实现：

// 适配RootA的适配器
public class RootAAdapter implements Root {
    private RootA realRootA;

    public RootAAdapter(RootA realRootA) {
        this.realRootA = realRootA;
    }

    @Override
    public void select() {
        realRootA.select(); // 调用原RootA的select方法
    }

    @Override
    public void func1() {
        realRootA.func1(); // 调用原RootA的func1方法
    }
}

// 适配RootB的适配器
public class RootBAdapter implements Root {
    private RootB realRootB;

    public RootBAdapter(RootB realRootB) {
        this.realRootB = realRootB;
    }

    @Override
    public void select() {
        realRootB.select();
    }

    @Override
    public void func1() {
        realRootB.func1();
    }
}

然后初始化全局变量时：

private Root rootA = new RootAAdapter(new RootA());
private Root rootB = new RootBAdapter(new RootB());

之后的用法和之前完全一样，f1函数不需要任何修改，照样可以复用。

总结 #

你的方案不仅可行，而且是非常优雅的面向对象实践——通过多态（或适配器兼容）实现逻辑复用，避免了大量重复的分支判断代码。只要把类型体系统一好，切换目标对象只需要修改rootList的指向，完全符合你的预期。

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