理解Fragment的生命周期

与活动类似，Fragment也有自己的生命周期。理解Fragment的生命周期有助于在Fragment销毁时能恰当地保存其实例，然后在重新创建时能够将其恢复至之前的状态。

下面的“试一试”将研究Fragment的各种状态。

(1) 使用上一节创建的项目，向Fragment1.java文件中添加如下所示的粗体代码：

1. package net.learn2develop.Fragments;
2. import android.app.Activity;
3. import android.app.Fragment;
4. import android.os.Bundle;
5. import android.view.LayoutInflater;
6. import android.view.View;
7. import android.view.ViewGroup;
8. import android.util.Log;
9. public class Fragment1 extends Fragment {
10. 　　　
11. 　　　@Override
12. 　　　public void onAttach(Activity activity) {
13. 　　　　　super.onAttach(activity);
14. 　　　　　Log.d("Fragment 1", "onAttach");
15. 　　　}
16. 　　　
17. 　　　@Override
18. 　　　public void onCreate(Bundle savedInstanceState) {
19. 　　　　super.onCreate(savedInstanceState);
20. 　　　　Log.d("Fragment 1", "onCreate");
21. 　　　}
22. 　　　
23. 　　　@Override
24. 　　　public View onCreateView(LayoutInflater inflater,
25. 　　　ViewGroup container, Bundle savedInstanceState) {
26. 　　　　　Log.d("Fragment 1", "onCreateView");
27. 　　　　　
28. 　　　　　// Inflate the layout for this fragment
29. 　　　　　return Inflater.inflate(R.layout.fragment1,
30. 　　　　　　　container, false);
31. 　　　}
32. 　　　
33. 　　　@Override
34. 　　　public void onActivityCreated(Bundle savedInstanceState) {
35. 　　　　　super.onActivityCreated(savedInstanceState);
36. 　　　　　Log.d("Fragment 1", "onActivityCreated");
37. 　　　}
38. 　　　
39. 　　　@Override
40. 　　　public void onStart() {
41. 　　　　super.onStart();
42. 　　　　Log.d("Fragment 1", "onStart");
43. 　　　}
44. 　　　
45. 　　　@Override
46. 　　　public void onResume() {
47. 　　　　super.onResume();
48. 　　　　Log.d("Fragment 1", "onResume");
49. 　　　}
50. 　　　
51. 　　　@Override
52. 　　　public void onPause() {
53. 　　　　super.onPause();
54. 　　　　Log.d("Fragment 1", "onPause");
55. 　　　}
56. 　　　
57. 　　　@Override
58. 　　　public void onStop() {
59. 　　　　super.onStop();
60. 　　　　Log.d("Fragment 1", "onStop");
61. 　　　}
62. 　　　
63. 　　　@Override
64. 　　　public void onDestroyView() {
65. 　　　　super.onDestroyView();
66. 　　　　Log.d("Fragment 1", "onDestroyView");
67. 　　　}
68. 　　　
69. 　　　@Override
70. 　　　public void onDestroy() {
71. 　　　　super.onDestroy();
72. 　　　　Log.d("Fragment 1", "onDestroy");
73. 　　　}
74. 　　　
75. 　　　@Override
76. 　　　public void onDetach() {
77. 　　　　super.onDetach();
78. 　　　　Log.d("Fragment 1", "onDetach");
79. 　　　}
80. }
81. 　　　　　　　　

(2) 按下Ctrl+F11组合键将Android模拟器切换至landscape模式。

(3) 在Eclipse中按下F11键，在Android模拟器中调试应用。

(4) 当应用在模拟器中加载时，LogCat窗口中输出的内容如下所示(Window｜Show View｜LogCat)：

1. 04-02 06:55:38.953: DEBUG/Fragment 1(6818): onAttach
2. 04-02 06:55:38.953: DEBUG/Fragment 1(6818): onCreate
3. 04-02 06:55:38.963: DEBUG/Fragment 1(6818): onCreateView
4. 04-02 06:55:38.983: DEBUG/Fragment 1(6818): onActivityCreated
5. 04-02 06:55:38.983: DEBUG/Fragment 1(6818): onStart
6. 04-02 06:55:39.003: DEBUG/Fragment 1(6818): onResume

(5) 按下模拟器上的Home按钮。LogCat窗口中输出的内容如下所示：

1. 04-02 04:03:45.543: DEBUG/Fragments(2606): onPause
2. 04-02 04:03:47.394: DEBUG/Fragments(2606): onStop

(6) 在模拟器上单击屏幕右上角的Apps按钮再次启动应用。这一次，LogCat窗口中输出的内容如下所示：

1. 04-02 04:04:32.703: DEBUG/Fragments(2606): onStart
2. 04-02 04:04:32.703: DEBUG/Fragments(2606): onResume

(7) 最后，单击模拟器上的Back按钮。现在会看到如下输出：

1. 04-02 07:23:07.393: DEBUG/Fragment 1(7481): onPause
2. 04-02 07:23:07.393: DEBUG/Fragment 1(7481): onStop
3. 04-02 07:23:07.393: DEBUG/Fragment 1(7481): onDestroyView
4. 04-02 07:23:07.403: DEBUG/Fragment 1(7481): onDestroy
5. 04-02 07:23:07.413: DEBUG/Fragment 1(7481): onDetach

示例说明
与活动类似，Android中的Fragment也拥有自己的生命周期。如你所见，当创建Fragment时，它会经历如下状态：

1. onAttach()
2. onCreate()
3. onCreateView()
4. onActivityCreated()

当Fragment变为可见时，它会经历如下状态：

1. onStart()
2. onResume()

当Fragment进入后台模式时，它会经历如下状态：

1. onPause()
2. onStop()

当Fragment销毁时(当托管Fragment的活动销毁时)，它会经历如下状态：

1. onPause()
2. onStop()
3. onDestroyView()
4. onDestroy()
5. onDetach()

与活动类似，可以在如下状态中使用Bundle对象恢复Fragment实例：

1. onCreate()
2. onCreateView()
3. onActivityCreated()

Fragment所经历的大多数状态都类似于活动。然而，有些新状态却是其所独有的：

1. onAttached()—当Fragment关联到活动上时调用
2. onCreateView()—为Fragment创建视图时调用
3. onActivityCreated()—当活动的onCreate()方法返回时调用
4. onDestroyView()—当Fragment的视图被删除时调用
5. onDetach()—当Fragment脱离活动时调用

注
意一下活动与Fragment之间的一个主要差别。它动进入后台时，它会被放到后台栈中。这样当用户按下Back按钮时，活动就可以重新执行。但对于
Fragment来说，当进入到后台时，它们并不会被放到后台栈中。相对于将Fragment放到后台栈中来说，需要显式地在Fragment事务中调用
addToBackStack()方法，如下所示：

1. 　if (d.getWidth() > d.getHeight())
2. 　　　{
3. 　　　　　//---landscape mode---
4. 　　　　　Fragment1 fragment1 = new Fragment1();
5. 　　　　　fragmentTransaction.replace(
6. 　　　　　　　R.id.fragmentContainer, fragment1);
7. 　　　}
8. 　　　else
9. 　　　{
10. 　　　　　//---portrait mode---
11. 　　　　　Fragment2 fragment2 = new Fragment2();
12. 　　　　　fragmentTransaction.replace(
13. 　　　　　　　R.id.fragmentContainer, fragment2);
14. 　　　}
15. 　　　
16. 　　　//---add to the back stack---
17. 　　　fragmentTransaction.addToBackStack(null);
18. 　　　fragmentTransaction.commit();

上述代码确保当Fragment被添加到活动中后，用户可以单击Back按钮将其删除。