Android Fragment（一）

Fragment官方文档（需要翻墙）

文章目录

Android Fragment（一）
一、关于Fragment
二、Fragment生命周期
- 1.onAttach()
- 2.onCreat()
- 3.onCreateView()
- 4.onActivityCreated()
- 5.onStart()
- 6.onResume()
- 7.onPause()
- 8.onStop
- 9.onDestroyView()
- 10.onDestroy()
- 11.onDetach()
三、Fragment加载方式
- 1.静态加载
- 2.动态加载

一、关于Fragment

Fragment 表示 FragmentActivity 中的行为或界面的一部分。可以在一个 Activity 中组合多个Fragment ，从而构建多窗格界面，并在多个 Activity 中重复使用某个Fragment 。可以将Fragment 视为 Activity 的模块化组成部分，它具有自己的生命周期，能接收自己的输入事件，并且您可以在 Activity 运行时添加或移除Fragment （这有点像可以在不同 Activity 中重复使用的“子 Activity”）。
Fragment 必须始终托管在 Activity 中，其生命周期直接受宿主 Activity 生命周期的影响。例如，当 Activity 暂停时，Activity 的所有Fragment也会暂停；当 Activity 被销毁时，所有Fragment也会被销毁。不过，当 Activity 正在运行（处于已恢复生命周期状态）时，可以独立操纵每个Fragment，如添加或移除Fragment。当执行此类片段事务时，也可将其添加到由 Activity 管理的返回栈 — Activity 中的每个返回栈条目都是一条已发生Fragment事务的记录。借助返回栈，用户可以通过按返回按钮撤消Fragment事务（后退）。
当将Fragment作为 Activity 布局的一部分添加时，其位于 Activity 视图层次结构的某个 ViewGroup 中，并且Fragment会定义其自己的视图布局。可以通过在 Activity 的布局文件中声明Fragment，将其作为元素插入您的 Activity 布局，或者通过将其添加到某个现有的 ViewGroup，利用应用代码将其插入布局

二、Fragment生命周期

1.onAttach()

/*** Called when a fragment is first attached to its context.* {@link #onCreate(Bundle)} will be called after this.*/@SuppressWarnings("deprecation")@MainThread@CallSuperpublic void onAttach(@NonNull Context context) {mCalled = true;final Activity hostActivity = mHost == null ? null : mHost.getActivity();if (hostActivity != null) {mCalled = false;onAttach(hostActivity);}}/*** Called when a fragment is first attached to its activity.* {@link #onCreate(Bundle)} will be called after this.** @deprecated See {@link #onAttach(Context)}.*/@SuppressWarnings({"unused", "DeprecatedIsStillUsed"})@Deprecated@MainThread@CallSuperpublic void onAttach(@NonNull Activity activity) {mCalled = true;}

onAttach 是Fragment 生命周期的第一步，它的作用

在Fragment 和 Activity 建立关联前调用（Activity 传递到此方法内）

通常在Activity 与Fragment 是宿主关系的时候，Activity 向Fragment 传递数据的时候使用

@Overridepublic void onAttach(@NonNull Context context) {super.onAttach(context);str = ((MainActivity) context).getStr();    // activity获取数据System.out.println(str);}

2.onCreat()

/*** Called to do initial creation of a fragment.  This is called after* {@link #onAttach(Activity)} and before* {@link #onCreateView(LayoutInflater, ViewGroup, Bundle)}.** <p>Note that this can be called while the fragment's activity is* still in the process of being created.  As such, you can not rely* on things like the activity's content view hierarchy being initialized* at this point.  If you want to do work once the activity itself is* created, add a {@link androidx.lifecycle.LifecycleObserver} on the* activity's Lifecycle, removing it when it receives the* {@link Lifecycle.State#CREATED} callback.** <p>Any restored child fragments will be created before the base* <code>Fragment.onCreate</code> method returns.</p>** @param savedInstanceState If the fragment is being re-created from* a previous saved state, this is the state.*/@MainThread@CallSuperpublic void onCreate(@Nullable Bundle savedInstanceState) {mCalled = true;restoreChildFragmentState(savedInstanceState);if (!mChildFragmentManager.isStateAtLeast(Fragment.CREATED)) {mChildFragmentManager.dispatchCreate();}}

fragment初次创建时调用。尽管它看起来像是Activity的OnCreate()函数，但这个只是用来创建Fragment的。此时的Activity还没有创建完成，因为我们的Fragment也是Activity创建的一部分。

3.onCreateView()

 /*** Called to have the fragment instantiate its user interface view.* This is optional, and non-graphical fragments can return null. This will be called between* {@link #onCreate(Bundle)} and {@link #onViewCreated(View, Bundle)}.* <p>A default View can be returned by calling {@link #Fragment(int)} in your* constructor. Otherwise, this method returns null.** <p>It is recommended to <strong>only</strong> inflate the layout in this method and move* logic that operates on the returned View to {@link #onViewCreated(View, Bundle)}.** <p>If you return a View from here, you will later be called in* {@link #onDestroyView} when the view is being released.** @param inflater The LayoutInflater object that can be used to inflate* any views in the fragment,* @param container If non-null, this is the parent view that the fragment's* UI should be attached to.  The fragment should not add the view itself,* but this can be used to generate the LayoutParams of the view.* @param savedInstanceState If non-null, this fragment is being re-constructed* from a previous saved state as given here.** @return Return the View for the fragment's UI, or null.*/@MainThread@Nullablepublic View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container,@Nullable Bundle savedInstanceState) {if (mContentLayoutId != 0) {return inflater.inflate(mContentLayoutId, container, false);}return null;}

在这个fragment构造它的用户接口视图(即布局)时调用。

4.onActivityCreated()

/*** Called when the fragment's activity has been created and this* fragment's view hierarchy instantiated.  It can be used to do final* initialization once these pieces are in place, such as retrieving* views or restoring state.  It is also useful for fragments that use* {@link #setRetainInstance(boolean)} to retain their instance,* as this callback tells the fragment when it is fully associated with* the new activity instance.  This is called after {@link #onCreateView}* and before {@link #onViewStateRestored(Bundle)}.** @param savedInstanceState If the fragment is being re-created from* a previous saved state, this is the state.** @deprecated use {@link #onViewCreated(View, Bundle)} for code touching* the Fragment's view and {@link #onCreate(Bundle)} for other initialization.* To get a callback specifically when a Fragment activity's* {@link Activity#onCreate(Bundle)} is called, register a* {@link androidx.lifecycle.LifecycleObserver} on the Activity's* {@link Lifecycle} in {@link #onAttach(Context)}, removing it when it receives the* {@link Lifecycle.State#CREATED} callback.*/@SuppressWarnings({"DeprecatedIsStillUsed", "unused"})@MainThread@CallSuper@Deprecatedpublic void onActivityCreated(@Nullable Bundle savedInstanceState) {mCalled = true;}

在Activity的OnCreate()结束后，会调用此方法。所以到这里的时候，Activity已经创建完成！在这个函数中才可以使用Activity的所有资源。

5.onStart()

/*** Called when the Fragment is visible to the user.  This is generally* tied to {@link Activity#onStart() Activity.onStart} of the containing* Activity's lifecycle.*/@MainThread@CallSuperpublic void onStart() {mCalled = true;}

当到OnStart()时，Fragment对用户就是可见的了。但用户还未开始与Fragment交互。在生命周期中也可以看到Fragment的OnStart()过程与Activity的OnStart()过程是绑定的。意义即是一样的。

6.onResume()

/*** Called when the fragment is visible to the user and actively running.* This is generally* tied to {@link Activity#onResume() Activity.onResume} of the containing* Activity's lifecycle.*/@MainThread@CallSuperpublic void onResume() {mCalled = true;}

当这个fragment对用户可见并且正在运行时调用。这是Fragment与用户交互之前的最后一个回调。从生命周期对比中，可以看到，Fragment的OnResume与Activity的OnResume是相互绑定的，意义是一样的。它依赖于包含它的activity的Activity.onResume。当OnResume()结束后，就可以正式与用户交互了。

7.onPause()

/*** Called when the Fragment is no longer resumed.  This is generally* tied to {@link Activity#onPause() Activity.onPause} of the containing* Activity's lifecycle.*/@MainThread@CallSuperpublic void onPause() {mCalled = true;}

此回调与Activity的OnPause()相绑定，与Activity的OnPause()意义一样。

8.onStop

/*** Called when the Fragment is no longer started.  This is generally* tied to {@link Activity#onStop() Activity.onStop} of the containing* Activity's lifecycle.*/@MainThread@CallSuperpublic void onStop() {mCalled = true;}

这个回调与Activity的OnStop()相绑定，意义一样。已停止的Fragment可以直接返回到OnStart()回调，然后调用OnResume()。

9.onDestroyView()

/*** Called when the view previously created by {@link #onCreateView} has* been detached from the fragment.  The next time the fragment needs* to be displayed, a new view will be created.  This is called* after {@link #onStop()} and before {@link #onDestroy()}.  It is called* <em>regardless</em> of whether {@link #onCreateView} returned a* non-null view.  Internally it is called after the view's state has* been saved but before it has been removed from its parent.*/@MainThread@CallSuperpublic void onDestroyView() {mCalled = true;}

如果Fragment即将被结束或保存，那么撤销方向上的下一个回调将是onDestoryView()。会将在onCreateView创建的视图与这个fragment分离。下次这个fragment若要显示，那么将会创建新视图。这会在onStop之后和onDestroy之前调用。这个方法的调用同onCreateView是否返回非null视图无关。它会潜在的在这个视图状态被保存之后以及它被它的父视图回收之前调用。

10.onDestroy()

  /*** Called when the fragment is no longer in use.  This is called* after {@link #onStop()} and before {@link #onDetach()}.*/@MainThread@CallSuperpublic void onDestroy() {mCalled = true;}

当这个fragment不再使用时调用。需要注意的是，它即使经过了onDestroy()阶段，但仍然能从Activity中找到，因为它还没有Detach。

11.onDetach()

   /*** Called when the fragment is no longer attached to its activity.  This* is called after {@link #onDestroy()}.*/@MainThread@CallSuperpublic void onDetach() {mCalled = true;}

Fragment生命周期中最后一个回调是onDetach()。调用它以后，Fragment就不再与Activity相绑定，它也不再拥有视图层次结构，它的所有资源都将被释放。

三、Fragment加载方式

1.静态加载

MainActivity.class

public class MainActivity extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.main_activity);}
}

main_activity.xml

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"android:id="@+id/container"android:layout_width="match_parent"android:layout_height="match_parent"><fragmentandroid:id="@+id/staticFragment"android:name="com.lw.fgmt.ui.StaticFragment"android:layout_width="match_parent"android:layout_height="match_parent"/></RelativeLayout>

StaticFragment.java

public class StaticFragment extends Fragment {@Nullable@Overridepublic View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {// Fragment的静态加载View view = inflater.inflate(R.layout.fragment_static, container, false);return view;}
}

fragment_static.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"android:layout_width="match_parent"android:layout_height="match_parent"android:background="#00ff00"><TextViewandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="fragment static load"android:textColor="#000000"android:textSize="25sp"/></LinearLayout>

2.动态加载

MainActivity.java

public class MainActivity extends AppCompatActivity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.main_activity);if (savedInstanceState == null) {getSupportFragmentManager().beginTransaction().replace(R.id.container, MainFragment.newInstance()).commit();}}
}