Fragment 与多屏适配

深入 Fragment 生命周期、FragmentManager 与 FragmentTransaction 操作、返回栈管理、Fragment 间通信与 ViewPager2 集成，构建灵活的多屏页面

学习目标

Fragment 是 Activity 中可复用的模块化 UI 片段，自 Android 3.0 引入以来已成为“平板适配、底部导航、滑动多页”等场景的核心组件。本章目标：

• 在 Logcat 中读懂 Fragment 与宿主 Activity 生命周期的联动；
• 用 FragmentTransaction 完成动态添加、替换、隐藏/显示；
• 正确管理 Fragment 返回栈，避免用户按返回键时出现非预期行为；
• 在多个 Fragment 之间安全地传递事件，避免直接强转导致耦合；
• 用 ViewPager2 + FragmentStateAdapter 构建带 Tab 的滑动多页。

Fragment 生命周期

1. 与 Activity 生命周期的关系

Fragment 的生命周期比 Activity 多出几个 Fragment 特有的回调，并与宿主 Activity 的回调一一联动：

public class HomeFragment extends Fragment {

    private static final String TAG = "FragmentLifecycle";

    @Override
    public void onAttach(@NonNull Context context) {
        super.onAttach(context);
        Log.d(TAG, "onAttach");
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG, "onCreate");
    }

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,
                             @Nullable Bundle savedInstanceState) {
        Log.d(TAG, "onCreateView");
        return inflater.inflate(R.layout.fragment_home, container, false);
    }

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        Log.d(TAG, "onViewCreated");
        // 在这里初始化 View 与监听器
    }

    @Override
    public void onViewStateRestored(@Nullable Bundle savedInstanceState) {
        super.onViewStateRestored(savedInstanceState);
        Log.d(TAG, "onViewStateRestored");
    }

    @Override
    public void onStart() {
        super.onStart();
        Log.d(TAG, "onStart");
    }

    @Override
    public void onResume() {
        super.onResume();
        Log.d(TAG, "onResume");
    }

    @Override
    public void onPause() {
        super.onPause();
        Log.d(TAG, "onPause");
    }

    @Override
    public void onStop() {
        super.onStop();
        Log.d(TAG, "onStop");
    }

    @Override
    public void onDestroyView() {
        super.onDestroyView();
        Log.d(TAG, "onDestroyView");
    }

    @Override
    public void onDestroy() {
        super.onDestroy();
        Log.d(TAG, "onDestroy");
    }

    @Override
    public void onDetach() {
        super.onDetach();
        Log.d(TAG, "onDetach");
    }
}

2. 关键回调说明

• onAttach：Fragment 关联到 Activity，可拿到 Context；
• onCreateView：创建布局，必须返回 View；
• onViewCreated：View 已创建完成，常用于初始化子 View 与绑定监听；
• onDestroyView：与 onCreateView 成对，常在此释放 ViewBinding 避免内存泄漏；
• onDetach：Fragment 与 Activity 解除关联，最晚触发。

3. 与 Activity 联动的顺序

新增 Fragment 时：Activity onCreate 完成后 → Fragment onAttach → onCreate → onCreateView → onViewCreated → onStart → onResume。

FragmentManager 与 FragmentTransaction

1. 获取 FragmentManager

// Activity 中
FragmentManager fm = getSupportFragmentManager();

// Fragment 中获取子 Fragment 管理器
FragmentManager childFm = getChildFragmentManager();

2. 常用操作：add / replace / remove / hide / show

public class MainActivity extends AppCompatActivity {

    private static final String TAG_HOME = "home";
    private static final String TAG_DETAIL = "detail";

    private void showHome() {
        HomeFragment fragment = new HomeFragment();
        getSupportFragmentManager().beginTransaction()
                .replace(R.id.fragment_container, fragment, TAG_HOME)
                .commit();
    }

    private void addDetailOnTop() {
        DetailFragment fragment = new DetailFragment();
        getSupportFragmentManager().beginTransaction()
                .add(R.id.fragment_container, fragment, TAG_DETAIL)
                .addToBackStack("detail_stack")
                .commit();
    }

    private void toggleVisibility(Fragment target, boolean show) {
        FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
        if (show) {
            ft.show(target);
        } else {
            ft.hide(target);
        }
        ft.commit();
    }
}

注意：add 与 replace 的核心区别——replace 会先把容器内已有 Fragment 全部移除（触发它们的 onDestroyView），再添加新的；add 则叠加在上层。需要保留隐藏 Fragment 的 View 状态时优先用 hide/show。

3. 提交方式：commit / commitNow / commitAllowingStateLoss

// 同步立即提交（仅适合在 onSaveInstanceState 之后不能再调用）
getSupportFragmentManager().executePendingTransactions();

ft.commit();              // 异步，最常用
ft.commitNow();           // 同步立即执行
ft.commitAllowingStateLoss(); // 在 onSaveInstanceState 之后也可提交

返回栈 addToBackStack

1. 把事务压入回退栈

getSupportFragmentManager().beginTransaction()
        .replace(R.id.fragment_container, new DetailFragment(), TAG_DETAIL)
        .addToBackStack("detail")
        .commit();

2. 在 Fragment 中处理返回键（Android 13+）

public class DetailFragment extends Fragment {

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        requireActivity().getOnBackPressedDispatcher().addCallback(this,
                new OnBackPressedCallback(true) {
                    @Override
                    public void handleOnBackPressed() {
                        if (canGoBack()) {
                            // 自定义返回逻辑
                            getParentFragmentManager().popBackStack();
                        } else {
                            setEnabled(false);
                            requireActivity().getOnBackPressedDispatcher().onBackPressed();
                        }
                    }
                });
    }
}

addCallback(this, ...) 传入 LifecycleOwner，Fragment 销毁时回调会自动注销，避免泄漏。

3. popBackStack 与 popBackStackImmediate

// 弹出栈顶事务
getParentFragmentManager().popBackStack();

// 弹出到指定 tag 之前
getParentFragmentManager().popBackStack("detail", FragmentManager.POP_BACK_STACK_INCLUSIVE);

Fragment 间通信

1. 反模式：直接强转 getActivity()

// 不要这样写！
((MainActivity) getActivity()).onSomethingHappened();

这样会导致 Fragment 强耦合到某个 Activity，无法复用到其他界面。

2. 方案 A：接口回调

public class ListFragment extends Fragment {

    public interface OnItemSelectedListener {
        void onItemSelected(String id);
    }

    private OnItemSelectedListener mListener;

    @Override
    public void onAttach(@NonNull Context context) {
        super.onAttach(context);
        if (context instanceof OnItemSelectedListener) {
            mListener = (OnItemSelectedListener) context;
        } else {
            throw new ClassCastException(context + " must implement OnItemSelectedListener");
        }
    }

    private void notifyItemSelected(String id) {
        if (mListener != null) mListener.onItemSelected(id);
    }

    @Override
    public void onDetach() {
        super.onDetach();
        mListener = null;
    }
}

// 宿主 Activity
public class MainActivity extends AppCompatActivity
        implements ListFragment.OnItemSelectedListener {

    @Override
    public void onItemSelected(String id) {
        showDetailFragment(id);
    }
}

3. 方案 B：共享 ViewModel（推荐）

public class SharedViewModel extends ViewModel {
    private final MutableLiveData<String> selectedId = new MutableLiveData<>();
    public LiveData<String> getSelectedId() { return selectedId; }
    public void select(String id) { selectedId.setValue(id); }
}

// 在 Activity 范围内共享，多个 Fragment 取同一个 ViewModel
public class ListFragment extends Fragment {
    private SharedViewModel mShared;

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        mShared = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);

        view.findViewById(R.id.btn).setOnClickListener(v ->
                mShared.select("item_001"));
    }
}

public class DetailFragment extends Fragment {
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        SharedViewModel shared = new ViewModelProvider(requireActivity())
                .get(SharedViewModel.class);
        shared.getSelectedId().observe(getViewLifecycleOwner(), id -> updateView(id));
    }
}

关键：requireActivity() 而不是 this，确保两个 Fragment 共享同一份 ViewModel 实例。

4. Fragment Result API（一次性事件）

// 接收方
getParentFragmentManager().setFragmentResultListener("request_key", this,
        (key, bundle) -> {
            String value = bundle.getString("result_value");
            // ...
        });

// 发送方
Bundle result = new Bundle();
result.putString("result_value", "hello");
getParentFragmentManager().setFragmentResult("request_key", result);

嵌套 Fragment

public class ParentFragment extends Fragment {

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);

        getChildFragmentManager().beginTransaction()
                .replace(R.id.child_container, new ChildFragment())
                .commit();
    }
}

嵌套 Fragment 使用 getChildFragmentManager()，不能使用宿主 Activity 的 FragmentManager。

ViewPager2 + Fragment

1. Gradle 依赖

dependencies {
    implementation 'androidx.viewpager2:viewpager2:1.1.0'
    implementation 'com.google.android.material:material:1.12.0'
}

2. FragmentStateAdapter 实现

public class TabPagerAdapter extends FragmentStateAdapter {

    private static final int PAGE_COUNT = 3;

    public TabPagerAdapter(@NonNull FragmentActivity activity) {
        super(activity);
    }

    @NonNull
    @Override
    public Fragment createFragment(int position) {
        switch (position) {
            case 0: return new HomeFragment();
            case 1: return new DiscoverFragment();
            case 2: return new ProfileFragment();
            default: throw new IllegalArgumentException("Invalid position " + position);
        }
    }

    @Override
    public int getItemCount() {
        return PAGE_COUNT;
    }
}

3. Activity 布局与代码

<!-- res/layout/activity_main.xml -->
<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <androidx.viewpager2.widget.ViewPager2
        android:id="@+id/view_pager"
        android:layout_width="0dp"
        android:layout_height="0dp"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintBottom_toTopOf="@id/bottom_nav"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />

    <com.google.android.material.bottomnavigation.BottomNavigationView
        android:id="@+id/bottom_nav"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        app:menu="@menu/bottom_menu"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintEnd_toEndOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout>

public class MainActivity extends AppCompatActivity {

    private ViewPager2 mViewPager;
    private BottomNavigationView mBottomNav;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        mViewPager = findViewById(R.id.view_pager);
        mBottomNav = findViewById(R.id.bottom_nav);

        mViewPager.setAdapter(new TabPagerAdapter(this));
        mViewPager.registerOnPageChangeCallback(new ViewPager2.OnPageChangeCallback() {
            @Override
            public void onPageSelected(int position) {
                mBottomNav.getMenu().getItem(position).setChecked(true);
            }
        });

        mBottomNav.setOnItemSelectedListener(item -> {
            int id = item.getItemId();
            if (id == R.id.nav_home) {
                mViewPager.setCurrentItem(0, false);
                return true;
            } else if (id == R.id.nav_discover) {
                mViewPager.setCurrentItem(1, false);
                return true;
            } else if (id == R.id.nav_profile) {
                mViewPager.setCurrentItem(2, false);
                return true;
            }
            return false;
        });
    }
}

4. TabLayout 联动

TabLayoutMediator mediator = new TabLayoutMediator(
        mTabLayout, mViewPager,
        (tab, position) -> tab.setText("Tab " + (position + 1))
);
mediator.attach();

常见坑与最佳实践

1. Fragment 构造函数传参：默认要求无参构造，否则在配置变更重建时会抛 Fragment.instantiate 异常。请用 Bundle 参数 + setArguments：

public static DetailFragment newInstance(String id) {
    DetailFragment f = new DetailFragment();
    Bundle args = new Bundle();
    args.putString("extra_id", id);
    f.setArguments(args);
    return f;
}

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    String id = getArguments() != null ? getArguments().getString("extra_id") : null;
}

2. 在 onCreate 中操作 View：Fragment 的 View 在 onCreateView 之后才创建。所有 findViewById 与 ViewBinding 绑定都应在 onViewCreated 中进行。

3. 使用 getViewLifecycleOwner() 而非 this：LiveData/Flow 观察应绑定到 View 的生命周期，避免 onDestroyView 后还接收回调更新已销毁的 View。

4. 多次 commit 同一事务：每次事务只能 commit 一次，重复 commit 会抛异常。需要再操作就开新事务。

5. 在 onSaveInstanceState 之后调用 commit：会抛 IllegalStateException。如确实需要提交，用 commitAllowingStateLoss，但要承担丢失状态的风险。

6. FragmentStateAdapter 与 FragmentPagerAdapter：ViewPager2 只能用 FragmentStateAdapter；旧 FragmentPagerAdapter 已废弃，且 Fragment 不会被回收，占用内存大。

7. 直接持有其他 Fragment 引用：会导致 Activity 重建后引用指向旧实例（已被销毁）。请通过 FragmentManager.findFragmentByTag 或共享 ViewModel 通信。

8. requireActivity() 与 requireContext()：Fragment 不在 attached 状态时会抛 IllegalStateException。在异步回调中使用时记得先判断 isAdded() 或 getContext() != null。

章节小结

• Fragment 生命周期与 Activity 联动，多出 onAttach/onCreateView/onViewCreated/onDestroyView/onDetach 等 View 阶段回调；
• add/replace/remove/hide/show 五大操作配合 commit/commitNow 控制事务提交时机；
• 返回栈 addToBackStack + OnBackPressedDispatcher 让 Fragment 也能响应返回键；
• 通信首选共享 ViewModel，旧项目可用接口回调；一次性事件用 Fragment Result API；
• ViewPager2 + FragmentStateAdapter + BottomNavigationView 是当前主流的滑动多页方案。

下一章预告

第 13 章将讲解 Intent 与页面跳转：显式 Intent 与隐式 Intent 的区别、IntentFilter、putExtra 传参、ActivityResult API、回传结果，以及深链接与 App Links 的接入方式。