理解Fragment的生命周期

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

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

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

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

(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. 
   
2. 04-02 04:03:45.543: DEBUG/Fragments(2606): onPause
   
3. 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按钮将其删除。