如何将8个相似Android Fragment重构为通用Fragment统一管理？

我拥有8个结构相似的Fragment，除布局文件及2-3个方法外，其余代码完全一致。我希望构建一个通用Fragment来统一管理这些Fragment，但暂未明确具体实现方案。目前我的思路是借助辅助类处理差异化方法，以下是示例代码：

Fragment 1.

public class Fragment1 extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return inflater.inflate(R.layout.lm_fragment, container, false);
    }
    public void method(){}
}

Fragment 2.

public class Fragment2 extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return inflater.inflate(R.layout.lm_fragment, container, false);
    }
    public void method2(){}
    public void method3(){}
}

Fragment X...
每个Fragment结构一致，仅差异化方法不同，请问实现通用Fragment的最佳方式是什么？

针对你这种多个Fragment高度相似、仅少数逻辑差异化的场景，我推荐几种成熟的实现方案，你可以根据自己的需求来选：

方案一：抽象基类 + 抽象方法/回调（最常用） #

这是Android开发中处理重复Fragment代码最经典的方案，核心是把所有通用逻辑抽离到一个抽象基类中，将差异化的部分定义为抽象方法或者回调接口，让子类去实现。

实现步骤： #

1. 创建抽象基类BaseCommonFragment，封装通用的生命周期逻辑、视图初始化等：

public abstract class BaseCommonFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        // 通用的视图初始化逻辑，也可以把布局ID作为抽象方法让子类返回
        return inflater.inflate(getLayoutResId(), container, false);
    }

    // 抽象方法：让子类返回各自的布局ID
    protected abstract int getLayoutResId();

    // 如果有通用的初始化逻辑，比如绑定控件、设置监听，可以放在onViewCreated里
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        initCommonViews(view);
        initUniqueLogic();
    }

    // 通用的视图初始化方法
    private void initCommonViews(View view) {
        // 比如初始化所有Fragment都有的Toolbar、通用按钮等
    }

    // 抽象方法：让子类实现各自的差异化逻辑
    protected abstract void initUniqueLogic();

    // 如果有特定的差异化方法，可以定义为抽象方法或者可选的空实现方法
    protected abstract void uniqueMethod();
}

2. 子类Fragment继承基类，实现抽象方法即可：

public class Fragment1 extends BaseCommonFragment {

    @Override
    protected int getLayoutResId() {
        return R.layout.lm_fragment;
    }

    @Override
    protected void initUniqueLogic() {
        // Fragment1特有的初始化逻辑
    }

    @Override
    protected void uniqueMethod() {
        // 实现Fragment1的method()逻辑
    }
}

public class Fragment2 extends BaseCommonFragment {

    @Override
    protected int getLayoutResId() {
        return R.layout.lm_fragment; // 如果布局不同就返回对应的ID
    }

    @Override
    protected void initUniqueLogic() {
        // Fragment2特有的初始化逻辑
    }

    @Override
    protected void uniqueMethod() {
        // 实现Fragment2的method2()/method3()逻辑，或者可以拆分多个抽象方法
    }

    // 如果有额外的差异化方法，也可以在这里新增，或者在基类里定义可选的空方法
    public void method3() {
        // 特有的方法逻辑
    }
}

优点：逻辑清晰，代码结构简单，符合面向对象的继承思想，维护成本低。
缺点：如果差异化逻辑过于复杂，可能会导致基类膨胀，不过你的场景是2-3个差异化方法，完全适用。

方案二：组合模式 + 辅助类（你提到的思路） #

如果不想用继承，或者差异化逻辑需要动态切换，组合模式会更灵活。核心是把差异化逻辑封装到独立的辅助类中，基类通过持有辅助类的实例来调用差异化方法。

实现步骤： #

1. 定义辅助类的接口，声明所有可能的差异化方法：

public interface FragmentHelper {
    int getLayoutResId();
    void doUniqueLogic(View view);
    void uniqueMethod();
}

2. 为每个Fragment创建对应的辅助类实现：

public class Fragment1Helper implements FragmentHelper {
    @Override
    public int getLayoutResId() {
        return R.layout.lm_fragment;
    }

    @Override
    public void doUniqueLogic(View view) {
        // Fragment1的差异化初始化逻辑
    }

    @Override
    public void uniqueMethod() {
        // 对应Fragment1的method()逻辑
    }
}

public class Fragment2Helper implements FragmentHelper {
    @Override
    public int getLayoutResId() {
        return R.layout.lm_fragment;
    }

    @Override
    public void doUniqueLogic(View view) {
        // Fragment2的差异化初始化逻辑
    }

    @Override
    public void uniqueMethod() {
        // 对应Fragment2的method2()逻辑
    }

    // 如果有额外的方法，可以在这里扩展，基类通过类型转换调用（或者在接口里新增）
    public void method3() {
        // 对应Fragment2的method3()逻辑
    }
}

3. 创建通用的CommonFragment，持有FragmentHelper实例：

public class CommonFragment extends Fragment {
    private FragmentHelper helper;

    // 通过静态方法传递辅助类实例，创建Fragment
    public static CommonFragment newInstance(FragmentHelper helper) {
        CommonFragment fragment = new CommonFragment();
        fragment.helper = helper;
        return fragment;
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        return inflater.inflate(helper.getLayoutResId(), container, false);
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        // 通用初始化逻辑
        initCommonViews(view);
        // 调用辅助类的差异化逻辑
        helper.doUniqueLogic(view);
    }

    private void initCommonViews(View view) {
        // 通用视图初始化
    }

    // 暴露给外部调用差异化方法
    public void callUniqueMethod() {
        helper.uniqueMethod();
    }

    // 如果需要调用特定辅助类的扩展方法，可以提供类型转换的方法
    public <T extends FragmentHelper> T getHelper() {
        return (T) helper;
    }
}

4. 使用时创建对应的辅助类，传入CommonFragment：

// 创建Fragment1实例
CommonFragment fragment1 = CommonFragment.newInstance(new Fragment1Helper());
// 创建Fragment2实例
CommonFragment fragment2 = CommonFragment.newInstance(new Fragment2Helper());
// 如果需要调用Fragment2的method3()
((Fragment2Helper) fragment2.getHelper()).method3();

优点：遵循组合优于继承的原则，差异化逻辑完全解耦，方便动态替换逻辑，基类不会膨胀。
缺点：需要额外创建辅助类，代码量略多，调用特定方法时需要类型转换（可以通过泛型优化）。

方案三：ViewModel + 基类（适合数据驱动场景） #

如果你的Fragment涉及到数据处理、生命周期感知的逻辑，可以把通用的业务逻辑放到ViewModel中，基类Fragment绑定ViewModel，子类只负责UI和差异化逻辑。

这个方案适合有数据交互的场景，比如列表Fragment、带网络请求的Fragment，核心思路是：

• 通用ViewModel封装通用数据请求、数据处理逻辑
• 基类Fragment负责绑定ViewModel、通用UI更新
• 子类Fragment实现差异化的UI渲染、事件处理

总结 #

如果你的场景只是简单的2-3个差异化方法，**方案一（抽象基类）**是最直接高效的选择，代码结构清晰，维护起来也方便；如果后续可能需要动态切换差异化逻辑，或者不想用继承，**方案二（组合+辅助类）**会更灵活。

内容的提问来源于stack exchange，提问作者Víctor Martín