Fragment生命週期

與Activity類似，Fragment也存在如下狀態。

• 執行狀態：當前Fragment位於前臺，使用者可見，可以獲得焦點。
• 暫停：其他Activity位於前臺，該Fragment依然可見，只是不能獲得焦點。
• 停止狀態：該Fragment不可見，失去焦點。
• 銷燬狀態：該Fragment完全被刪除，或該Fragment所在的Activity被結束。

如下圖官方給出的Fragment生命週期圖：

• onAttach():當該Fragment被新增到Activity時被呼叫。該方法只會被呼叫一次。
• onCreate()：建立Fragment時被呼叫。該方法只會被呼叫一次。
• onCreateView()：每次建立、繪製該Fragment的View元件時回撥該方法，Fragment將會顯示該方法返回的View元件。
• onActivityCreated()：當Fragment所在的Activity被啟動完成後回撥該方法。
• onStart()：啟動Fragment時被回撥。
• onResume():恢復Fragment時被回撥。
• onPause()：暫停Fragment時被回撥。
• onStop():停止Fragment時被回撥。
• onDestroyView():銷燬該Fragment所包含的View元件時被呼叫。
• onDestroy():銷燬Fragment時被回撥。該方法之後被呼叫一次。
• onDetach():將該Fragment從Activity中刪除、替換完成時回撥該方法，在onDestroy()方法後一定會回撥onDetach()方法。該方法只會被呼叫一次。

從上圖可以看出：
1. 當使用Activity載入Fragment時，執行的函式為：
onAttach()
onCreate()
onCreateView()
onActivityCreated()
onStart()
onResume()

2.在Activity上啟動一個對話方塊，Activity將轉入暫停狀態時，Fragment也會進入暫停狀態。執行的函式為：onPause()

3.關閉對話方塊，Activity進入執行狀態，Fragment將會再次進入執行狀態，執行的函式為：onResume()
即由2到3，執行的函式為：onPause()—>onResume(),沒有重構介面佈局。因此，如果當按回退鍵，不想重構Fragment，要儲存原來Fragment中的資料，可以將Fragment隱藏(使用hide()函式)，處於暫定狀態

4.如上圖左邊那條流程線，替換Fragment不加入回退棧或按退出按鈕，則Fragment例項會被銷燬。執行的函式為：
onPause()
onStop()
onDestroyView()
onDestroy()
onDetach()

5.如上圖右邊的那條流程線，替換Fragment並加入回退棧，Fragment的例項不會銷燬，只會銷燬Fragment的介面佈局。執行的函式為：
onPause()
onStop()
onDestroyView()
當按下手機的回退鍵時，Fragment將會再次顯示出來，執行的函式為：
onCreateView()
onActivityCreated()
onStart()
onResume()

回退棧

介紹回退棧之前先介紹下Fragment家族常用的API：
Fragment常用的三個類：

• android.app.Fragment 主要用於定義Fragment

• android.app.FragmentManager 主要用於在Activity中操作Fragment

• android.app.FragmentTransaction 保證一些列Fragment操作的原子性，熟悉事務這個詞，一定能明白~

a、獲取FragmentManage的方式：

getFragmentManager() // v4中，getSupportFragmentManager

b、主要的操作都是FragmentTransaction的方法

• FragmentTransaction transaction = fm.benginTransatcion();//開啟一個事務

• transaction.add()： 往Activity中新增一個Fragment

• transaction.remove() ：從Activity中移除一個Fragment，如果被移除的Fragment沒有新增到回退棧，這個Fragment例項將會被銷燬。如果新增到回退棧，則這個Fragment的例項不會銷燬，但是它的佈局檢視會被銷燬。

• transaction.replace()：使用另一個Fragment替換當前的，實際上就是remove()然後add()的合體~

• transaction.hide()：隱藏當前的Fragment，僅僅是設為不可見，例項並不會銷燬，Fragment的佈局檢視也不會銷燬。

• transaction.show()：顯示之前隱藏的Fragment

• detach()：會將view從UI中移除,和remove()不同,此時fragment的狀態依然由FragmentManager維護。

• attach()：重建view檢視，附加到UI上並顯示。

• transatcion.commit()//提交一個事務

注意：常用Fragment的哥們，可能會經常遇到這樣Activity狀態不一致：State loss這樣的錯誤。主要是因為：commit方法一定要在Activity.onSaveInstance()之前呼叫。

上述，基本是操作Fragment的所有的方式了，在一個事務開啟到提交可以進行多個的新增、移除、替換等操作。

注：此處的FragmentTransaction(事務)是一個狀態變化的過程，如

// Create new fragment and transaction
Fragment newFragment = new ExampleFragment();
FragmentTransaction transaction = getFragmentManager().beginTransaction();

// Replace whatever is in the fragment_container view with this fragment,
// and add the transaction to the back stack
transaction.replace(R.id.fragment_container, newFragment);
transaction.addToBackStack(null);

// Commit the transaction
transaction.commit();

如上面程式碼，transaction只是記錄了從一個狀態到另一個狀態的變化過程，即比如從FragmentA替換到FragmentB的過程，當通過函式transaction.addToBackStack(null)將這個事務新增到回退棧，則會記錄這個事務的狀態變化過程，如從FragmentA —>FragmentB,當用戶點選手機回退鍵時，因為transaction的狀態變化過程被儲存，則可以將事務的狀態變化過程還原，即將FragmentB —> FragmentA.

新增到回退棧的函式：transaction.addToBackStack(null);
官方解釋為：

Before you call commit(), however, you might want to call addToBackStack(), in order to add the transaction to a back stack of fragment transactions. This back stack is managed by the activity and allows the user to return to the previous fragment state, by pressing the Back button.

For example, here’s how you can replace one fragment with another, and preserve the previous state in the back stack:

// Create new fragment and transaction
Fragment newFragment = new ExampleFragment();
FragmentTransaction transaction = getFragmentManager().beginTransaction();

// Replace whatever is in the fragment_container view with this fragment,
// and add the transaction to the back stack
transaction.replace(R.id.fragment_container, newFragment);
transaction.addToBackStack(null);

// Commit the transaction
transaction.commit();

In this example, newFragment replaces whatever fragment (if any) is currently in the layout container identified by the R.id.fragment_container ID. By calling addToBackStack(), the replace transaction is saved to the back stack so the user can reverse the transaction and bring back the previous fragment by pressing the Back button.

當Activity的回退棧中沒有事務時，在按返回鍵則會退出Activity。

類似與Android系統為Activity維護一個任務棧，我們也可以通過Activity維護一個回退棧來儲存每次Fragment事務發生的變化。如果你將Fragment任務新增到回退棧，當用戶點選後退按鈕時，將看到上一次的儲存的Fragment。一旦Fragment完全從後退棧中彈出，使用者再次點選後退鍵，則退出當前Activity。

Demo:看如下效果

在文字框中輸入”one”,點選按鈕，切換到第二個介面; 在文字框中輸入”two”,點選按鈕，切換到第三個介面；點選按鈕出現Toast提示訊息；然後點選Back鍵依次回退到FragmentTwo,文字框中的資料”two”還存在，再次點選Back鍵會退到FragmentOne,文字框中的資料”one”不存在了。

程式碼：一共3個Fragment和一個Activity

先看Activity：activity_main.xml

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

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

不同的Fragment就在這個FrameLayout中顯示。

MainActivity.java

public class MainActivity extends Activity {

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

        FragmentManager fragmentManager = getFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

        FragmentOne fragmentOne = new FragmentOne();
        fragmentTransaction.add(R.id.frameLayout,fragmentOne,"One");
        fragmentTransaction.commit();
    }
}

很簡單，直接將FragmentOne新增到佈局檔案中的FrameLayout中，注意這裡並沒有呼叫FragmentTransaction.addToBackStack(String)，因為我不喜歡在當前顯示時，點選Back鍵出現白板。而正確的時點選相應Back鍵，即退出我們的Activity.

下面時3個Fragment的佈局檔案，大體相同，就只寫一個，fragment_one.xml：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.example.songxitang.fragmenttest.FragmentOne">

    <EditText
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />

    <Button
        android:id="@+id/fragOneBtn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center"
        android:text="FragmentOne"
        android:textAllCaps="false" />
</LinearLayout>

FragmentOne.java

public class FragmentOne extends Fragment {
    private Button fragOneBtn;

    public FragmentOne() {
        // Required empty public constructor
    }


    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_one, container, false);
        fragOneBtn = (Button) view.findViewById(R.id.fragOneBtn);
        fragOneBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                FragmentTwo fragmentTwo = new FragmentTwo();
                FragmentManager fragmentManager = getFragmentManager();
                FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
                fragmentTransaction.replace(R.id.frameLayout,fragmentTwo,"Two");
                //將事務新增到回退棧中
                fragmentTransaction.addToBackStack("FragmentTwo");
                fragmentTransaction.commit();
            }
        });
        return view;
    }
}

我們在點選FragmentOne中的按鈕時，使用了replace方法，replace是remove和add的合體，並且如果不新增事務到回退棧，前一個Fragment例項會被銷燬。這裡很明顯，我們呼叫tx.addToBackStack(null);將當前的事務新增到了回退棧，所以FragmentOne例項不會被銷燬，但是檢視層次依然會被銷燬，即會呼叫onDestoryView和onCreateView，證據就是：仔細看上面的效果圖，我們在跳轉前在文字框輸入的內容，在使用者Back得到第一個介面的時候不見了。

FragmentTwo.java

public class FragmentTwo extends Fragment {
    private Button fragTwoBtn;

    public FragmentTwo() {
        // Required empty public constructor
    }
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_two, container, false);
        fragTwoBtn = (Button) view.findViewById(R.id.fragTwoBtn);
        fragTwoBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                FragmentThree fragmentThree = new FragmentThree();
                FragmentManager fragmentManager = getFragmentManager();
                FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
                fragmentTransaction.hide(FragmentTwo.this);
                fragmentTransaction.add(R.id.frameLayout,fragmentThree,"Three");
                fragmentTransaction.addToBackStack(null);
                fragmentTransaction.commit();
            }
        });
        return view;
    }
}

這裡點選時，我們沒有使用replace，而是先隱藏了當前的Fragment，然後添加了FragmentThree的例項，最後將事務新增到回退棧。這樣做的目的是為了給大家提供一種方案：如果不希望檢視重繪該怎麼做，請再次仔細看效果圖，我們在FragmentTwo的EditText填寫的內容，使用者Back回來時，資料還在~~~

最後FragmentThree就是簡單的Toast了,FragmentThree.java:

public class FragmentThree extends Fragment {
    private Button fragThreeBtn;

    public FragmentThree() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_three, container, false);
        fragThreeBtn = (Button) view.findViewById(R.id.fragThreeBtn);
        fragThreeBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(getActivity(),"I am a Button in FragmentThree!"
                ,Toast.LENGTH_LONG).show();
            }
        });
        return view;
    }
}

值得注意的是：如果你喜歡使用Fragment，一定要清楚這些方法，哪個會銷燬檢視，哪個會銷燬例項，哪個僅僅只是隱藏，這樣才能更好的使用它們。

a、比如：我在FragmentA中的EditText填了一些資料，當切換到FragmentB時，如果希望會到A還能看到資料，則適合你的就是hide和show；也就是說，希望保留使用者操作的面板，你可以使用hide和show，當然了不要使勁在那new例項，進行下非null判斷。

b、再比如：我不希望保留使用者操作，你可以使用remove()，然後add()；或者使用replace()這個和remove,add是相同的效果。

c、remove和detach有一點細微的區別，在不考慮回退棧的情況下，remove會銷燬整個Fragment例項，而detach則只是銷燬其檢視結構，例項並不會被銷燬。那麼二者怎麼取捨使用呢？如果你的當前Activity一直存在，那麼在不希望保留使用者操作的時候，你可以優先使用detach。

程式碼下載