原文地址：https://mp.weixin.qq.com/s/dUuGSVhWinAnN9uMiBaXgw

導語 Fragment作爲Android最基本，最重要的基礎概念之一，在開發中經常會和他打交道。本文從爲什麼出現Fragment開始，介紹了Fragment相關的方方面面，包括Fragment的基本定義及使用、回退棧的內部實現、Fragment通信、DialogFragment、ViewPager+Fragment的使用、嵌套Fragment、懶加載等。

下文中FragmentDemo的源代碼地址：https://github.com/xiazdong/FragmentDemo

基本概念

Fragment，簡稱碎片，是Android 3.0（API 11）提出的，爲了兼容低版本，support-v4庫中也開發了一套Fragment API，最低兼容Android 1.6。

過去support-v4庫是一個jar包，24.2.0版本開始，將support-v4庫模塊化爲多個jar包，包含：support-fragment, support-ui, support-media-compat等，這麼做是爲了減少APK包大小，你需要用哪個模塊就引入哪個模塊。

如果想引入整個support-v4庫，則compile 'com.android.support:support-v4:24.2.1'，
如果只想引入support-fragment庫，則com.android.support:support-fragment:24.2.1。

因爲support庫是不斷更新的，因此建議使用support庫中的android.support.v4.app.Fragment，而不要用系統自帶的android.app.Fragment。而如果要使用support庫的Fragment，Activity必須要繼承FragmentActivity（AppCompatActivity是FragmentActivity的子類）。

Fragment官方的定義是：

A Fragment represents a behavior or a portion of user interface in an Activity. You can combine multiple fragments in a single activity to build a multi-pane UI and reuse a fragment in multiple activities. You can think of a fragment as a modular section of an activity, which has its own lifecycle, receives its own input events, and which you can add or remove while the activity is running.

根據上面的定義可知：

Fragment是依賴於Activity的，不能獨立存在的。
一個Activity裏可以有多個Fragment。
一個Fragment可以被多個Activity重用。
Fragment有自己的生命週期，並能接收輸入事件。
我們能在Activity運行時動態地添加或刪除Fragment。

Android 3.0系統只針對平板電腦，且閉源，那時候針對手機和針對平板是兩套源代碼，後來Android 4.0時整合了手機和平板的源碼，因此市面上很難看到Android 3.0系統。

Fragment的優勢有以下幾點：

模塊化（Modularity）：我們不必把所有代碼全部寫在Activity中，而是把代碼寫在各自的Fragment中。
可重用（Reusability）：多個Activity可以重用一個Fragment。
可適配（Adaptability）：根據硬件的屏幕尺寸、屏幕方向，能夠方便地實現不同的佈局，這樣用戶體驗更好。

Fragment核心的類有：

Fragment：Fragment的基類，任何創建的Fragment都需要繼承該類。
FragmentManager：管理和維護Fragment。他是抽象類，具體的實現類是FragmentManagerImpl。
FragmentTransaction：對Fragment的添加、刪除等操作都需要通過事務方式進行。他是抽象類，具體的實現類是BackStackRecord。
Nested Fragment（Fragment內部嵌套Fragment的能力）是Android 4.2提出的，support-fragment庫可以兼容到1.6。通過getChildFragmentManager()
能夠獲得管理子Fragment的FragmentManager，在子Fragment中可以通過getParentFragment()
獲得父Fragment。

基本使用

這裏給出Fragment最基本的使用方式。首先，創建繼承Fragment的類，名爲Fragment1：

public class Fragment1 extends Fragment{
    private static String ARG_PARAM = "param_key";
    private String mParam;
    private Activity mActivity;
    public void onAttach(Context context) {
        mActivity = (Activity) context;
        mParam = getArguments().getString(ARG_PARAM);  //獲取參數
    }
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View root = inflater.inflate(R.layout.fragment_1, container, false);
        TextView view = root.findViewById(R.id.text);
        view.setText(mParam);
        return root;
    }
    public static Fragment1 newInstance(String str) {
        Fragment1 frag = new Fragment1();
        Bundle bundle = new Bundle();
        bundle.putString(ARG_PARAM, str);
        fragment.setArguments(bundle);   //設置參數
        return fragment;
    }
}

Fragment有很多可以複寫的方法，其中最常用的就是onCreateView()
，該方法返回Fragment的UI佈局，需要注意的是inflate()
的第三個參數是false，因爲在Fragment內部實現中，會把該佈局添加到container中，如果設爲true，那麼就會重複做兩次添加，則會拋如下異常：

Caused by: java.lang.IllegalStateException: The specified child already has a parent. You must call removeView() on the child's parent first.

如果在創建Fragment時要傳入參數，必須要通過setArguments(Bundle bundle)
方式添加，而不建議通過爲Fragment添加帶參數的構造函數，因爲通過setArguments()
方式添加，在由於內存緊張導致Fragment被系統殺掉並恢復（re-instantiate）時能保留這些數據。官方建議如下：

It is strongly recommended that subclasses do not have other constructors with parameters, since these constructors will not be called when the fragment is re-instantiated.

我們可以在Fragment的onAttach()
中通過getArguments()
獲得傳進來的參數，並在之後使用這些參數。如果要獲取Activity對象，不建議調用getActivity()
，而是在onAttach()
中將Context對象強轉爲Activity對象。
創建完Fragment後，接下來就是把Fragment添加到Activity中。在Activity中添加Fragment的方式有兩種：

靜態添加：在xml中通過的方式添加，缺點是一旦添加就不能在運行時刪除。
動態添加：運行時添加，這種方式比較靈活，因此建議使用這種方式。

雖然Fragment能在XML中添加，但是這只是一個語法糖而已，Fragment並不是一個View，而是和Activity同一層次的。
這裏只給出動態添加的方式。首先Activity需要有一個容器存放Fragment，一般是FrameLayout，因此在Activity的佈局文件中加入FrameLayout：

<FrameLayout
    android:id="@+id/container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

然後在onCreate()中，通過以下代碼將Fragment添加進Activity中。

if (bundle == null) {
    getSupportFragmentManager().beginTransaction()
        .add(R.id.container, Fragment1.newInstance("hello world"), "f1")        //.addToBackStack("fname")
        .commit();
}

這裏需要注意幾點：

因爲我們使用了support庫的Fragment，因此需要使用getSupportFragmentManager()
獲取FragmentManager。
add()是對Fragment衆多操作中的一種，還有remove(), replace()等，第一個參數是根容器的id（FrameLayout的id，即”@id/container”），第二個參數是Fragment對象，第三個參數是fragment的tag名，指定tag的好處是後續我們可以通過Fragment1 frag = getSupportFragmentManager().findFragmentByTag("f1")從FragmentManager中查找Fragment對象。
在一次事務中，可以做多個操作，比如同時做add().remove().replace()。
commit()操作是異步的，內部通過mManager.enqueueAction()加入處理隊列。對應的同步方法爲commitNow()，commit()內部會有checkStateLoss()操作，如果開發人員使用不當（比如commit()操作在onSaveInstanceState()之後），可能會拋出異常，而commitAllowingStateLoss()方法則是不會拋出異常版本的commit()方法，但是儘量使用commit()
，而不要使用commitAllowingStateLoss()。
addToBackStack("fname")是可選的。FragmentManager擁有回退棧（BackStack），類似於Activity的任務棧，如果添加了該語句，就把該事務加入回退棧，當用戶點擊返回按鈕，會回退該事務（回退指的是如果事務是add(frag1)，那麼回退操作就是remove(frag1)）；如果沒添加該語句，用戶點擊返回按鈕會直接銷燬Activity。
Fragment有一個常見的問題，即Fragment重疊問題，這是由於Fragment被系統殺掉，並重新初始化時再次將fragment加入activity，因此通過在外圍加if語句能判斷此時是否是被系統殺掉並重新初始化的情況。

Fragment有個常見的異常：

java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState
    at android.support.v4.app.FragmentManagerImpl.checkStateLoss(FragmentManager.java:1341)
    at android.support.v4.app.FragmentManagerImpl.enqueueAction(FragmentManager.java:1352)
    at android.support.v4.app.BackStackRecord.commitInternal(BackStackRecord.java:595)
    at android.support.v4.app.BackStackRecord.commit(BackStackRecord.java:574)

該異常出現的原因是：commit()在onSaveInstanceState()後調用。首先，onSaveInstanceState()在onPause()之後，onStop()之前調用。onRestoreInstanceState()在onStart()之後，onResume()之前。

因此避免出現該異常的方案有：

不要把Fragment事務放在異步線程的回調中，比如不要把Fragment事務放在AsyncTask的onPostExecute()，因此onPostExecute()可能會在onSaveInstanceState()之後執行。
逼不得已時使用commitAllowingStateLoss()。

生命週期

Fragment的生命週期和Activity類似，但比Activity的生命週期複雜一些，基本的生命週期方法如下圖：

解釋如下：

onAttach()：Fragment和Activity相關聯時調用。可以通過該方法獲取Activity引用，還可以通過getArguments()獲取參數。
onCreate()：Fragment被創建時調用。
onCreateView()：創建Fragment的佈局。
onActivityCreated()：當Activity完成onCreate()時調用。
onStart()：當Fragment可見時調用。
onResume()：當Fragment可見且可交互時調用。
onPause()：當Fragment不可交互但可見時調用。
onStop()：當Fragment不可見時調用。
onDestroyView()：當Fragment的UI從視圖結構中移除時調用。
onDestroy()：銷燬Fragment時調用。
onDetach()：當Fragment和Activity解除關聯時調用。

上面的方法中，只有onCreateView()在重寫時不用寫super方法，其他都需要。

因爲Fragment是依賴Activity的，因此爲了講解Fragment的生命週期，需要和Activity的生命週期方法一起講，即Fragment的各個生命週期方法和Activity的各個生命週期方法的關係和順序，如圖：

image.png

我們這裏舉個例子來理解Fragment生命週期方法。功能如下：共有兩個Fragment：F1和F2，F1在初始化時就加入Activity，點擊F1中的按鈕調用replace替換爲F2。

當F1在Activity的onCreate()中被添加時，日誌如下：

BasicActivity: [onCreate] 
BEGINBasicActivity: [onCreate] END
BasicActivity: [onStart] BEGIN
Fragment1: [onAttach] BEGIN 
Fragment1: [onAttach] END
BasicActivity: [onAttachFragment] BEGIN
BasicActivity: [onAttachFragment] END
Fragment1: [onCreate] BEGIN
Fragment1: [onCreate] END
Fragment1: [onCreateView]
Fragment1: [onViewCreated] BEGIN
Fragment1: [onViewCreated] END
Fragment1: [onActivityCreated] BEGIN
Fragment1: [onActivityCreated] END
Fragment1: [onStart] BEGIN
Fragment1: [onStart] END
BasicActivity: [onStart] END
BasicActivity: [onPostCreate] BEGIN
BasicActivity: [onPostCreate] END
BasicActivity: [onResume] BEGIN
BasicActivity: [onResume] END
BasicActivity: [onPostResume] BEGIN
Fragment1: [onResume] BEGIN
Fragment1: [onResume] END
BasicActivity: [onPostResume] END
BasicActivity: [onAttachedToWindow] BEGIN
BasicActivity: [onAttachedToWindow] END

可以看出：

Fragment的onAttach()->onCreate()->onCreateView()->onActivityCreated()->onStart()都是在Activity的onStart()中調用的。
Fragment的onResume()在Activity的onResume()之後調用。

接下去分兩種情況，分別是不加addToBackStack()和加addToBackStack()。
1、當點擊F1的按鈕，調用replace()替換爲F2，且不加addToBackStack()時，日誌如下：

Fragment2: [onAttach] BEGIN
Fragment2: [onAttach] END
BasicActivity: [onAttachFragment] BEGIN
BasicActivity: [onAttachFragment] END
Fragment2: [onCreate] BEGIN
Fragment2: [onCreate] END
Fragment1: [onPause] BEGIN
Fragment1: [onPause] END
Fragment1: [onStop] BEGIN
Fragment1: [onStop] END
Fragment1: [onDestroyView] BEGIN
Fragment1: [onDestroyView] END
Fragment1: [onDestroy] BEGIN
Fragment1: [onDestroy] END
Fragment1: [onDetach] BEGIN
Fragment1: [onDetach] END
Fragment2: [onCreateView]
Fragment2: [onViewCreated] BEGIN
Fragment2: [onViewCreated] END
Fragment2: [onActivityCreated] BEGIN
Fragment2: [onActivityCreated] END
Fragment2: [onStart] BEGIN
Fragment2: [onStart] END
Fragment2: [onResume] BEGIN
Fragment2: [onResume] END

可以看到，F1最後調用了onDestroy()和onDetach()。

2、當點擊F1的按鈕，調用replace()替換爲F2，且加addToBackStack()時，日誌如下：

Fragment2: [onAttach] BEGIN
Fragment2: [onAttach] END
BasicActivity: [onAttachFragment] BEGIN
BasicActivity: [onAttachFragment] END
Fragment2: [onCreate] BEGIN
Fragment2: [onCreate] END
Fragment1: [onPause] BEGIN
Fragment1: [onPause] END
Fragment1: [onStop] BEGIN
Fragment1: [onStop] END
Fragment1: [onDestroyView] BEGIN
Fragment1: [onDestroyView] END
Fragment2: [onCreateView]
Fragment2: [onViewCreated] BEGIN
Fragment2: [onViewCreated] END
Fragment2: [onActivityCreated] BEGIN
Fragment2: [onActivityCreated] END
Fragment2: [onStart] BEGIN
Fragment2: [onStart] END
Fragment2: [onResume] BEGIN
Fragment2: [onResume] END

可以看到，F1被替換時，最後只調到了onDestroyView()，並沒有調用onDestroy()和onDetach()。當用戶點返回按鈕回退事務時，F1會調onCreateView()->onStart()->onResume()，因此在Fragment事務中加不加addToBackStack()會影響Fragment的生命週期。
FragmentTransaction有一些基本方法，下面給出調用這些方法時，Fragment生命週期的變化：

add(): onAttach()->…->onResume()。
remove(): onPause()->…->onDetach()。
replace(): 相當於舊Fragment調用remove()，新Fragment調用add()。
show(): 不調用任何生命週期方法，調用該方法的前提是要顯示的Fragment已經被添加到容器，只是純粹把Fragment UI的setVisibility爲true。
hide(): 不調用任何生命週期方法，調用該方法的前提是要顯示的Fragment已經被添加到容器，只是純粹把Fragment UI的setVisibility爲false。
detach(): onPause()->onStop()->onDestroyView()。UI從佈局中移除，但是仍然被FragmentManager管理。
attach(): onCreateView()->onStart()->onResume()。

Fragment實現原理和Back Stack

我們知道Activity有任務棧，用戶通過startActivity將Activity加入棧，點擊返回按鈕將Activity出棧。Fragment也有類似的棧，稱爲回退棧（Back Stack），回退棧是由FragmentManager管理的。默認情況下，Fragment事務是不會加入回退棧的，如果想將Fragment事務加入回退棧，則可以加入addToBackStack("")
。如果沒有加入回退棧，則用戶點擊返回按鈕會直接將Activity出棧；如果加入了回退棧，則用戶點擊返回按鈕會回滾Fragment事務。

我們將通過最常見的Fragment用法，講解Back Stack的實現原理：

getSupportFragmentManager().beginTransaction()
    .add(R.id.container, f1, "f1")
    .addToBackStack("")
    .commit();

上面這個代碼的功能就是將Fragment加入Activity中，內部實現爲：創建一個BackStackRecord對象，該對象記錄了這個事務的全部操作軌跡（這裏只做了一次add操作，並且加入回退棧），隨後將該對象提交到FragmentManager的執行隊列中，等待執行。

BackStackRecord類的定義如下

class BackStackRecord extends FragmentTransaction implements FragmentManager.BackStackEntry, Runnable {}

從定義可以看出，BackStackRecord有三重含義：

繼承了FragmentTransaction，即是事務，保存了整個事務的全部操作軌跡。
實現了BackStackEntry，作爲回退棧的元素，正是因爲該類擁有事務全部的操作軌跡，因此在popBackStack()時能回退整個事務。
繼承了Runnable，即被放入FragmentManager執行隊列，等待被執行。

先看第一層含義，getSupportFragmentManager.beginTransaction()
返回的就是BackStackRecord對象，代碼如下：

public FragmentTransaction beginTransaction() {
   return new BackStackRecord(this);
}

BackStackRecord類包含了一次事務的整個操作軌跡，是以鏈表形式存在的，鏈表的元素是Op類，表示其中某個操作，定義如下：

static final class Op {
    Op next; //鏈表後一個節點
    Op prev; //鏈表前一個節點
    int cmd;  //操作是add或remove或replace或hide或show等
    Fragment fragment; //對哪個Fragment對象做操作
}

我們來看下具體場景下這些類是怎麼被使用的，比如我們的事務做add操作。add函數的定義：

public FragmentTransaction add(int containerViewId, Fragment fragment, String tag) {
    doAddOp(containerViewId, fragment, tag, OP_ADD);
   return this;
}

doAddOp()方法就是創建Op對象，並加入鏈表，定義如下：

private void doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd) {
    fragment.mTag = tag;  //設置fragment的tag
    fragment.mContainerId = fragment.mFragmentId = containerViewId;  //設置fragment的容器id
    Op op = new Op();
    op.cmd = opcmd;
    op.fragment = fragment;
    addOp(op);
}

addOp()是將創建好的Op對象加入鏈表，定義如下：

void addOp(Op op) {
   if (mHead == null) {
        mHead = mTail = op;
    } else {
        op.prev = mTail;
        mTail.next = op;
        mTail = op;
    }
    mNumOp++;
}

addToBackStack(“”)是將mAddToBackStack變量記爲true，在commit()中會用到該變量。commit()是異步的，即不是立即生效的，但是後面會看到整個過程還是在主線程完成，只是把事務的執行扔給主線程的Handler，commit()內部是commitInternal()，實現如下：

int commitInternal(boolean allowStateLoss) {
    mCommitted = true;
   if (mAddToBackStack) {
        mIndex = mManager.allocBackStackIndex(this);
    } else {
        mIndex = -1;
    }
    mManager.enqueueAction(this, allowStateLoss); //將事務添加進待執行隊列中
    return mIndex;
}

如果mAddToBackStack爲true，則調用allocBackStackIndex(this)將事務添加進回退棧，FragmentManager類的變量ArrayListmBackStackIndices;就是回退棧。實現如下：

public int allocBackStackIndex(BackStackRecord bse) {
   if (mBackStackIndices == null) {
        mBackStackIndices = new ArrayList<BackStackRecord>();
   }
   int index = mBackStackIndices.size();
   mBackStackIndices.add(bse);
   return index;
}

在commitInternal()中，mManager.enqueueAction(this, allowStateLoss);是將BackStackRecord加入待執行隊列中，定義如下：

public void enqueueAction(Runnable action, boolean allowStateLoss) {
   if (mPendingActions == null) {
        mPendingActions = new ArrayList<Runnable>();
    }
    mPendingActions.add(action);
    if (mPendingActions.size() == 1) {
        mHost.getHandler().removeCallbacks(mExecCommit);
        mHost.getHandler().post(mExecCommit); //調用execPendingActions()執行待執行隊列的事務
    }
}

mPendingActions就是前面說的待執行隊列，mHost.getHandler()就是主線程的Handler，因此Runnable是在主線程執行的，mExecCommit的內部就是調用了execPendingActions()，即把mPendingActions中所有積壓的沒被執行的事務全部執行。執行隊列中的事務會怎樣被執行呢？就是調用BackStackRecord的run()方法，run()方法就是執行Fragment的生命週期函數，還有將視圖添加進container中。

與addToBackStack()對應的是popBackStack()，有以下幾種變種：

popBackStack()：將回退棧的棧頂彈出，並回退該事務。
popBackStack(String name, int flag)：name爲addToBackStack(String name)的參數，通過name能找到回退棧的特定元素，flag可以爲0或者FragmentManager.POP_BACK_STACK_INCLUSIVE，0表示只彈出該元素以上的所有元素，POP_BACK_STACK_INCLUSIVE表示彈出包含該元素及以上的所有元素。這裏說的彈出所有元素包含回退這些事務。
popBackStack()是異步執行的，是丟到主線程的MessageQueue執行，popBackStackImmediate()是同步版本。

我們通過講解Demo1來更清晰地瞭解回退棧的使用。功能如下：共有三個Fragment：F1, F2, F3，F1在初始化時就加入Activity，點擊F1中的按鈕跳轉到F2，點擊F2的按鈕跳轉到F3，點擊F3的按鈕回退到F1。

在Activity的onCreate()中，將F1加入Activity中：

getSupportFragmentManager().beginTransaction()
    .add(R.id.container, f1, "f1")
    .addToBackStack(Fragment1.class.getSimpleName())
    .commit();

F1按鈕的onClick()內容如下：

getFragmentManager().beginTransaction()
    .replace(R.id.container, f2, "f2")
    .addToBackStack(Fragment2.class.getSimpleName())
    .commit();

F2按鈕的onClick()如下：

getFragmentManager().beginTransaction()
    .replace(R.id.container, f3, "f3")
    .addToBackStack(Fragment3.class.getSimpleName())
    .commit();

F3按鈕的onClick()如下：

getFragmentManager().popBackStack(Fragment2.class.getSimpleName(), FragmentManager.POP_BACK_STACK_INCLUSIVE);

這樣就完成了整個界面的跳轉邏輯。

這裏補充一個點getSupportFragmentManager().findFragmentByTag()是經常用到的方法，他是FragmentManager的方法，FragmentManager是抽象類，FragmentManagerImpl是繼承FragmentManager的實現類，他的內部實現是：

class FragmentManagerImpl extends FragmentManager {
    ArrayList<Fragment> mActive;
    ArrayList<Fragment> mAdded;

    public Fragment findFragmentByTag(String tag) {
        if (mAdded != null && tag != null) {
            for (int i = mAdded.size() - 1; i >= 0; i--) {
                Fragment f = mAdded.get(i);
                if (f != null && tag.equals(f.mTag)) {
                    return f;
                }
            }
        }
        if (mActive != null && tag != null) {
            for (int i = mActive.size() - 1; i >= 0; i--) {
                Fragment f = mActive.get(i);
                if (f != null && tag.equals(f.mTag)) {
                    return f;
                }
            }
        }
        return null;
    }
}

從上面看到，先從mAdded中查找是否有該Fragment，如果沒找到，再從mActive中查找是否有該Fragment。mAdded是已經添加到Activity的Fragment的集合，mActive不僅包含mAdded，還包含雖然不在Activity中，但還在回退棧中的Fragment。

Fragment通信

Fragment向Activity傳遞數據

首先，在Fragment中定義接口，並讓Activity實現該接口（具體實現省略）：

public interface OnFragmentInteractionListener {
    void onItemClick(String str);  //將str從Fragment傳遞給Activity
}

在Fragment的onAttach()中，將參數Context強轉爲OnFragmentInteractionListener對象：

public void onAttach(Context context) {
    super.onAttach(context);
    if (context instanceof OnFragmentInteractionListener) {
        mListener = (OnFragmentInteractionListener) context;
    } else {
        throw new RuntimeException(context.toString() + " must implement OnFragmentInteractionListener");
    }
}

並在Fragment合適的地方調用mListener.onItemClick("hello")將”hello”從Fragment傳遞給Activity。

FABridge

由於通過接口的方式從Fragment向Activity進行數據傳遞比較麻煩，需要在Fragment中定義interface，並讓Activity實現該interface，FABridge(https://github.com/hongyangAndroid/FABridge)通過註解的形式免去了這些定義。

在build.gradle中添加依賴：

annotationProcessor 'com.zhy.fabridge:fabridge-compiler:1.0.0'compile 'com.zhy.fabridge:fabridge-api:1.0.0'

首先定義方法ID，這裏爲FAB_ITEM_CLICK，接着在Activity中定義接口：

@FCallbackId(id = FAB_ITEM_CLICK)
public void onItemClick(String str) {  //方法名任意
    Toast.makeText(this, str, Toast.LENGTH_SHORT).show();
}

最後，在Fragment中，通過以下形式調用”ID=FAB_ITEM_CLICK”的方法（該方法可能在Activity中，也可能在任何類中）：

Fabridge.call(mActivity,FAB_ITEM_CLICK,"data");  //調用ID對應的方法，"data"爲參數值

Activity向Fragment傳遞數據

Activity向Fragment傳遞數據比較簡單，獲取Fragment對象，並調用Fragment的方法即可，比如要將一個字符串傳遞給Fragment，則在Fragment中定義方法：

public void setString(String str) {
    this.str = str;
}

並在Activity中調用fragment.setString("hello")即可。

Fragment之間通信

由於Fragment之間是沒有任何依賴關係的，因此如果要進行Fragment之間的通信，建議通過Activity作爲中介，不要Fragment之間直接通信。

DialogFragment

DialogFragment是Android 3.0提出的，代替了Dialog，用於實現對話框。他的優點是：即使旋轉屏幕，也能保留對話框狀態。

如果要自定義對話框樣式，只需要繼承DialogFragment，並重寫onCreateView()，該方法返回對話框UI。這裏我們舉個例子，實現進度條樣式的圓角對話框。

public class ProgressDialogFragment extends DialogFragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        getDialog().requestWindowFeature(Window.FEATURE_NO_TITLE); //消除Title區域 
        getDialog().getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));  //將背景變爲透明
        setCancelable(false);  //點擊外部不可取消
        View root = inflater.inflate(R.layout.fragment_progress_dialog, container);
        return root;
    }

    public static ProgressDialogFragment newInstance() {
        return new ProgressDialogFragment();
    }
}

進度條動畫我們使用Lottie(https://github.com/airbnb/lottie-android)實現，Lottie動畫從這裏(https://www.lottiefiles.com/)找到。使用非常方便，只需要下載JSON動畫文件，然後在XML中寫入：

<com.airbnb.lottie.LottieAnimationView
    android:layout_width="wrap_content"  //大小根據JSON文件確定
    android:layout_height="wrap_content"
    app:lottie_fileName="loader_ring.json"   //JSON文件
    app:lottie_loop="true"    //循環播放
    app:lottie_autoPlay="true" />  //自動播放

然後通過下面代碼顯示對話框：

ProgressDialogFragment fragment = ProgressDialogFragment.newInstance();
fragment.show(getSupportFragmentManager(), "tag");//fragment.dismiss();

爲了實現圓角，除了在onCreateView()中把背景設爲透明，還需要對UI加入背景：

<shape xmlns:android="http://schemas.android.com/apk/res/android">
    <solid android:color="#ffffff"/>
    <corners android:radius="20dp"/>
</shape>

ViewPager+Fragment相關

基本使用

ViewPager是support v4庫中提供界面滑動的類，繼承自ViewGroup。PagerAdapter是ViewPager的適配器類，爲ViewPager提供界面。但是一般來說，通常都會使用PagerAdapter的兩個子類：FragmentPagerAdapter和FragmentStatePagerAdapter作爲ViewPager的適配器，他們的特點是界面是Fragment。

在support v13和support v4中都提供了FragmentPagerAdapter和FragmentStatePagerAdapter，區別在於：support v13中使用android.app.Fragment，而support v4使用android.support.v4.app.Fragment。一般都使用support v4中的FragmentPagerAdapter和FragmentStatePagerAdapter。

默認，ViewPager會緩存當前頁相鄰的界面，比如當滑動到第2頁時，會初始化第1頁和第3頁的界面（即Fragment對象，且生命週期函數運行到onResume()），可以通過setOffscreenPageLimit(count)設置離線緩存的界面個數。

FragmentPagerAdapter和FragmentStatePagerAdapter需要重寫的方法都一樣，常見的重寫方法如下：

public FragmentPagerAdapter(FragmentManager fm): 構造函數，參數爲FragmentManager。如果是嵌套Fragment場景，子 PagerAdapter的參數傳入getChildFragmentManager()。
Fragment getItem(int position): 返回第position位置的Fragment，必須重寫。
int getCount(): 返回ViewPager的頁數，必須重寫。
Object instantiateItem(ViewGroup container, int position): container是ViewPager對象，返回第position位置的Fragment。
void destroyItem(ViewGroup container, int position, Object object): container是ViewPager對象，object是Fragment對象。
getItemPosition(Object object): object是Fragment對象，如果返回POSITION_UNCHANGED，則表示當前Fragment不刷新，如果返回POSITION_NONE，則表示當前Fragment需要調用destroyItem()和instantiateItem()進行銷燬和重建。默認情況下返回POSITION_UNCHANGED。

懶加載

懶加載主要用於ViewPager且每頁是Fragment的情況，場景爲微信主界面，底部有4個tab，當滑到另一個tab時，先顯示”正在加載”，過一會纔會顯示正常界面。

默認情況，ViewPager會緩存當前頁和左右相鄰的界面。實現懶加載的主要原因是：用戶沒進入的界面需要有一系列的網絡、數據庫等耗資源、耗時的操作，預先做這些數據加載是不必要的。

這裏懶加載的實現思路是：用戶不可見的界面，只初始化UI，但是不會做任何數據加載。等滑到該頁，纔會異步做數據加載並更新UI。

這裏就實現類似微信那種效果，整個UI佈局爲：底部用PagerBottomTabStrip(https://github.com/tyzlmjj/PagerBottomTabStrip)項目實現，上面是ViewPager，使用FragmentPagerAdapter。邏輯爲：當用戶滑到另一個界面，首先會顯示正在加載，等數據加載完畢後（這裏用睡眠1秒鐘代替）顯示正常界面。

ViewPager默認緩存左右相鄰界面，爲了避免不必要的重新數據加載（重複調用onCreateView()），因爲有4個tab，因此將離線緩存的半徑設置爲3，即setOffscreenPageLimit(3)。

懶加載主要依賴Fragment的setUserVisibleHint(boolean isVisible)方法，當Fragment變爲可見時，會調用setUserVisibleHint(true)；當Fragment變爲不可見時，會調用setUserVisibleHint(false)，且該方法調用時機：

onAttach()之前，調用setUserVisibleHint(false)。
onCreateView()之前，如果該界面爲當前頁，則調用setUserVisibleHint(true)，否則調用setUserVisibleHint(false)。
界面變爲可見時，調用setUserVisibleHint(true)。*界面變爲不可見時，調用setUserVisibleHint(false)。

懶加載Fragment的實現：

public class LazyFragment extends Fragment {
    private View mRootView;
    private boolean mIsInited;
    private boolean mIsPrepared;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        mRootView = inflater.inflate(R.layout.fragment_lazy, container, false);
        mIsPrepared = true;
        lazyLoad();
        return mRootView;
    }

    public void lazyLoad() {
        if (getUserVisibleHint() && mIsPrepared && !mIsInited) {
            //異步初始化，在初始化後顯示正常UI
            loadData();
        }
    }

    private void loadData() {
        new Thread() {
            public void run() {
                //1. 加載數據
                //2. 更新UI
                //3. mIsInited = true
            }
        }.start();
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        if (isVisibleToUser) {
            lazyLoad();
        }
    }

    public static LazyFragment newInstance() {
        return new LazyFragment();
    }
}

注意點：

在Fragment中有兩個變量控制是否需要做數據加載：
- mIsPrepared：表示UI是否準備好，因爲數據加載後需要更新UI，如果UI還沒有inflate，就不需要做數據加載，因爲setUserVisibleHint()會在onCreateView()之前調用一次，如果此時調用，UI還沒有inflate，因此不能加載數據。
- mIsInited：表示是否已經做過數據加載，如果做過了就不需要做了。因爲setUserVisibleHint(true)在界面可見時都會調用，如果滑到該界面做過數據加載後，滑走，再滑回來，還是會調用setUserVisibleHint(true)，此時由於mIsInited=true，因此不會再做一遍數據加載。
lazyLoad()：懶加載的核心類，在該方法中，只有界面可見（getUserVisibleHint()==true）、UI準備好（mIsPrepared==true）、過去沒做過數據加載（mIsInited==false）時，才需要調loadData()做數據加載，數據加載做完後把mIsInited置爲true。

佈局XML主要分兩個container，一個是初始顯示的狀態，即R.id.container_empty，當數據加載完成，就顯示R.id.container：

<FrameLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent">
    <RelativeLayout
        android:id="@+id/container_empty"
        android:layout_width="match_parent"
        android:layout_height="match_parent">
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerInParent="true"
            android:text="正在加載"
            />
    </RelativeLayout>
    <RelativeLayout
        android:id="@+id/container"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="gone"
        >
        ... 
   </RelativeLayout>
</FrameLayout>

參考文獻

入門(https://www.raywenderlich.com/169885/android-fragments-tutorial-introduction-2)
教程1
(http://assets.en.oreilly.com/1/event/68/Fragments%20for%20All%20Presentation.pdf)
教程2
(http://vinsol.com/blog/2014/09/15/advocating-fragment-oriented-applications-in-android/)
生命週期(https://github.com/xxv/android-lifecycle)
detach vs remove
(https://stackoverflow.com/questions/9156406/whats-the-difference-between-detaching-a-fragment-and-removing-it)
Google I/O 2016: What the Fragment?(https://www.youtube.com/watch?v=k3IT-IJ0J98)
Google I/O 2017: Fragment Tricks
(https://www.youtube.com/watch?v=eUG3VWnXFtg)
mAdded和mActive的區別(https://stackoverflow.com/questions/25695960/difference-between-madded-mactive-in-source-code-of-support-fragmentmanager)
如何避免IllegalStateException異常(http://www.androiddesignpatterns.com/2013/08/fragment-transaction-commit-state-loss.html)

Android基礎：Fragment，看這篇就夠了

基本概念

基本使用

生命週期

Fragment實現原理和Back Stack

Fragment通信

Fragment向Activity傳遞數據

FABridge

Activity向Fragment傳遞數據

Fragment之間通信

DialogFragment

ViewPager+Fragment相關

基本使用

懶加載

Wireshark 安裝+使用（一）

博客園商業化之路-衆包平臺：繼續召集早期合作開發者

Android屏幕各尺寸的獲取方法詳解

ImageView常用屬性解析

Android中Display及DisplayMetrics理解

List和List的區別？

自定義控件詳解（三）：Canvas效果變換

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結