Android Fragment 真正的彻底解析（下）

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/37992017

上篇博客中已经介绍了Fragment产生缘由，以及一些基本的用法和各类API，若是你还不了解，请看：Android Fragment 真正的彻底解析（上）。

本篇将介绍上篇博客提到的：如何管理Fragment回退栈，Fragment如何与Activity交互，Fragment与Activity交互的最佳实践，没有视图的Fragment的用处，使用Fragment建立对话框，如何与ActionBar，MenuItem集成等~~

一、管理Fragment回退栈

相似与Android系统为Activity维护一个任务栈，咱们也能够经过Activity维护一个回退栈来保存每次Fragment事务发生的变化。若是你将Fragment任务添加到回退栈，当用户点击后退按钮时，将看到上一次的保存的Fragment。一旦Fragment彻底从后退栈中弹出，用户再次点击后退键，则退出当前Activity。

看这样一个效果图：

点击第一个按钮，切换到第二个界面，点击第二个按钮，切换到第三个界面，而后点击Back键依次回退。这像不像初学Android时的Activity跳转，固然了，这里确定不是，否则我就跪了。这里是Fragment实现的，用户点击Back，实际是Fragment回退栈不断的弹栈。

如何添加一个Fragment事务到回退栈：

FragmentTransaction.addToBackStack(String)

下面讲解代码：很明显一共是3个Fragment和一个Activity.

先看Activity的布局文件：

[html] view plain copy

 

1. <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"  

2.     xmlns:tools="http://schemas.android.com/tools"  

3.     android:layout_width="match_parent"  

4.     android:layout_height="match_parent" >  

5.   

6.     <FrameLayout  

7.         android:id="@+id/id_content"  

8.         android:layout_width="fill_parent"  

9.         android:layout_height="fill_parent" >  

10.     </FrameLayout>  

11.   

12. </RelativeLayout>  

不一样的Fragment就在这个FrameLayout中显示。

MainActivity.java

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Activity;  

4. import android.app.FragmentManager;  

5. import android.app.FragmentTransaction;  

6. import android.os.Bundle;  

7. import android.view.Window;  

8.   

9. public class MainActivity extends Activity  

10. {  

11.   

12.   

13.     @Override  

14.     protected void onCreate(Bundle savedInstanceState)  

15.     {  

16.         super.onCreate(savedInstanceState);  

17.         requestWindowFeature(Window.FEATURE_NO_TITLE);  

18.         setContentView(R.layout.activity_main);  

19.   

20.         FragmentManager fm = getFragmentManager();  

21.         FragmentTransaction tx = fm.beginTransaction();  

22.         tx.add(R.id.id_content, new FragmentOne(),"ONE");  

23.         tx.commit();  

24.     }  

25.   

26. }  

很简单，直接将FragmentOne添加到布局文件中的FrameLayout中，注意这里并无调用FragmentTransaction.addToBackStack(String)，由于我不喜欢在当前显示时，点击Back键出现白板。而是正确的相应Back键，即退出咱们的Activity.

下面是FragmentOne

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Fragment;  

4. import android.app.FragmentManager;  

5. import android.app.FragmentTransaction;  

6. import android.os.Bundle;  

7. import android.view.LayoutInflater;  

8. import android.view.View;  

9. import android.view.View.OnClickListener;  

10. import android.view.ViewGroup;  

11. import android.widget.Button;  

12.   

13. public class FragmentOne extends Fragment implements OnClickListener  

14. {  

15.   

16.     private Button mBtn;  

17.   

18.     @Override  

19.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  

20.             Bundle savedInstanceState)  

21.     {  

22.         View view = inflater.inflate(R.layout.fragment_one, container, false);  

23.         mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn);  

24.         mBtn.setOnClickListener(this);  

25.         return view;  

26.     }  

27.   

28.     @Override  

29.     public void onClick(View v)  

30.     {  

31.         FragmentTwo fTwo = new FragmentTwo();  

32.         FragmentManager fm = getFragmentManager();  

33.         FragmentTransaction tx = fm.beginTransaction();  

34.         tx.replace(R.id.id_content, fTwo, "TWO");  

35.         tx.addToBackStack(null);  

36.         tx.commit();  

37.   

38.     }  

39.   

40. }  

咱们在点击FragmentOne中的按钮时，使用了replace方法，若是你看了前一篇博客，必定记得replace是remove和add的合体，而且若是不添加事务到回退栈，前一个Fragment实例会被销毁。这里很明显，咱们调用tx.addToBackStack(null);将当前的事务添加到了回退栈，因此FragmentOne实例不会被销毁，可是视图层次依然会被销毁，即会调用onDestoryView和onCreateView，证据就是：仔细看上面的效果图，咱们在跳转前在文本框输入的内容，在用户Back获得第一个界面的时候不见了。

接下来FragmentTwo

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Fragment;  

4. import android.app.FragmentManager;  

5. import android.app.FragmentTransaction;  

6. import android.os.Bundle;  

7. import android.view.LayoutInflater;  

8. import android.view.View;  

9. import android.view.View.OnClickListener;  

10. import android.view.ViewGroup;  

11. import android.widget.Button;  

12.   

13. public class FragmentTwo extends Fragment implements OnClickListener  

14. {  

15.   

16.     private Button mBtn ;  

17.     @Override  

18.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  

19.             Bundle savedInstanceState)  

20.     {  

21.         View view = inflater.inflate(R.layout.fragment_two, container, false);  

22.         mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn);  

23.         mBtn.setOnClickListener(this);  

24.         return view ;   

25.     }  

26.     @Override  

27.     public void onClick(View v)  

28.     {  

29.         FragmentThree fThree = new FragmentThree();  

30.         FragmentManager fm = getFragmentManager();  

31.         FragmentTransaction tx = fm.beginTransaction();  

32.         tx.hide(this);  

33.         tx.add(R.id.id_content , fThree, "THREE");  

34. //      tx.replace(R.id.id_content, fThree, "THREE");  

35.         tx.addToBackStack(null);  

36.         tx.commit();  

37.     }  

38.   

39.   

40. }  

这里点击时，咱们没有使用replace，而是先隐藏了当前的Fragment，而后添加了FragmentThree的实例，最后将事务添加到回退栈。这样作的目的是为了给你们提供一种方案：若是不但愿视图重绘该怎么作，请再次仔细看效果图，咱们在FragmentTwo的EditText填写的内容，用户Back回来时，数据还在~~~

最后FragmentThree就是简单的Toast了：

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Fragment;  

4. import android.os.Bundle;  

5. import android.view.LayoutInflater;  

6. import android.view.View;  

7. import android.view.View.OnClickListener;  

8. import android.view.ViewGroup;  

9. import android.widget.Button;  

10. import android.widget.Toast;  

11.   

12. public class FragmentThree extends Fragment implements OnClickListener  

13. {  

14.   

15.     private Button mBtn;  

16.   

17.     @Override  

18.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  

19.             Bundle savedInstanceState)  

20.     {  

21.         View view = inflater.inflate(R.layout.fragment_three, container, false);  

22.         mBtn = (Button) view.findViewById(R.id.id_fragment_three_btn);  

23.         mBtn.setOnClickListener(this);  

24.         return view;  

25.     }  

26.   

27.     @Override  

28.     public void onClick(View v)  

29.     {  

30.         Toast.makeText(getActivity(), " i am a btn in Fragment three",  

31.                 Toast.LENGTH_SHORT).show();  

32.     }  

33.   

34. }  

好了，通过上面的介绍，应该已经知道Fragment回退栈是怎么一回事了，以及hide，replace等各自的应用的场景。

这里极其注意一点：上面的总体代码不具备任何参考价值，纯粹为了显示回退栈，在后面讲解了Fragment与Activity通讯之后，会重构上面的代码！

二、Fragment与Activity通讯

由于全部的Fragment都是依附于Activity的，因此通讯起来并不复杂，大概概括为：

a、若是你Activity中包含本身管理的Fragment的引用，能够经过引用直接访问全部的Fragment的public方法

b、若是Activity中未保存任何Fragment的引用，那么不要紧，每一个Fragment都有一个惟一的TAG或者ID,能够经过getFragmentManager.findFragmentByTag()或者findFragmentById()得到任何Fragment实例，而后进行操做。

c、在Fragment中能够经过getActivity获得当前绑定的Activity的实例，而后进行操做。

注：若是在Fragment中须要Context，能够经过调用getActivity(),若是该Context须要在Activity被销毁后还存在，则使用getActivity().getApplicationContext()。

三、Fragment与Activity通讯的最佳实践

由于要考虑Fragment的重复使用，因此必须下降Fragment与Activity的耦合，并且Fragment更不该该直接操道别的Fragment，毕竟Fragment操做应该由它的管理者Activity来决定。

下面我经过两种方式的代码，分别重构，FragmentOne和FragmentTwo的点击事件，以及Activity对点击事件的响应：

首先看FragmentOne

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Fragment;  

4. import android.os.Bundle;  

5. import android.view.LayoutInflater;  

6. import android.view.View;  

7. import android.view.View.OnClickListener;  

8. import android.view.ViewGroup;  

9. import android.widget.Button;  

10.   

11. public class FragmentOne extends Fragment implements OnClickListener  

12. {  

13.     private Button mBtn;  

14.   

15.     /** 

16.      * 设置按钮点击的回调 

17.      * @author zhy 

18.      * 

19.      */  

20.     public interface FOneBtnClickListener  

21.     {  

22.         void onFOneBtnClick();  

23.     }  

24.   

25.     @Override  

26.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  

27.             Bundle savedInstanceState)  

28.     {  

29.         View view = inflater.inflate(R.layout.fragment_one, container, false);  

30.         mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn);  

31.         mBtn.setOnClickListener(this);  

32.         return view;  

33.     }  

34.   

35.     /** 

36.      * 交给宿主Activity处理，若是它但愿处理 

37.      */  

38.     @Override  

39.     public void onClick(View v)  

40.     {  

41.         if (getActivity() instanceof FOneBtnClickListener)  

42.         {  

43.             ((FOneBtnClickListener) getActivity()).onFOneBtnClick();  

44.         }  

45.     }  

46.   

47. }  

能够看到如今的FragmentOne不和任何Activity耦合，任何Activity均可以使用；而且咱们声明了一个接口，来回调其点击事件，想要管理其点击事件的Activity实现此接口就便可。能够看到咱们在onClick中首先判断了当前绑定的Activity是否实现了该接口，若是实现了则调用。

再看FragmentTwo

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Fragment;  

4. import android.os.Bundle;  

5. import android.view.LayoutInflater;  

6. import android.view.View;  

7. import android.view.View.OnClickListener;  

8. import android.view.ViewGroup;  

9. import android.widget.Button;  

10.   

11. public class FragmentTwo extends Fragment implements OnClickListener  

12. {  

13.   

14.       

15.     private Button mBtn ;  

16.       

17.     private FTwoBtnClickListener fTwoBtnClickListener ;  

18.       

19.     public interface FTwoBtnClickListener  

20.     {  

21.         void onFTwoBtnClick();  

22.     }  

23.     //设置回调接口  

24.     public void setfTwoBtnClickListener(FTwoBtnClickListener fTwoBtnClickListener)  

25.     {  

26.         this.fTwoBtnClickListener = fTwoBtnClickListener;  

27.     }  

28.     @Override  

29.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  

30.             Bundle savedInstanceState)  

31.     {  

32.         View view = inflater.inflate(R.layout.fragment_two, container, false);  

33.         mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn);  

34.         mBtn.setOnClickListener(this);  

35.         return view ;   

36.     }  

37.     @Override  

38.     public void onClick(View v)  

39.     {  

40.         if(fTwoBtnClickListener != null)  

41.         {  

42.             fTwoBtnClickListener.onFTwoBtnClick();  

43.         }  

44.     }  

45.   

46. }  

与FragmentOne极其相似，可是咱们提供了setListener这样的方法，意味着Activity不只须要实现该接口，还必须显示调用mFTwo.setfTwoBtnClickListener(this)。

最后看Activity :

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Activity;  

4. import android.app.FragmentManager;  

5. import android.app.FragmentTransaction;  

6. import android.os.Bundle;  

7. import android.view.Window;  

8.   

9. import com.zhy.zhy_fragments.FragmentOne.FOneBtnClickListener;  

10. import com.zhy.zhy_fragments.FragmentTwo.FTwoBtnClickListener;  

11.   

12. public class MainActivity extends Activity implements FOneBtnClickListener,  

13.         FTwoBtnClickListener  

14. {  

15.   

16.     private FragmentOne mFOne;  

17.     private FragmentTwo mFTwo;  

18.     private FragmentThree mFThree;  

19.   

20.     @Override  

21.     protected void onCreate(Bundle savedInstanceState)  

22.     {  

23.         super.onCreate(savedInstanceState);  

24.         requestWindowFeature(Window.FEATURE_NO_TITLE);  

25.         setContentView(R.layout.activity_main);  

26.   

27.         mFOne = new FragmentOne();  

28.         FragmentManager fm = getFragmentManager();  

29.         FragmentTransaction tx = fm.beginTransaction();  

30.         tx.add(R.id.id_content, mFOne, "ONE");  

31.         tx.commit();  

32.     }  

33.   

34.     /** 

35.      * FragmentOne 按钮点击时的回调 

36.      */  

37.     @Override  

38.     public void onFOneBtnClick()  

39.     {  

40.   

41.         if (mFTwo == null)  

42.         {  

43.             mFTwo = new FragmentTwo();  

44.             mFTwo.setfTwoBtnClickListener(this);  

45.         }  

46.         FragmentManager fm = getFragmentManager();  

47.         FragmentTransaction tx = fm.beginTransaction();  

48.         tx.replace(R.id.id_content, mFTwo, "TWO");  

49.         tx.addToBackStack(null);  

50.         tx.commit();  

51.     }  

52.   

53.     /** 

54.      * FragmentTwo 按钮点击时的回调 

55.      */  

56.     @Override  

57.     public void onFTwoBtnClick()  

58.     {  

59.         if (mFThree == null)  

60.         {  

61.             mFThree = new FragmentThree();  

62.   

63.         }  

64.         FragmentManager fm = getFragmentManager();  

65.         FragmentTransaction tx = fm.beginTransaction();  

66.         tx.hide(mFTwo);  

67.         tx.add(R.id.id_content, mFThree, "THREE");  

68.         // tx.replace(R.id.id_content, fThree, "THREE");  

69.         tx.addToBackStack(null);  

70.         tx.commit();  

71.     }  

72.   

73. }  

代码重构结束，与开始的效果如出一辙。上面两种通讯方式都是值得推荐的，随便选择一种本身喜欢的。这里再提一下：虽然Fragment和Activity能够经过getActivity与findFragmentByTag或者findFragmentById，进行任何操做，甚至在Fragment里面操做另外的Fragment，可是没有特殊理由是绝对不提倡的。Activity担任的是Fragment间相似总线同样的角色，应当由它决定Fragment如何操做。另外虽然Fragment不能响应Intent打开，可是Activity能够，Activity能够接收Intent，而后根据参数判断显示哪一个Fragment。

四、如何处理运行时配置发生变化

运行时配置发生变化，最多见的就是屏幕发生旋转，若是你不知道如何处理屏幕变化能够参考：Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案

这里提一下：不少人以为强制设置屏幕的方向就能够了，可是有一点，当你的应用被至于后台（例如用户点击了home），长时间没有返回的时候，你的应用也会被从新启动。好比上例：若是你把上面的例子你至于FragmentThree界面，而后处于后台状态，长时间后你会发现当你再次经过home打开时，上面FragmentThree与FragmentOne叠加在一块儿，这就是由于你的Activity从新启动，在原来的FragmentThree上又绘制了一个FragmentOne。

好了，下面看一段代码：

Activity:

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Activity;  

4. import android.app.FragmentManager;  

5. import android.app.FragmentTransaction;  

6. import android.os.Bundle;  

7. import android.view.Window;  

8.   

9. public class MainActivity extends Activity  

10.   

11. {  

12.     private FragmentOne mFOne;  

13.   

14.     @Override  

15.     protected void onCreate(Bundle savedInstanceState)  

16.     {  

17.         super.onCreate(savedInstanceState);  

18.         requestWindowFeature(Window.FEATURE_NO_TITLE);  

19.         setContentView(R.layout.activity_main);  

20.   

21.         mFOne = new FragmentOne();  

22.         FragmentManager fm = getFragmentManager();  

23.         FragmentTransaction tx = fm.beginTransaction();  

24.         tx.add(R.id.id_content, mFOne, "ONE");  

25.         tx.commit();  

26.   

27.     }  

28.   

29. }  

Fragment

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Fragment;  

4. import android.os.Bundle;  

5. import android.util.Log;  

6. import android.view.LayoutInflater;  

7. import android.view.View;  

8. import android.view.ViewGroup;  

9.   

10. public class FragmentOne extends Fragment  

11. {  

12.     private static final String TAG = "FragmentOne";  

13.   

14.     @Override  

15.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  

16.             Bundle savedInstanceState)  

17.     {  

18.         Log.e(TAG, "onCreateView");  

19.         View view = inflater.inflate(R.layout.fragment_one, container, false);  

20.         return view;  

21.     }  

22.   

23.     @Override  

24.     public void onCreate(Bundle savedInstanceState)  

25.     {  

26.         // TODO Auto-generated method stub  

27.         super.onCreate(savedInstanceState);  

28.   

29.         Log.e(TAG, "onCreate");  

30.     }  

31.   

32.     @Override  

33.     public void onDestroyView()  

34.     {  

35.         // TODO Auto-generated method stub  

36.         super.onDestroyView();  

37.         Log.e(TAG, "onDestroyView");  

38.     }  

39.   

40.     @Override  

41.     public void onDestroy()  

42.     {  

43.         // TODO Auto-generated method stub  

44.         super.onDestroy();  

45.         Log.e(TAG, "onDestroy");  

46.     }  

47.   

48. }  

很简单的代码，当你运行以后，不断的旋转屏幕，你会发现每旋转一次屏幕，屏幕上就多了一个FragmentOne的实例，而且后台log会打印出许多套生命周期的回调。

相似：

[html] view plain copy

 

1. 07-20 08:18:46.651: E/FragmentOne(1633): onCreate  

2. 07-20 08:18:46.651: E/FragmentOne(1633): onCreate  

3. 07-20 08:18:46.651: E/FragmentOne(1633): onCreate  

4. 07-20 08:18:46.681: E/FragmentOne(1633): onCreateView  

5. 07-20 08:18:46.831: E/FragmentOne(1633): onCreateView  

6. 07-20 08:18:46.891: E/FragmentOne(1633): onCreateView  

这是为何呢，由于当屏幕发生旋转，Activity发生从新启动，默认的Activity中的Fragment也会跟着Activity从新建立；这样形成当旋转的时候，自己存在的Fragment会从新启动，而后当执行Activity的onCreate时，又会再次实例化一个新的Fragment，这就是出现的缘由。

那么如何解决呢：

其实经过检查onCreate的参数Bundle savedInstanceState就能够判断，当前是否发生Activity的从新建立：

默认的savedInstanceState会存储一些数据，包括Fragment的实例：经过打印能够看出：

[java] view plain copy

 

1. 07-20 08:23:12.952: E/FragmentOne(1782): Bundle[{android:fragments=android.app.FragmentManagerState@40d0b7b8, android:viewHierarchyState=Bundle[{android:focusedViewId=2131230721, android:views=android.util.SparseArray@40d0af68}]}]  

因此，咱们简单改一下代码，只有在savedInstanceState==null时，才进行建立Fragment实例：

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Activity;  

4. import android.app.FragmentManager;  

5. import android.app.FragmentTransaction;  

6. import android.os.Bundle;  

7. import android.util.Log;  

8. import android.view.Window;  

9.   

10. public class MainActivity extends Activity  

11.   

12. {  

13.     private static final String TAG = "FragmentOne";  

14.     private FragmentOne mFOne;  

15.   

16.     @Override  

17.     protected void onCreate(Bundle savedInstanceState)  

18.     {  

19.         super.onCreate(savedInstanceState);  

20.         requestWindowFeature(Window.FEATURE_NO_TITLE);  

21.         setContentView(R.layout.activity_main);  

22.   

23.         Log.e(TAG, savedInstanceState+"");  

24.           

25.         if(savedInstanceState == null)  

26.         {  

27.             mFOne = new FragmentOne();  

28.             FragmentManager fm = getFragmentManager();  

29.             FragmentTransaction tx = fm.beginTransaction();  

30.             tx.add(R.id.id_content, mFOne, "ONE");  

31.             tx.commit();  

32.         }  

33.           

34.           

35.   

36.     }  

37.   

38. }  

如今不管进行屡次旋转都只会有一个Fragment实例在Activity中。

如今还存在一个问题，就是从新绘制时，Fragment发生重建，本来的数据如何保持？

其实和Activity相似，Fragment也有onSaveInstanceState的方法，在此方法中进行保存数据，而后在onCreate或者onCreateView或者onActivityCreated进行恢复均可以。

因为篇幅缘由，就不贴测试代码了。

五、Fragmeny与ActionBar和MenuItem集成

Fragment能够添加本身的MenuItem到Activity的ActionBar或者可选菜单中。

a、在Fragment的onCreate中调用 setHasOptionsMenu(true);

b、而后在Fragment子类中实现onCreateOptionsMenu

c、若是但愿在Fragment中处理MenuItem的点击，也能够实现onOptionsItemSelected；固然了Activity也能够直接处理该MenuItem的点击事件。

代码：

Fragment

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Fragment;  

4. import android.os.Bundle;  

5. import android.view.LayoutInflater;  

6. import android.view.Menu;  

7. import android.view.MenuInflater;  

8. import android.view.MenuItem;  

9. import android.view.View;  

10. import android.view.ViewGroup;  

11. import android.widget.Toast;  

12.   

13. public class FragmentOne extends Fragment  

14. {  

15.   

16.     @Override  

17.     public void onCreate(Bundle savedInstanceState)  

18.     {  

19.         super.onCreate(savedInstanceState);  

20.         setHasOptionsMenu(true);  

21.     }  

22.   

23.     @Override  

24.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  

25.             Bundle savedInstanceState)  

26.     {  

27.         View view = inflater.inflate(R.layout.fragment_one, container, false);  

28.         return view;  

29.     }  

30.   

31.     @Override  

32.     public void onCreateOptionsMenu(Menu menu, MenuInflater inflater)  

33.     {  

34.         inflater.inflate(R.menu.fragment_menu, menu);  

35.     }  

36.   

37.     @Override  

38.     public boolean onOptionsItemSelected(MenuItem item)  

39.     {  

40.         switch (item.getItemId())  

41.         {  

42.         case R.id.id_menu_fra_test:  

43.             Toast.makeText(getActivity(), "FragmentMenuItem1", Toast.LENGTH_SHORT).show();  

44.             break;  

45.         }  

46.         return true;  

47.     }  

48.   

49. }  

Activity

[java] view plain copy

 

1. package com.zhy.zhy_fragments;  

2.   

3. import android.app.Activity;  

4. import android.app.FragmentManager;  

5. import android.app.FragmentTransaction;  

6. import android.os.Bundle;  

7. import android.util.Log;  

8. import android.view.Menu;  

9. import android.view.MenuItem;  

10. import android.view.Window;  

11. import android.widget.Toast;  

12.   

13. public class MainActivity extends Activity  

14.   

15. {  

16.     private static final String TAG = "FragmentOne";  

17.     private FragmentOne mFOne;  

18.   

19.     @Override  

20.     protected void onCreate(Bundle savedInstanceState)  

21.     {  

22.         super.onCreate(savedInstanceState);  

23.         requestWindowFeature(Window.FEATURE_NO_TITLE);  

24.         setContentView(R.layout.activity_main);  

25.   

26.         Log.e(TAG, savedInstanceState + "");  

27.   

28.         if (savedInstanceState == null)  

29.         {  

30.             mFOne = new FragmentOne();  

31.             FragmentManager fm = getFragmentManager();  

32.             FragmentTransaction tx = fm.beginTransaction();  

33.             tx.add(R.id.id_content, mFOne, "ONE");  

34.             tx.commit();  

35.         }  

36.   

37.     }  

38.   

39.     @Override  

40.     public boolean onCreateOptionsMenu(Menu menu)  

41.     {  

42.         super.onCreateOptionsMenu(menu);  

43.         getMenuInflater().inflate(R.menu.main, menu);  

44.         return true;  

45.     }  

46.   

47.     @Override  

48.     public boolean onOptionsItemSelected(MenuItem item)  

49.     {  

50.         switch (item.getItemId())  

51.         {  

52.         case R.id.action_settings:  

53.             Toast.makeText(this, "setting", Toast.LENGTH_SHORT).show();  

54.             return true;  

55.         default:  

56.             //若是但愿Fragment本身处理MenuItem点击事件，必定不要忘了调用super.xxx  

57.             return super.onOptionsItemSelected(item);  

58.         }  

59.     }  

60.   

61. }  

效果图：

好了，能够很好的看到，Fragment能够添加MenuItem，也能够本身处理点击~~~

六、没有布局的Fragment的做用

没有布局文件Fragment其实是为了保存，当Activity重启时，保存大量数据准备的

请参考博客：Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案

七、使用Fragment建立对话框

这是Google推荐的方式，我也单独写过博客介绍，请参考：Android 官方推荐 : DialogFragment 建立对话框

好了，终于把Fragment相关的联系到一块儿了，上述基本包含了Fragment全部的用法~~~相信你们若是可以看完，必定有很多的收获~~~

有任何问题，欢迎留言~~~

两篇结束，相信你对Fragment已经有了必定的了解，那么在项目中的最佳实践是什么呢？请移步：Android Fragment 你应该知道的一切