Fragment


 


一、Fragment的概念和用法：


（一）、概念：
        Fragment是在Android 3.0 (API level 11)开始引入新的API技术。
        为了提高代码重用性和改善用户体验，我们将Activity中的UI组件进行分组和模块化管理。这些分组后的UI组件就是Fragment。
        一个Activity页面中可以包含多个Fragment模块，而同一个Fragment模块也可以被多个Activity使用。每个Fragment有自己的布局，有自己的生命周期。虽然Fragment拥有自己的生命周期，但因为Fragment必须被嵌入到Activity中使用，因此Fragment的生命周期是受其Activity宿主的生命周期所控制的。当Activity暂停时，该Activtiy内的所有Fragment都会暂停；当Activity被销毁时，该Activity内的所有Fragment都会被销毁。






（二）、Fragment为什么能改善用户体验，另外Fragment能用于平板电脑，那么普通的手机屏幕适用吗？




下图是一个“AndroidManual学习手册浏览界面”的效果图：







      


  如上图所示，“平板电脑”中，在一个Activity布局中放了两个Fragment：左侧是文章标题列表Fragment，右侧是文章内容展示的Fragment。左侧的标题列表不变，点击每条列表项，右侧的文章内容发生变化。点击和浏览内容都在同一个页面中发生，避免了页面切换和点击“返回键”返回的操作。用户感觉自然方便和快捷。
        那么Fragment组件适用于普通屏幕的手机吗？答案是肯定的。Fragment本身是可复用的组件。是否在一个Activity页面中放置多个Fragment取决了屏幕的大小，如果屏幕大小不够，那么就可以在Activity A中只包含Fragment A，在Activity B中只包含Fragment
 B，点击A中的item跳转到B就可以。








（三）、Fragment要点：【重点】
    1、Fragment作为Activity界面的一部分组成出现；
    2、可以在一个Activity中同时出现多个Fragment，并且，一个Fragment亦可在多个Activity中使用；
    3、在Activity运行过程中，可以添加、移除、替换、隐藏、显示Fragment（add()、remove()、replace()、hide()、show()）；
    4、Fragment可以响应自己的输入事件，并且有自己的生命周期，当然，它们的生命周期直接受其所属的宿主Activity的生命周期控制。


    5、FragmenetTransaction的方法：


使用add()加入fragment时将触发onAttach(),使用attach()不会触发onAttach()
使用replace()替换后会将之前的fragment的view从viewtree中删除
触发顺序:
detach()->onPause()->onStop()->onDestroyView()
attach()->onCreateView()->onActivityCreated()->onStart()->onResume()
使用hide()方法只是隐藏了fragment的view并没有将view从viewtree中删除,随后可用show()方法将view设置为显示
而使用detach()会将view从viewtree中删除,和remove()不同,此时fragment的状态依然保持着,在使用 attach()时会再次调用onCreateView()来重绘视图,注意使用detach()后fragment.isAdded()方法将返回  false,在使用attach()还原fragment后isAdded()会依然返回false(需要再次确认)
执行detach()和replace()后要还原视图的话, 可以在相应的fragment中保持相应的view,并在onCreateView()方法中通过view的parent的removeView()方法将view和parent的关联删除后返回







（四）、Fragment家族常用的API

1、Fragment常用的三个类：


android.app.Fragment 主要用于定义Fragment 
android.app.FragmentManager 主要用于在Activity中操作Fragment 
android.app.FragmentTransaction  





2、获取FragmentManage的方式：
getFragmentManager() // v4中，getSupportFragmentManager




3、主要的操作都是FragmentTransaction的方法
    FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务



transaction.add()      往Activity中添加一个Fragment 
transaction.remove()    从Activity中移除一个Fragment，如果被移除的Fragment没有添加到回退栈，这个Fragment实例将会被销毁。
transaction.replace()    使用另一个Fragment替换当前的，实际上就是remove()+add()的合体 
transaction.hide()    隐藏当前的Fragment，仅仅是设为不可见，并不会销毁 
transaction.show()   显示之前隐藏的Fragment 
transaction.detach()    会将view从UI中移除，和remove()不同，此时fragment的状态依然由FragmentManager维护
transaction.attach()     重建view视图，附加到UI上并显示 
transatcion.commit()    提交一个事务
fragment.isAdded()  判断一个Fragment是否已经被添加到事务中 



二、Fragment生命周期：

（一）、Fragment基本状态：

    1、活动状态：Resumed   当前Fragment位于前台，用户可见，可以获得焦点；

    2、暂停状态：  Paused   另一个Activity处于前台并拥有焦点,
 但是该Fragment所在的Activity仍然可见(前台Activity局部透明或者没有覆盖整个屏幕)，不过不能获得焦点；

    3、停止状态：Stopped

要么是宿主Activity已经被停止, 要么是Fragment从Activity被移除但被添加到回退栈中；

停止状态的Fragment仍然活着(所有状态和成员信息被系统保持着)。 然而, 它对用户不再可见, 并且如果Activity被销毁，它也会被销毁；

    4、销毁状态：Destroyed  只能等待被回收。



（二）、Fragment生命周期：【重点】








方法

描述



onAttach(Activity)

当前Fragment与Activity关联，调用！




onCreate()

完成fragment的初始化创建









onCreateView()

创建并返回与当前fragment相关联的层次视图view









onActivityCreated()

主activity的onCreate()执行完后，该方法才执行









onStart()

fragment可见，当主activity处于started状态后执行














onResume()

fragment能与用户交互，当主activity处于resumed状态后执行














onPause()

fragment不在与用户交互，可能在主activity将要处于paused前执行，可能该fragment被修改









onStop()

fragment不在可见，可能在主activity将要处于stopped前执行，可能该fragment被修改









onDestroyView()

允许该fragment清理视图相关资源




onDestroy()

清理掉视图state信息




onDetach()

该fragment不在于activity关联






1、onAttach(): 当该Fragment被添加到Activity时被回调。该方法只会被调用一次；

2、onCreate():  当创建Fragment时被回调。该方法只会被调用一次；

3、onCreateView()：每次创建、绘制该Fragment的View组件时回调该方法，Fragment将会显示该方法返回的View 组件；

4、onActivityCreated(): 当Fragment的宿主Activity被启动完成后回调该方法；

5、onStart(): 启动Fragment时被回调；

6、onResume():  onStart()方法后一定会回调onResume()方法；

7、onPause(): 暂停Fragment时被回调；

8、onStop(): 停止Fragment时被回调；

9、onDestroyView():  销毁该Fragment所包含的View组件时调用；

10、onDestroy():  销毁Fragment时被回调。该方法只会被调用一次；

11、onDetach():  将Fragment从Activity中删除、替换完成时调用该方法。onDestroy()方法后一定会回调onDetach()方法。该方法只会被调用一次。

12、onInflate():  

13、onViewCreated(): 



【备注：】其中大多数程序必须实现Fragment的三个回调方法分别为： 

onCreate ：系统创建Fragments 时调用，可做执行初始化工作或者当程序被暂停或停止时用来恢复状态，跟Activity 中的onCreate相当。  

onCreateView ：用于首次绘制用户界面的回调方法，必须返回要创建的Fragment 视图UI。假如你不希望提供Fragment用户界面则可以返回NULL。  

onPause ： 当用户离开这个Fragment的时候调用，这时你要提交任何应该持久的变化，因为用户可能不会回来。



（三）、示例代码：

1、Fragment的布局文件:







<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"



android:layout_width="match_parent"



android:layout_height="match_parent"



android:orientation="vertical">









<TextView



android:id="@+id/text_leftfragment_info"



android:layout_width="wrap_content"



android:layout_height="wrap_content"



android:text="这是leftFragment中的textview"/>





</LinearLayout>





2、MainActivity的布局文件:







<RelativeLayoutxmlns: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">



<fragment



android:id="@+id/fragment_left_newstitle"



android:layout_width="wrap_content"



android:layout_height="wrap_content"



android:name="com.steven.android24_fragmentlifecycle.LeftFragment"/>



</RelativeLayout>





3、Fragment文件中的java代码:



publicclass LeftFragment extends Fragment
 {



privatestaticfinal String TAG = "LeftFragment";



@Override



publicvoid onInflate(Activity
 activity, AttributeSet attrs,



Bundle savedInstanceState) {



Log.i(TAG, "==onInflate()执行了");



super.onInflate(activity, attrs, savedInstanceState);



}









@Override



publicvoid onAttach(Activity
 activity) {



Log.i(TAG, "==onAttach()执行了");



super.onAttach(activity);



}









@Override



publicvoid onCreate(Bundle
 savedInstanceState) {



Log.i(TAG, "==onCreate()执行了");



super.onCreate(savedInstanceState);



}









@Override



public View onCreateView(LayoutInflater inflater,
 ViewGroup container,



Bundle savedInstanceState) {



Log.i(TAG, "==onCreateView()执行了");



// inflater.inflate(resource, null);



return inflater.inflate(R.layout.fragment_left,
 container, false);



}









@Override



publicvoid onViewCreated(View
 view, Bundle savedInstanceState) {



Log.i(TAG, "==onViewCreated()执行了");



super.onViewCreated(view, savedInstanceState);



}









@Override



publicvoid onActivityCreated(Bundle
 savedInstanceState) {



Log.i(TAG, "==onActivityCreated()执行了");



super.onActivityCreated(savedInstanceState);



}









@Override



publicvoid onStart()
 {



Log.i(TAG, "==onStart()执行了");



super.onStart();



}









@Override



publicvoid onResume()
 {



Log.i(TAG, "==onResume()执行了");



super.onResume();



}









@Override



publicvoid onPause()
 {



Log.i(TAG, "==onPause()执行了");



super.onPause();



}









@Override



publicvoid onStop()
 {



Log.i(TAG, "==onStop()执行了");



super.onStop();



}









@Override



publicvoid onDestroyView()
 {



Log.i(TAG, "==onDestroyView()执行了");



super.onDestroyView();



}









@Override



publicvoid onDestroy()
 {



Log.i(TAG, "==onDestroy()执行了");



super.onDestroy();



}









@Override



publicvoid onDetach()
 {



Log.i(TAG, "==onDetach()执行了");



super.onDetach();



}









@Override



publicvoid onCreateOptionsMenu(Menu
 menu, MenuInflater inflater) {



super.onCreateOptionsMenu(menu, inflater);



}









@Override



publicvoid onCreateContextMenu(ContextMenu
 menu, View v,



ContextMenuInfo menuInfo) {



super.onCreateContextMenu(menu, v, menuInfo);



}

}







（四）、运行结果观察：

    1、第一次加载Fragment：



    2、在MainActivity中，点击“返回键”退出程序：



    3、在MainActivity中，点击“HOME键”退出程序：

【备注：】请注意第二种和第三种情况的区别。如果点HOME键退出，则少调用了onDestroyView()、onDestroy()、onDetach()三个回调方法。



    4、点击“下一页”，进入NextActivity页面：



    5、在NextActivity页面中，点击“HOME键”退出程序：



    6、上次HOME键退出后，重新进入程序：【因为上次是从NextActivity页面按HOME退出，所以此时直接进入 NextActivity页面 】





（五）、跟Fragment生命周期相关的其他方法：

1、onInflate()：在onCreate()方法之前调用，这时窗体上的控件都没有被创建，所以不能通过getActivity().findViewById()，因为此时getActivity()返回null。

2、onViewCreated()：在onCreateView()方法后会立刻调用onViewCreated()方法。通常在该方法中完成创建Fragment的最后工作，然后系统就开始调用onCreate()方法对窗体初始化。







（六）、如果Activity生命周期和Fragment生命周期的Log都开启，那么依次会如何输出信息呢？



1、第一次加载MainActivity页面：



2、在MainActivity页面中，点击“返回键”退出程序：



   3、在MainActivity中，点击“HOME键”退出程序：



【备注：】请同学们注意观察Activity回调方法和Fragment回调方法执行的顺序。请设想各种操作步骤，写出生命周期回调方法执行的顺序。



【特别强调：】

当Activity的onCreate()方法中，如果将Log的位置放在setContentView(R.layout.activity_main)之前，那么Activity的onCreate()方法就会在最先执行，如果将日志写在setContentView(R.layout.activity_main)之后，那么Activity的onCreate()方法就会在Fragment的onViewCreated()之后执行。





4、分析生命周期执行过程的案例：

开启一个包含有Fragment的Activity页面，然后点击“返回键”退出，然后再次启动该Activity页面，请描述完整的生命周期回调方法。

参考答案：



04:36:31.282: MainActivity: ==onCreate()

04:36:31.502: LeftFragment: ==onInflate()执行了

04:36:31.502: LeftFragment: ==onAttach()执行了

04:36:31.513: LeftFragment: ==onCreate()执行了

04:36:31.513: LeftFragment: ==onCreateView()执行了

04:36:31.533: LeftFragment: ==onViewCreated()执行了

04:36:31.542: LeftFragment: ==onActivityCreated()执行了

04:36:31.542: MainActivity: ==onStart()

04:36:31.552: LeftFragment: ==onStart()执行了

04:36:31.563: MainActivity: ==onResume()

04:36:31.563: LeftFragment: ==onResume()执行了

04:37:20.133: LeftFragment: ==onPause()执行了

04:37:20.142: MainActivity: ==onPause()

04:37:21.932: LeftFragment: ==onStop()执行了

04:37:21.932: MainActivity: ==onStop()

04:37:21.942: LeftFragment: ==onDestroyView()执行了

04:37:21.952: LeftFragment: ==onDestroy()执行了

04:37:21.952: LeftFragment: ==onDetach()执行了

04:37:21.952: MainActivity: ==onDestroy()

04:39:20.763: MainActivity: ==onCreate()

04:39:21.552: LeftFragment: ==onInflate()执行了

04:39:21.635: LeftFragment: ==onAttach()执行了

04:39:21.635: LeftFragment: ==onCreate()执行了

04:39:21.652: LeftFragment: ==onCreateView()执行了

04:39:21.652: LeftFragment: ==onViewCreated()执行了

04:39:21.842: LeftFragment: ==onActivityCreated()执行了

04:39:21.842: MainActivity: ==onStart()

04:39:21.908: LeftFragment: ==onStart()执行了

04:39:21.912: MainActivity: ==onResume()

04:39:21.932: LeftFragment: ==onResume()执行了

三、创建Fragment：

（一）、创建Fragment的步骤：【只需要两步】

1、创建一个Fragment，必须继承Fragment 这个基类或其子类；

        【备注：】除了继承基类 Fragment , 还有一些子类你可能会继承，是哪些子类呢？

DialogFragment





































显示一个浮动的对话框.  用这个类来创建一个对话框,是使用在Activity类的对话框工具方法之外的一个好的选择,因为你可以将一个fragment对话框合并到activity管理的fragment
 back stack中,允许用户返回到一个之前曾被摒弃的fragment.
ListFragment




显示一个由一个adapter(例如 SimpleCursorAdapter)管理的项目的列表, 类似于ListActivity。它提供一些方法来管理一个list view, 例如 onListItemClick()回调来处理点击事件.
PreferenceFragment




显示一个 Preference对象的层次结构的列表, 类似于PreferenceActivity。这在为你的应用创建一个"设置"activity时有用处.

2、实现回调方法：

        Fragment类的代码看起来很像 Activity 。它包含了和activity类似的回调方法， 例如onCreate()、 onStart()、onPause()以及 onStop()。事实上,，如果你准备将一个现成的Android应用转换到使用Fragment，可能只需要将代码从你的Activity的回调方法中分别移动到你的Fragment的回调方法即可。

        通常，应当至少实现如下的生命周期方法：

onCreate()

当创建fragment时, 系统调用该方法. 

在实现代码中,应当初始化想要在fragment中保持的必要组件, 当fragment被暂停或者停止后可以恢复.

onCreateView()

fragment第一次绘制它的用户界面的时候, 系统会调用此方法. 为了绘制fragment的UI,此方法必须返回一个View,
 这个view是你的fragment布局的根view. 如果fragment不提供UI, 可以返回null.

onPause()

用户将要离开fragment时,系统调用这个方法作为第一个指示(然而它不总是意味着fragment将被销毁.) 。在当前用户会话结束之前,通常应当在这里提交任何应该持久化的变化(因为用户有可能不会返回).

    【备注：】对于大部分Fragment而言，通常实现三个回调方法即可。但是实际开发中可以根据需要重写Fragment生命周期中的任意回调方法。    





（二）、Fragment实例：

1、描述：以“ 影视介绍 ”为例，无需页面切换，点击左侧影视名称，在右侧区域显示影视内容介绍。

2、主页面布局及Fragment布局文件代码：



//activity_main.xml布局文件：

<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"



android:layout_width="fill_parent"



android:layout_height="fill_parent">





<fragment



android:id="@+id/fragment_left_title"



android:layout_width="0dp"



android:layout_height="fill_parent"



android:layout_weight="1"



class="com.steven.android24_fragmentmovie.LeftFragment"/>



<fragment



android:id="@+id/fragment_right_detail"



android:layout_width="0dp"



android:layout_height="fill_parent"



android:layout_weight="3"



class="com.steven.android24_fragmentmovie.RightFragment"/>



</LinearLayout>









//LeftFragment的布局文件：





<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"



android:layout_width="match_parent"



android:layout_height="match_parent"



android:orientation="vertical">



<ListView



android:id="@+id/listView_fragment_left"



android:layout_width="match_parent"



android:layout_height="wrap_content">



</ListView>



</LinearLayout>









//RightFragment的布局文件：



<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"



android:layout_width="match_parent"



android:layout_height="match_parent"



android:orientation="vertical">



<TextView



android:id="@+id/text_fragment_right"



android:layout_width="wrap_content"



android:layout_height="wrap_content"



android:text="请点击左侧列表"/>



</LinearLayout>





【备注：】

<fragment>标签的android:id 和 android:tag属性必须至少有一个，同一个xml文件中id或tag必须唯一；

<fragment>标签的class 和 android:name属性功能完全相同，使用其中任何一个即可。



3、LeftFragment核心代码：



publicclass
 LeftFragment extends
 Fragment {



private
 ListView listView_fragment_left;



private
 String[] arr_data =
new
 String[] { "扫毒",
" 功夫战斗机",
"顶楼的大象",
"狂爱恶徒",



"兽性窥视",
"新金瓶梅" };



private
 TextView text_fragment_right;







@Override



public
 View onCreateView(LayoutInflater inflater, ViewGroup container,



Bundle savedInstanceState) {



View view = inflater.inflate(R.layout.fragment_left,
null);





listView_fragment_left = (ListView) view



.findViewById(R.id.listView_fragment_left);









ArrayAdapter<String> adapter =
new
 ArrayAdapter<String>(getActivity(),



android.R.layout.simple_list_item_1,
arr_data);



listView_fragment_left.setAdapter(adapter);









listView_fragment_left



.setOnItemClickListener(new
 OnItemClickListener() {









@Override



publicvoid
 onItemClick(AdapterView<?> parent, View view,



int
 position, long
 id) {



InputStream is;



ByteArrayOutputStream baos =
new
 ByteArrayOutputStream();



String data =
"";



try
 {



is = getActivity().getResources().getAssets()



.open("movie"
 + position + ".txt");



byte[]
 buffer = newbyte[1024];



int
 c = 0;



while
 ((c = is.read(buffer)) != -1) {



baos.write(buffer, 0, c);



baos.flush();



}



data =
new
 String(baos.toByteArray(), "utf-8");



}
catch
 (IOException e) {



e.printStackTrace();



}









TextView text_fragment_right = (TextView) getActivity()



.findViewById(R.id.text_fragment_right);



if
 (text_fragment_right != null)
 {



text_fragment_right.setText(data);









}
else
 {



Intent intent =
new
 Intent(getActivity(),



DetailActivity.class);



intent.putExtra("detail",
 data);



startActivity(intent);



}



}



});









return
 view;



}



}



【备注：】本例子中的数据源是assets目录下的文本文件。通过本例，也复习了assets资产文件的访问方式。



4、平板和手机适配：

如果想在平板和手机中显示不同的效果。则可以新建布局目录：layout-sw600dp.





三、动态创建Fragment：

（一）、概念：

如果将Fragment写在布局文件中，那么就是静态创建fragment；如果没有在布局文件中写<fragment>标签，而是在java文件中通过实例化Fragment创建Fragment的方式就是动态创建Fragment。



（二）、动态创建Fragment的步骤：

1、步骤：





2、Activity布局文件代码：



<LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"



android:layout_width="fill_parent"



android:layout_height="fill_parent"



android:orientation="vertical">









<Button



android:id="@+id/button_main_submit"



android:layout_width="wrap_content"



android:layout_height="wrap_content"



android:onClick="clickButton"



android:text="点击发送消息"/>



<!-- fragment



android:id="@+id/fragment_content"



android:layout_width="wrap_content"



android:layout_height="wrap_content"



android:name="com.steven.android24_fragmentarguments.DetailFragment" /-->







<LinearLayout



android:id="@+id/layout_container_fragment"



android:layout_width="match_parent"



android:layout_height="wrap_content"



android:orientation="horizontal">



</LinearLayout>





</LinearLayout>





3、MainActivity文件代码：



FragmentManager manager =
getFragmentManager();

DetailFragment fragment = new DetailFragment();



FragmentTransaction transaction =
manager.beginTransaction();

transaction.add(R.id.layout_container_fragment, fragment, "content_fragment");

transaction.commit();





四、Activity与Fragment之间的数据交互：

（一）、Activity向Fragment传递数据：Arguments

1、做法：

        可以通过Fragment.setArguments()方法向Fragment传递数据，并且通过getArguments()方法获取传递的数据。



2、MainActivity文件代码：



publicclass
 MainActivity extends
 Activity {



privatestaticfinal
 String TAG
 = "MainActivity";









@Override



protectedvoid
 onCreate(Bundle savedInstanceState) {



super.onCreate(savedInstanceState);



setContentView(R.layout.activity_main);









Log.i(TAG,
"==onCreate()执行");



FragmentManager manager = getFragmentManager();









DetailFragment fragment =
new
 DetailFragment();



Bundle bundle =
new
 Bundle();



bundle.putString("msg",
"Hello Fragment!!!");



fragment.setArguments(bundle);









FragmentTransaction transaction = manager.beginTransaction();



transaction.add(R.id.layout_container_fragment,
 fragment,



"content_fragment");



transaction.commit();



}



}





3、DetailFragment文件代码：



publicclass
 DetailFragment extends
 Fragment {



private
 TextView text_fragment_detail;

private
 Button button_fragment_get;





@Override



publicvoid
 onAttach(Activity activity) {



super.onAttach(activity);



Log.i("DetailFragment",
"==onAttach()");

}







@Override



publicvoid
 onCreate(Bundle savedInstanceState) {



super.onCreate(savedInstanceState);



}







@Override



public
 View onCreateView(LayoutInflater inflater, ViewGroup container,



Bundle savedInstanceState) {



View view = inflater



.inflate(R.layout.fragment_detail,
 container, false);



text_fragment_detail = (TextView) view



.findViewById(R.id.text_fragment_detail);







button_fragment_get = (Button) view

.findViewById(R.id.button_fragment_get);







Bundle bundle = getArguments();



if
 (bundle != null)
 {



text_fragment_detail.setText(bundle.getString("msg"));



}
else
 {



text_fragment_detail.setText("没有收到信息！");

}



return
 view;



}



}







4、注意事项：

Supply the construction arguments for this fragment. This can only be called before the fragment has been attached to its activity; that is, you should call it immediately after constructing the fragment.
 The arguments supplied here will be retained across fragment destroy and creation.

翻译：setArguments(bundle)为fragment提供构造的参数。它只能在fragment回调onAttach()方法之前调用。就是说，你应该在构造完fragment之后立刻调用它。提供的这些参数将在Fragment被销毁前一直保留。

在布局文件中使用<fragment>标签声明的Fragment（也就是静态生成的Fragment），都不能使用setArguments方法设置Bundle对象。



（二）、Fragment向宿主Activity回传信息：（Fragment回调机制）

1、原则：

Fragment类要尽量保证其独立性，Fragment类中不应该有访问其他Fragment和Activity中资源的代码，否则这个Fragment就不能在不改动代码的情况下用在其他地方。

如何让多个Fragment之间可以独立多次使用，而不是紧密地绑定到一起？通常的做法就是在Fragment类中编写一个接口，然后在该Fragment的宿主窗口类中实现该接口。这样Fragment与其宿主就实现了信息交互。





2、Fragment接口回调的步骤：（五步曲）

在Fragment文件中定义接口：OnItemClickedListener，定义抽象方法onClick(String
 info);

在Fragment文件中定义属性：private OnItemClickedListener mylistener;

在Fragment文件中的onAttach()方法中执行：mylistener
 = (OnItemClickedListener) getActivity();

在Fragment文件中，给某个控件增加监听器，在监听器中执行：mylistener.onClick(“需要传递的数据”);

将MainActivity实现OnItemClickedListener，重写onClick(String
 info)方法。参数就是Fragment传递的数据信息，在该方法中执行希望的逻辑操作。



3、DetailFragment的核心代码：







publicclass DetailFragment extends Fragment
 {



private TextView text_fragment_detail;



private Button button_fragment_get;



private Button button_fragment_send;



private OnItemClickedListener mylistener;









publicinterface OnItemClickedListener
 {



publicvoid onClick(String
 info);



}









@Override



publicvoid onAttach(Activity
 activity) {



super.onAttach(activity);



Log.i("DetailFragment", "==onAttach()");



if (getActivity() instanceof OnItemClickedListener)
 {



mylistener = (OnItemClickedListener) getActivity();



}



}









@Override



publicvoid onCreate(Bundle
 savedInstanceState) {



super.onCreate(savedInstanceState);



}









@Override



public View onCreateView(LayoutInflater inflater,
 ViewGroup container,



Bundle savedInstanceState) {



View view = inflater



.inflate(R.layout.fragment_detail,
 container, false);



text_fragment_detail = (TextView) view



.findViewById(R.id.text_fragment_detail);









button_fragment_get = (Button) view



.findViewById(R.id.button_fragment_get);



button_fragment_send = (Button) view



.findViewById(R.id.button_fragment_send);









button_fragment_get.setOnClickListener(new OnClickListener()
 {









@Override



publicvoid onClick(View
 v) {



Bundle bundle = getArguments();



if (bundle != null)
 {



text_fragment_detail.setText(bundle.getString("msg"));



} else {



text_fragment_detail.setText("没有收到信息！");



}



}



});









button_fragment_send.setOnClickListener(new OnClickListener()
 {









@Override



publicvoid onClick(View
 v) {



mylistener.onClick(“我是fragment传递给宿主的信息！");



}



});









return view;



}



}





4、MainActivity的核心代码：







publicclass MainActivity extends Activity implements OnItemClickedListener
 {



privatestaticfinal String TAG = "MainActivity";









@Override



protectedvoid onCreate(Bundle
 savedInstanceState) {



super.onCreate(savedInstanceState);



setContentView(R.layout.activity_main);









Log.i(TAG, "==onCreate()执行");



FragmentManager manager = getFragmentManager();









DetailFragment fragment = new DetailFragment();



Bundle bundle = new Bundle();



bundle.putString("msg", "Hello
 Fragment!!!");



fragment.setArguments(bundle);









FragmentTransaction transaction = manager.beginTransaction();



transaction.add(R.id.layout_container_fragment,
 fragment,



"content_fragment");



transaction.commit();



}









@Override



publicvoid onClick(String
 info) {



// 拿到Fragment传递过来的数据，显示在Title上。

// 实际项目中，我们是将Fragment_A传给宿主的信息拿到后，再通过setArguments()传递给Fragment_B。这样就实现了两个Fragment之间的数据传递。



setTitle(info);



}



}







五、FragmentManager与Fragment事务:  【重要】

（一）、概念：

        Activity管理Fragment主要依靠FragmentManager。FragmentManager可以完成以下几方面的功能：















使用findFragmentById()或findFragmentByTag()方法来获取指定Fragment；

调用popBackStack()方法将Fragment从回退栈中弹出（如同用户按下“返回键”的效果）；

调用addOnBackStackChangeListener()注册一个监听器，用于监听回退栈的变化情况。

        在Activity中使用Fragment，一个很明显的特性是：根据用户的交互情况，可以对Fragment进行添加、移除、替换,以及执行其他动作，提交给Activity的每一套变化被称为一个事务。Fragment事务代表了Activity对Fragment执行的多个改变操作。实现事务借助于FragmentTransaction对象。我们可以保存每一个事务到一个Activity管理的backstack，这样用户就能由Fragment的变化返回导航。



（二）、Fragment与回退栈（导航）：

1、回退栈的概念：BackStack

在Activity中已经探讨过回退栈，这种数据结构用来存放创建的窗口对象，并根据一定的规则决定哪些窗口对象应该出栈，凡是出栈的窗口对象将被销毁，也就是说窗口对象从入栈到出栈完成了窗口的整个生命周期。回退栈不仅能存储窗口对象，还可以存储Fragment对象。





（三）、FragmentManager与FragmentTransaction示例代码：

Fragment的布局文件:

// 构建Bundle对象，将文章id放在其中。

Bundle bundle = new Bundle();

bundle.putString("titleId", id);

// 构建文章内容的Fragment

RightFragment fragment = new RightFragment();

// 通过fragment对象的setArguments(bundle)方法将数据传输给其他Fragment。

fragment.setArguments(bundle);



// 通过getFragmentManager()方法构建FragmentManager对象

FragmentManager fragManager = getFragmentManager();

// 通过FragmentManager对象的beginTransaction()方法构建FragmentTransaction对象

FragmentTransaction trans = fragManager.beginTransaction();

// 将主页面布局文件中的ViewGroup容器替换成文章内容Fragment

trans.replace(R.id.fragment_content, fragment);

trans.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);

// 将事务添加到回退栈，这样用户就可以通过“返回键”回到替换Fragment的上一个状态

trans.addToBackStack(null);

// 提交事务

trans.commit();







六、 FragmentTransaction中的replace方法与add、hide、show方法的区别：【重要】



示例代码如下：





private void initData() {
 fragmentManager = getSupportFragmentManager();
 // 初始化碎片集合
 listFragments = new ArrayList<Fragment>();
 listFragments.add(new FragmentOne());
 listFragments.add(new FragmentTwo());
 listFragments.add(new FragmentThree());
 // 在指定位置默认加载第一个碎片
 transaction = fragmentManager.beginTransaction();
 transaction.add(R.id.layout_container, listFragments.get(0));
 transaction.commit();
}
// 点击选项TAB按钮，执行碎片切换
public void clickButton(View view) {
 switch (view.getId()) {
 case R.id.button_one:
  switchFragment(0);
  break;
 case R.id.button_two:
  switchFragment(1);
  break;
 case R.id.button_three:
  switchFragment(2);
  break;
 }
}
/*
 * 使用replace()方法实现。 每次replace都会将当前的碎片进行销毁，新创建一个碎片将原有的进行替换
 * 当TAB菜单切换到之前的选项时，虽然对应的碎片已经被创建过，但是因为销毁了而需要重新创建一次，因此会造成性能浪费
 */
private void replaceFragment(int tabindex) {
 if (currentTabIndex != tabindex) {
  transaction = fragmentManager.beginTransaction();
  transaction.replace(R.id.layout_container,
    listFragments.get(tabindex));
  transaction.addToBackStack(null);
  transaction.commit();
  currentTabIndex = tabindex;
 }
}
/*
 * 使用add()、hide()、show()方法实现。被加载出来的碎片在导航切换过程中不会被销毁，只是在隐藏和显示两个状态切换而已。
 * 因为切换过的碎片不被销毁，自然会有内存占用上的开销，但是因为不用重新加载碎片而在性能上是优于replace的。
 */
private void switchFragment(int tabindex) {
 if (currentTabIndex != tabindex) {
  transaction = fragmentManager.beginTransaction();
  // 定义当前碎片与即将加载的碎片
  Fragment fromFragment = listFragments.get(currentTabIndex);
  Fragment toFragment = listFragments.get(tabindex);
  if (!toFragment.isAdded()) {
   // 如果该碎片还没有被添加到事务中，则新添加到事务
   transaction.hide(fromFragment).add(R.id.layout_container,
     toFragment);
  } else {
   // 如果该碎片已经被添加到事务中，则从事务中取出该碎片进行显示即可。无需销毁再重新创建。
   transaction.hide(fromFragment).show(toFragment);
  }
  // 提交执行过的事务
  transaction.addToBackStack(null);
  transaction.commit();
  currentTabIndex = tabindex;
 }
}

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/37970961
自从Fragment出现，曾经有段时间，感觉大家谈什么都能跟Fragment谈上关系，做什么都要问下Fragment能实现不~~~哈哈，是不是有点过~~~
本篇博客力求为大家说明Fragment如何产生，什么是Fragment，Fragment生命周期，如何静态和动态的使用Fragment，Fragment回退栈，Fragment事务；以及Fragment的一些特殊用途，例如：没有布局的Fragment有何用处？Fragment如何与Activity交互？Fragment如何创建对话框？Fragment如何与ActionBar集成等等。
1、Fragment的产生与介绍
Android运行在各种各样的设备中，有小屏幕的手机，超大屏的平板甚至电视。针对屏幕尺寸的差距，很多情况下，都是先针对手机开发一套App，然后拷贝一份，修改布局以适应平板神马超级大屏的。难道无法做到一个App可以同时适应手机和平板么，当然了，必须有啊。Fragment的出现就是为了解决这样的问题。你可以把Fragment当成Activity的一个界面的一个组成部分，甚至Activity的界面可以完全有不同的Fragment组成，更帅气的是Fragment拥有自己的生命周期和接收、处理用户的事件，这样就不必在Activity写一堆控件的事件处理的代码了。更为重要的是，你可以动态的添加、替换和移除某个Fragment。
2、Fragment的生命周期
Fragment必须是依存与Activity而存在的，因此Activity的生命周期会直接影响到Fragment的生命周期。官网这张图很好的说明了两者生命周期的关系：

可以看到Fragment比Activity多了几个额外的生命周期回调方法：
onAttach(Activity)
当Fragment与Activity发生关联时调用。
onCreateView(LayoutInflater, ViewGroup,Bundle)
创建该Fragment的视图
onActivityCreated(Bundle)
当Activity的onCreate方法返回时调用
onDestoryView()
与onCreateView想对应，当该Fragment的视图被移除时调用
onDetach()
与onAttach相对应，当Fragment与Activity关联被取消时调用
注意：除了onCreateView，其他的所有方法如果你重写了，必须调用父类对于该方法的实现，
3、静态的使用Fragment
嘿嘿，终于到使用的时刻了~~
这是使用Fragment最简单的一种方式，把Fragment当成普通的控件，直接写在Activity的布局文件中。步骤：
1、继承Fragment，重写onCreateView决定Fragemnt的布局
2、在Activity中声明此Fragment，就当和普通的View一样
下面展示一个例子（我使用2个Fragment作为Activity的布局，一个Fragment用于标题布局，一个Fragment用于内容布局）：
TitleFragment的布局文件:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="45dp"
    android:background="@drawable/title_bar" >

    <ImageButton
        android:id="@+id/id_title_left_btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerVertical="true"
        android:layout_marginLeft="3dp"
        android:background="@drawable/showleft_selector" />

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:gravity="center"
        android:text="我不是微信"
        android:textColor="#fff"
        android:textSize="20sp"
        android:textStyle="bold" />

</RelativeLayout>

TitleFragment
package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.ImageButton;
import android.widget.Toast;

public class TitleFragment extends Fragment
{

	private ImageButton mLeftMenu;

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		View view = inflater.inflate(R.layout.fragment_title, container, false);
		mLeftMenu = (ImageButton) view.findViewById(R.id.id_title_left_btn);
		mLeftMenu.setOnClickListener(new OnClickListener()
		{
			@Override
			public void onClick(View v)
			{
				Toast.makeText(getActivity(),
						"i am an ImageButton in TitleFragment ! ",
						Toast.LENGTH_SHORT).show();
			}
		});
		return view;
	}
}

同理还有ContentFragment的其布局文件：
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:gravity="center"
        android:text="使用Fragment做主面板"
        android:textSize="20sp"
        android:textStyle="bold" />

</LinearLayout>

package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class ContentFragment extends Fragment
{

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		return inflater.inflate(R.layout.fragment_content, container, false);
	}

}

MainActivity
package com.zhy.zhy_fragments;

import android.app.Activity;
import android.os.Bundle;
import android.view.Window;

public class MainActivity extends Activity
{

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

}

Activity的布局文件：
<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" >

    <fragment
        android:id="@+id/id_fragment_title"
        android:name="com.zhy.zhy_fragments.TitleFragment"
        android:layout_width="fill_parent"
        android:layout_height="45dp" />

    <fragment
        android:layout_below="@id/id_fragment_title"
        android:id="@+id/id_fragment_content"
        android:name="com.zhy.zhy_fragments.ContentFragment"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" />

</RelativeLayout>

是不是把Fragment当成普通的View一样声明在Activity的布局文件中，然后所有控件的事件处理等代码都由各自的Fragment去处理，瞬间觉得Activity好干净有木有~~代码的可读性、复用性以及可维护性是不是瞬间提升了~~~下面看下效果图：

4、动态的使用Fragment
上面已经演示了，最简单的使用Fragment的方式~下面介绍如何动态的添加、更新、以及删除Fragment
为了动态使用Fragment，我们修改一下Actvity的布局文件，中间使用一个FrameLayout，下面添加四个按钮~~~嘿嘿~~不是微信的按钮- -！
<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" >

    <fragment
        android:id="@+id/id_fragment_title"
        android:name="com.zhy.zhy_fragments.TitleFragment"
        android:layout_width="fill_parent"
        android:layout_height="45dp" />

    <include
        android:id="@+id/id_ly_bottombar"
        android:layout_width="fill_parent"
        android:layout_height="55dp"
        android:layout_alignParentBottom="true"
        layout="@layout/bottombar" />

    <FrameLayout
        android:id="@+id/id_content"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:layout_above="@id/id_ly_bottombar"
        android:layout_below="@id/id_fragment_title" />

</RelativeLayout>

底部四个按钮的布局就不贴了，到时看效果图就明白了~~
下面主Activity
package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.LinearLayout;

public class MainActivity extends Activity implements OnClickListener
{
	private LinearLayout mTabWeixin;
	private LinearLayout mTabFriend;

	private ContentFragment mWeixin;
	private FriendFragment mFriend;

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

		// 初始化控件和声明事件
		mTabWeixin = (LinearLayout) findViewById(R.id.tab_bottom_weixin);
		mTabFriend = (LinearLayout) findViewById(R.id.tab_bottom_friend);
		mTabWeixin.setOnClickListener(this);
		mTabFriend.setOnClickListener(this);

		// 设置默认的Fragment
		setDefaultFragment();
	}

	private void setDefaultFragment()
	{
		FragmentManager fm = getFragmentManager();
		FragmentTransaction transaction = fm.beginTransaction();
		mWeixin = new ContentFragment();
		transaction.replace(R.id.id_content, mWeixin);
		transaction.commit();
	}

	@Override
	public void onClick(View v)
	{
		FragmentManager fm = getFragmentManager();
		// 开启Fragment事务
		FragmentTransaction transaction = fm.beginTransaction();

		switch (v.getId())
		{
		case R.id.tab_bottom_weixin:
			if (mWeixin == null)
			{
				mWeixin = new ContentFragment();
			}
			// 使用当前Fragment的布局替代id_content的控件
			transaction.replace(R.id.id_content, mWeixin);
			break;
		case R.id.tab_bottom_friend:
			if (mFriend == null)
			{
				mFriend = new FriendFragment();
			}
			transaction.replace(R.id.id_content, mFriend);
			break;
		}
		// transaction.addToBackStack();
		// 事务提交
		transaction.commit();
	}

}

可以看到我们使用FragmentManager对Fragment进行了动态的加载，这里使用的是replace方法~~下一节我会详细介绍FragmentManager的常用API。
注：如果使用Android3.0以下的版本，需要引入v4的包，然后Activity继承FragmentActivity，然后通过getSupportFragmentManager获得FragmentManager。不过还是建议版Menifest文件的uses-sdk的minSdkVersion和targetSdkVersion都改为11以上，这样就不必引入v4包了。
代码中间还有两个Fragment的子类，ContentFragment上面已经见过，FriendFragment其实类似：
package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class FriendFragment extends Fragment
{

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		return inflater.inflate(R.layout.fragment_friend, container, false);
	}

}

效果图：

可以看到很好的实现了效果，其实这个效果以前的博客中也出现过，在博客：Android项目Tab类型主界面大总结 Fragment+TabPageIndicator+ViewPager，有兴趣可以看看。ps:为了代码的简洁，就不添加按钮的点击变化什么的了，主要讲解功能了~~~
5、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实例将会被销毁。
transaction.replace()
使用另一个Fragment替换当前的，实际上就是remove()然后add()的合体~
transaction.hide()
隐藏当前的Fragment，仅仅是设为不可见，并不会销毁
transaction.show()
显示之前隐藏的Fragment
detach()
会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。
attach()
重建view视图，附加到UI上并显示。
transatcion.commit()//提交一个事务
注意：常用Fragment的哥们，可能会经常遇到这样Activity状态不一致：State loss这样的错误。主要是因为：commit方法一定要在Activity.onSaveInstance()之前调用。
上述，基本是操作Fragment的所有的方式了，在一个事务开启到提交可以进行多个的添加、移除、替换等操作。
值得注意的是：如果你喜欢使用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。

上述已经介绍完成了Fragment常用的一些方法，相信看完，大家一定清楚了Fragment的产生理由，以及如何使用Fragment，再根据API的讲解，也能明白，曾经为何觉得Fragment会出现一些列乱七八槽的问题，终究是因为没有弄清楚其生命周期。
由于篇幅原因，剩下的内容留到下一篇了。在下一篇，会介绍：
1、如何管理Fragment回退栈
2、Fragment如何与Activity交互
3、Fragment与Activity交互的最佳实践
4、没有视图的Fragment的用处
5、使用Fragment创建对话框
6、如何与ActionBar，MenuItem集成等~~

下一篇：Android Fragment 真正的完全解析（下）

好了，有任何问题请留言~~




会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。

前言：follow your heart,be your own king

 

 

相关文章：

1、《Fragment详解之一——概述》

2、《Fragment详解之二——基本使用方法》

3、《Fragment详解之三——管理Fragment（1）》

4、《Fragment详解之四——管理Fragment（2）》

5、《Fragment详解之五——Fragment间参数传递》
6、《Fragment详解之六——如何监听fragment中的回退事件与怎样保存fragment状态》

 

前面给大家稍微看了要怎么使用fragment，在上篇中，我们也初步接触到了add,replace这些fragment操作的函数，下面就再详细讲讲如何管理Fragment页面吧。

 

一、概述

 1、FragmentManager

要管理activity中的fragments，你就需要使用FragmentManager。通过getFragmentManager（）或getSupportFragmentManager（）获得
常用的方法有：

 

manager.findFragmentById();  //根据ID来找到对应的Fragment实例，主要用在静态添加fragment的布局中，因为静态添加的fragment才会有ID
manager.findFragmentByTag();//根据TAG找到对应的Fragment实例，主要用于在动态添加的fragment中，根据TAG来找到fragment实例
manager.getFragments();//获取所有被ADD进Activity中的Fragment

2、FragmentTransaction

 

一般用来对当前的Fragment进行管理，包括add,replace,remove；

常用的针对Fragment的方法有：

 

 

 

//将一个fragment实例添加到Activity的最上层
add(int containerViewId, Fragment fragment, String tag);
//将一个fragment实例从Activity的fragment队列中删除
remove(Fragment fragment);
//替换containerViewId中的fragment实例，注意，它首先把containerViewId中所有fragment删除，然后再add进去当前的fragment
replace(int containerViewId, Fragment fragment);

还有hide()、show()、detach()、attach()这些函数，我们下篇再讲，这节先对Fragment的用法有一个初步了解；

二、add()、replace()、remove()使用方法示例

 

下面就通过例子来看看以上几个函数的使用方法吧。

效果图如下：

点击“ADD Fragment1”，在将Fragment1添加到Activity的container中；
	
点击“ADD Fragment2”，将Fragment2添加到Activity的container中；
	
点击“Remove Fragment2”，将Fragment2的实例从container中移除，移除之后，就显示出其下方的fragment1的视图出来了。
	
再点击”replace Fragment1”，将container中的视图移除，然后添加上fragment2的视图。 
 



那现在我们从头开始构建这个工程：

 

1、新建两个fragment1.xml 和 fragment2.xml： 

 

从效果图中也可以看出，这两个XML什么都没有，只是通过背景色和文字来区别当前是哪个Fragment的XML布局文件而已，他们的布局代码如下：

fragment1.xml:

 

 

 

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ff00f0"
    android:orientation="vertical" >
    
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="This is fragment 1"
        android:textColor="#000000"
        android:textSize="25sp" />

</LinearLayout>

fragment2.xml:

 

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ffff00"
    android:orientation="vertical" >
    
    <TextView
        android:id="@+id/fragment2_tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="This is fragment 2"
        android:textColor="#000000"
        android:textSize="25sp" />
    
</LinearLayout>

2、建立对应的Fragment类：Fragment1和Fragment2

 

Fragment1:

 

 

 

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class Fragment1 extends Fragment {
	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState) {
		return inflater.inflate(R.layout.fragment1, container, false);
	}

}

与上一篇一样，也只是在onCreateView()时返回对应的布局。同样，Fragment2的定义如下：

import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class Fragment2 extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment2, container, false);
    }
}

3、MainActivity的布局

 

从上面的的效果图中也可以看出大概的布局，首先是三个Button，最下方是一个FrameLayout布局，它是用来做为container动态盛装fragment的；它就像是一个占位符，你设置多大，它其中的fragment就最大能有多大。记住，fragment也是Activity中的一个普通控件而已，只不过它可以像Activity一样用于显示的同时还能用来盛装其它控件！作为fragment的容器，即可以用FrameLayout也可以用LinearLayout或者RelativeLayout，都是一样的。activity_main.xml的布局代码如下：

 

 

 

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_add_frag1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="ADD  Fragment1" />

    <Button
        android:id="@+id/btn_add_frag2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="ADD  Fragment2" />

    <Button
        android:id="@+id/btn_remove_frag2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Remove  Fragment2" />

    <Button
        android:id="@+id/btn_repalce_frag1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="replace  Fragment1" />

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

</LinearLayout>

4、MainActivity的实现：

（1）首先，先写一个添加fragment到Activity中的函数：

 

 

private void addFragment(Fragment fragment, String tag) {
    FragmentManager manager = getSupportFragmentManager();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.add(R.id.fragment_container, fragment, tag);
    transaction.commit();
}

先是传进来两个参数，一个是要添加的fragment实例，另一个是一个TAG
	
至于FragmentManager、FragmentTransaction就没什么好讲的，这是这么个流程，要获取它们的实例就得调用这些函数。
	
然后是add(R.id.fragment_container, fragment, tag)函数：第一个参数是要将fragment盛装的container，即我们上面的FrameLayout！第三个参数是tag，当传进去这个TAG，它就会跟这个fragment关联起来，当我们通过findFragmentByTag()时，根据这个TAG就能找到这个Fragment实例。进而对它进行操作，比如，我们下面的remove()；
	
在通过transaction对Fragment操作完以后，一定要记得调用transaction.commit()，这样才会将操作提交到系统中，这里的代码才会最终起作用。
 

有没有觉得这个流程挺像数据库的回滚操作！对，其实就是这样的，这里其实就是一个针对Fragment的回滚操作，首先通过beginTransaction()来定义回滚的开始，然后通过transaction对Fragment进行一系列操作（我们这里只是进行了ADD，其实可以做一串操作），等操作完了利用commit()提交。这里就先初步讲到这，下节会细讲有关transaction的回滚过程。
（2）添加Fragment1和Fragment2:

好了，上面我们写好了一个函数addFragment(Fragment fragment, String tag)，下面我们就要通过这个函数来添加Fragment1和Fragment2的实例了。

当点击“ADD Fragment1”按钮时：

 

Fragment1 fragment1 = new Fragment1();
addFragment(fragment1, "fragment1");

当点击“ADD Fragment2”按钮时：

Fragment2 fragment2 = new Fragment2();
addFragment(fragment2, "fragment2");

这里需要注意的是，当我们添加每个Fragment实例时，都传进去一个对应的TAG，fragment1对应的是“fragment1”，fragment2对应的是“fragment2”，通过这些TAG，我们就可以通过findFragmentByTag()来获取它们了。
（3）RemoveFragment2:

下面就是当点击“RemoveFragment2”按钮时的代码操作了：

private void removeFragment2() {
    FragmentManager manager = getSupportFragmentManager();
    Fragment fragment = manager.findFragmentByTag("fragment2");
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.remove(fragment);
    transaction.commit();
}

首先是通过

Fragment fragment = manager.findFragmentByTag("fragment2");

找到我们当时ADD进Activity的fragment2实例，然后通过transaction.remove(fragment);将它删除；从效果图中可以看到，由于我们移除了fragment2的实例，而又由于fragment2是在界面最上方的，所以把它删除了之后，自然就剩下了fragment1在最上方了，所以我们就看到了fragment1的界面。那如果我们移除的是fragment1呢？答案是界面没有任何变化！因为fragment1的实例是在fragment2的下方的，我们是根本看不到它的。
（4）ReplaceFragment1:

最后一个操作：ReplaceFragment1：

咱们先回到上面的RemoveFragment2操作，在RemoveFragment2之后，要知道我们的Activity的ADD队列中，就只有fragment1了。知道这一点之后，咱们看下面ReplaceFragment1的代码：

private void replaceFragment1() {
    FragmentManager manager = getSupportFragmentManager();
    Fragment2 fragment2 = new Fragment2();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.replace(R.id.fragment_container, fragment2);
    transaction.commit();
}

这里有个注意的问题：

transaction.replace(R.id.fragment_container, fragment2);

这里replace传进去的第一个参数是容器ID，第二个参数是要新增的fragment。既然要replace()，那它是针对哪个fragment进行replace()呢？怎么没有指定要替换的fragment!为什么这里的第一个参数是盛装Activity中所有Fragment的container的ID呢？没错，这里的replace操作会把这个cotainer中所有fragment清空！！！！然后再把fragment2添加进去！

从上面的的讲解，大家可能也已经觉查到FragmentTransaction的Add()操作是维持着一个队列的，在这个队列中，根据ADD进去的先后顺序形成了一个链表，我们上面的操作在这个列表中的形式变化如下图所示：


源码在文章最底部给出

到这里add,replace,remove的使用方法就讲完了，但这里有个问题，必须根大家讲一下：我们上面说过replace操作会把container中的所有fragment全部删除，然后再将指定的fragment添加进去！但Android在实现时出现了BUG！在replace()时，并不能把以前所有Fragment清空，就因为这个系统工程产了BUG就会导致add()和Replace()不能共用！关于add()和Replace()不能共用的问题，我们会在下篇再讲。下面先给大家说说有关回滚的问题。

三、有关回滚——FragmentTransaction

1、FragmentTransaction事务回滚使用方法：

 

上部分，我们讲了有关添加、删除Fragment的操作，想将上一次commit的操作返回时，要怎么做呢。这就需要FragmentTransaction的回滚功能了。

要使用回滚功能，只需要要使用下面两个代码：

在transaction.commit()之前，使用addToBackStack()将其添加到回退栈中。

 

 

 

transaction.addToBackStack(String tag);

在需要回退时，使用popBackStack()将最上层的操作弹出回退栈。

manager.popBackStack();

这里的popBackStack()是弹出默认的最上层的栈顶内容。

当栈中有多层时，我们可以根据id或TAG标识来指定弹出到的操作所在层。函数如下：

void popBackStack(int id, int flags);
void popBackStack(String name, int flags);

其中

参数int id是当提交变更时transaction.commit()的返回值。
	
参数string name是transaction.addToBackStack(String tag)中的tag值；
	
至于int flags有两个取值：0或FragmentManager.POP_BACK_STACK_INCLUSIVE；
	
当取值0时，表示除了参数一指定这一层之上的所有层都退出栈，指定的这一层为栈顶层； 
	
当取值POP_BACK_STACK_INCLUSIVE时，表示连着参数一指定的这一层一起退出栈； 
	
除了这几个函数，还有下面几个函数：有关他们的使用，我们在这小部分结尾时会提到
popBackStackImmediate()
popBackStackImmediate(String tag)
popBackStackImmediate(String tag, int flag)
popBackStackImmediate(int id, int flag)

下面我们就通过一个例子来讲解一下有关回退栈中的操作过程：

先看下效果图：



整体流程是这样的：

1、逐个将Fragment1,2,3,4添加到窗口中，在添加时，每添加一个Fragment要利用transaction的addToBackStack将此次操作加入到回退栈中。

2、然后点击"PopBackStack"方法，将栈顶最上层的操作回退。退将最后一次添加回退出来，显示Fragment3.

3、点击“ADD Fragment4”将栈还原到1，2，3，4依次ADD进栈的状态，即操作1完成后的栈状态，然后点击“BackToStack2_0”，其实调用的方法是：

manager.popBackStack("fragment2",0);//方法一,通过TAG回退

从这里可以看出，要回退到添加ADD Fragment2的状态，注意最后一个参数，这里设为0，表明，要回退ADD Fragment2的之后的操作，将ADD Fragment2的操作置为栈顶。从效果图中也可以看出，点击后的视图在Fragment2的位置

4、最后仍然是先点击"Add Fragment3"和"ADD Fragment4"，将栈还原到操作1完成后的栈状态。然后点击“BackToStack2_INCLUSIVE”;其调用的方法是：

manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退

这里与上面的主要不同点在于第二个参数，这里设置为POP_BACK_STACK_INCLUSIVE，即在出栈时连带ADD Fragment2的操作一块出栈，放在栈顶的是ADD Fragment1的操作，所以放在界面上就是显示的是Fragment1的视图。
下面我们看看具体实现：
(1)、首先，与上部分一样，先添加四个Fragment，并用背景色和文字来区分。这部分代码我们就不讲了。

主要看看点击按钮的代码处理方法。
(2)、首先是添加Fragment1:

 

Fragment1 fragment1 = new Fragment1();
stackID1 = addFragment(fragment1,"fragment1");

其中：

 

private int stackID1,stackID2,stackID3,stackID4;

private int addFragment(Fragment fragment,String stackName){
    FragmentManager manager = getSupportFragmentManager();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.add(R.id.fragment_container,fragment);
    transaction.addToBackStack(stackName);
    return transaction.commit();
}

首先，这里的stackID1,stackID2,stackID3,stackID4是用来保存每次commit()后返回的Transaction的ID值。在void popBackStack(int id, int flags);时，其中的参数id就是这个值

然后在每次ADD操作后，利用addToBackStack(string name)将每次ADD操作添加进回退栈中；

同样，添加Fragment2的代码如下，添加Fragment3,Fragment4的方法同理

Fragment2 fragment2 = new Fragment2();
stackID2 = addFragment(fragment2,"fragment2");

(3)、然后是回退栈顶内容：

 

private void popBackStack(){
    FragmentManager manager = getSupportFragmentManager();
    manager.popBackStack();
}

(4)、接着是点击BackToFrag2_0按钮的内容，这里有两种方法实现，一种是指定TAG，一种是利用Commit()返回的ID

 

private void popBackStackToFrag2_0(){
	FragmentManager manager = getSupportFragmentManager();
	manager.popBackStack("fragment2",0);//方法一,通过TAG回退
	// manager.popBackStack(stackID2,0);//方法二,通过Transaction ID回退
}

（5）、最后是点击BackToFrag2_INCLUSIVE按钮的代码：

 

private void popBackStackToFrag2_Inclusive(){
    FragmentManager manager = getSupportFragmentManager();
    manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退
// manager.popBackStack(stackID2,FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法二,通过Transaction ID回退
}

好了，到这里，有关回滚的基本使用就结束了，需要要注意的是：
使用popBackStack()来弹出栈内容的话，调用该方法后会将事物操作插入到FragmentManager的操作队列，只有当轮询到该事物时才能执行。如果想立即执行事物的话，需要使用下面几个对应的方法：

 

popBackStackImmediate()
popBackStackImmediate(String tag)
popBackStackImmediate(String tag, int flag)
popBackStackImmediate(int id, int flag)

2、回退栈（back stack）状态改变监听

 

FragmentManager还为我们提供了监控回退栈状态改变的方法：

 

 

 

FragmentManager::addOnBackStackChangedListener(listener);//添加监听器
FragmentManager::removeOnBackStackChangedListener(listener);//移除监听器

通过添加监听器，就可以在回退栈内容改变时，及时收到通知；

我们在上面代码的基础上，在MainAcitivy中为FragmentManager添加一个监听器，当回退栈状态改变时，打出一个LOG。具体实现如下：
（1）、OnCreate()中：

为fragmentManger添加一个监听器：

FragmentManager manager = getSupportFragmentManager();
listener = new FragmentManager.OnBackStackChangedListener() {
	
	@Override
	public void onBackStackChanged() {
		// TODO Auto-generated method stub
		Log.d("qijian","backstack changed");
	}
};
manager.addOnBackStackChangedListener(listener);

(2)、当onDestory()中将监听器remove掉：

 

protected void onDestroy() {
	// TODO Auto-generated method stub
	super.onDestroy();
	FragmentManager manager = getSupportFragmentManager();
	manager.removeOnBackStackChangedListener(listener);
}

大家一定要注意，不管是这里的回退栈的监听还是其它的监听器，在页面对应的销毁时，都要记得remove掉，不然会造成页面不释放，这也是造成OOM的问题之一。

这样当回退栈内容出现变动时，变会打LOG出来，如图：



源码在文章底部给出

3、Transaction事务回退的原则

这里我们着重讲一下，回退是以commit()提交的一次事务为单位的，而不是以其中的add,replace等等操作为单位回退的，即，如果我们在一次提交是添加了fragment2,fragment3,fragment4，那么回退时，会依据添加时的顺序，将它们一个个删除，返回到没有添加fragment4,fragment3,fragment2的状态。

下面我们仍然写一个例子来讲明一下事务的回退原则，效果图如下：



1、首先，添加Fragment1，提交一次事务
	
2、然后，一次添加Fragment2，Fragment3，Fragment4，然后提交一次事务
	
3、利用popBackStack()将顶层事务出栈，可以看到把Fragment2，Fragment3，Fragment4一次出栈，界面显示在了Fragment1的位置，这就充分说明了，回滚是以提交的事务为单位进行的！
 

下面是代码实现部分：
1、同样，新建四个Fragment，分别利用背景色和文字来表明之间的不同。

2、然后添加Fragment1的代码如下：

 

private void addFragment1() {
    Fragment1 fragment1 = new Fragment1();
    FragmentManager manager = getSupportFragmentManager();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.add(R.id.fragment_container, fragment1);
    transaction.addToBackStack("fragment1");
    transaction.commit();
}

3、然后是添加其它三个Fragment的代码如下：

 

private void addOtherFragments() {
    Fragment2 fragment2 = new Fragment2();
    Fragment3 fragment3 = new Fragment3();
    Fragment4 fragment4 = new Fragment4();
    FragmentManager manager = getSupportFragmentManager();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.add(R.id.fragment_container, fragment2);
    transaction.add(R.id.fragment_container, fragment3);
    transaction.add(R.id.fragment_container, fragment4);
    transaction.addToBackStack("other fragments");
    transaction.commit();
}

再一次重申，从代码中也可以看到，是依次将Fragment2、Fragment3、Fragment4加入容器之后，再提交一次事务，所以下面回滚时，会将他们反顺序的依次删除。即remove(fragment4)、remove(fragment3)、remove(fragment2)
4、点击popBackStack按钮时的代码

 

private void popBackStack() {
    FragmentManager manager = getSupportFragmentManager();
    manager.popBackStack();
}

 

 

好了，到这里这篇文章就结束了，这篇文章太TM长了……大家估计看得也快要吐了……知识点太多，又想能给大家讲的浅显易懂就只有拉长篇幅了……

 

源码中有三个工程：
1、《harvicBlog3_1》：对应第二部分：add()、replace()、remove()使用方法示例
2、《harvicBlog3_2》：对应第三部分《有关回滚——FragmentTransaction》中的：FragmentTransaction事务回滚使用方法和回退栈内容监听部分

3、《harvicBlog3_3》：对应第三部分《有关回滚——FragmentTransaction》中的：Transaction事务回退的原则部分

 

如果本文有帮到你，记得加关注哦

源码下载地址：http://download.csdn.net/detail/harvic880925/8578519

请大家尊重原创者版权，转载请标明出处：http://blog.csdn.net/harvic880925/article/details/44927375， 谢谢！

 

如果你喜欢我的文章，你可能更喜欢我的公众号

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/37992017
上篇博客中已经介绍了Fragment产生原因，以及一些基本的用法和各种API，如果你还不了解，请看：Android Fragment 真正的完全解析（上）。
本篇将介绍上篇博客提到的：如何管理Fragment回退栈，Fragment如何与Activity交互，Fragment与Activity交互的最佳实践，没有视图的Fragment的用处，使用Fragment创建对话框，如何与ActionBar，MenuItem集成等~~
1、管理Fragment回退栈
类似与Android系统为Activity维护一个任务栈，我们也可以通过Activity维护一个回退栈来保存每次Fragment事务发生的变化。如果你将Fragment任务添加到回退栈，当用户点击后退按钮时，将看到上一次的保存的Fragment。一旦Fragment完全从后退栈中弹出，用户再次点击后退键，则退出当前Activity。
看这样一个效果图：

点击第一个按钮，切换到第二个界面，点击第二个按钮，切换到第三个界面，然后点击Back键依次回退。这像不像初学Android时的Activity跳转，当然了，这里肯定不是，不然我就跪了。这里是Fragment实现的，用户点击Back，实际是Fragment回退栈不断的弹栈。
如何添加一个Fragment事务到回退栈：
FragmentTransaction.addToBackStack(String)
下面讲解代码：很明显一共是3个Fragment和一个Activity.
先看Activity的布局文件：
<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" >

    <FrameLayout
        android:id="@+id/id_content"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" >
    </FrameLayout>

</RelativeLayout>
不同的Fragment就在这个FrameLayout中显示。
MainActivity.java
package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.Window;

public class MainActivity extends Activity
{


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

		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.add(R.id.id_content, new FragmentOne(),"ONE");
		tx.commit();
	}

}
很简单，直接将FragmentOne添加到布局文件中的FrameLayout中，注意这里并没有调用FragmentTransaction.addToBackStack(String)，因为我不喜欢在当前显示时，点击Back键出现白板。而是正确的相应Back键，即退出我们的Activity.
下面是FragmentOne
package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

public class FragmentOne extends Fragment implements OnClickListener
{

	private Button mBtn;

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		View view = inflater.inflate(R.layout.fragment_one, container, false);
		mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn);
		mBtn.setOnClickListener(this);
		return view;
	}

	@Override
	public void onClick(View v)
	{
		FragmentTwo fTwo = new FragmentTwo();
		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.replace(R.id.id_content, fTwo, "TWO");
		tx.addToBackStack(null);
		tx.commit();

	}

}

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

import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

public class FragmentTwo extends Fragment implements OnClickListener
{

	private Button mBtn ;
	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		View view = inflater.inflate(R.layout.fragment_two, container, false);
		mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn);
		mBtn.setOnClickListener(this);
		return view ; 
	}
	@Override
	public void onClick(View v)
	{
		FragmentThree fThree = new FragmentThree();
		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.hide(this);
		tx.add(R.id.id_content , fThree, "THREE");
//		tx.replace(R.id.id_content, fThree, "THREE");
		tx.addToBackStack(null);
		tx.commit();
	}


}

这里点击时，我们没有使用replace，而是先隐藏了当前的Fragment，然后添加了FragmentThree的实例，最后将事务添加到回退栈。这样做的目的是为了给大家提供一种方案：如果不希望视图重绘该怎么做，请再次仔细看效果图，我们在FragmentTwo的EditText填写的内容，用户Back回来时，数据还在~~~
最后FragmentThree就是简单的Toast了：
package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.Toast;

public class FragmentThree extends Fragment implements OnClickListener
{

	private Button mBtn;

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		View view = inflater.inflate(R.layout.fragment_three, container, false);
		mBtn = (Button) view.findViewById(R.id.id_fragment_three_btn);
		mBtn.setOnClickListener(this);
		return view;
	}

	@Override
	public void onClick(View v)
	{
		Toast.makeText(getActivity(), " i am a btn in Fragment three",
				Toast.LENGTH_SHORT).show();
	}

}

好了，经过上面的介绍，应该已经知道Fragment回退栈是怎么一回事了，以及hide，replace等各自的应用的场景。
这里极其注意一点：上面的整体代码不具有任何参考价值，纯粹为了显示回退栈，在后面讲解了Fragment与Activity通信以后，会重构上面的代码！
2、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()。
3、Fragment与Activity通信的最佳实践
因为要考虑Fragment的重复使用，所以必须降低Fragment与Activity的耦合，而且Fragment更不应该直接操作别的Fragment，毕竟Fragment操作应该由它的管理者Activity来决定。
下面我通过两种方式的代码，分别重构，FragmentOne和FragmentTwo的点击事件，以及Activity对点击事件的响应：
首先看FragmentOne
package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

public class FragmentOne extends Fragment implements OnClickListener
{
	private Button mBtn;

	/**
	 * 设置按钮点击的回调
	 * @author zhy
	 *
	 */
	public interface FOneBtnClickListener
	{
		void onFOneBtnClick();
	}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		View view = inflater.inflate(R.layout.fragment_one, container, false);
		mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn);
		mBtn.setOnClickListener(this);
		return view;
	}

	/**
	 * 交给宿主Activity处理，如果它希望处理
	 */
	@Override
	public void onClick(View v)
	{
		if (getActivity() instanceof FOneBtnClickListener)
		{
			((FOneBtnClickListener) getActivity()).onFOneBtnClick();
		}
	}

}

可以看到现在的FragmentOne不和任何Activity耦合，任何Activity都可以使用；并且我们声明了一个接口，来回调其点击事件，想要管理其点击事件的Activity实现此接口就即可。可以看到我们在onClick中首先判断了当前绑定的Activity是否实现了该接口，如果实现了则调用。
再看FragmentTwo
package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

public class FragmentTwo extends Fragment implements OnClickListener
{

	
	private Button mBtn ;
	
	private FTwoBtnClickListener fTwoBtnClickListener ;
	
	public interface FTwoBtnClickListener
	{
		void onFTwoBtnClick();
	}
	//设置回调接口
	public void setfTwoBtnClickListener(FTwoBtnClickListener fTwoBtnClickListener)
	{
		this.fTwoBtnClickListener = fTwoBtnClickListener;
	}
	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		View view = inflater.inflate(R.layout.fragment_two, container, false);
		mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn);
		mBtn.setOnClickListener(this);
		return view ; 
	}
	@Override
	public void onClick(View v)
	{
		if(fTwoBtnClickListener != null)
		{
			fTwoBtnClickListener.onFTwoBtnClick();
		}
	}

}

与FragmentOne极其类似，但是我们提供了setListener这样的方法，意味着Activity不仅需要实现该接口，还必须显示调用mFTwo.setfTwoBtnClickListener(this)。
最后看Activity :
package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.Window;

import com.zhy.zhy_fragments.FragmentOne.FOneBtnClickListener;
import com.zhy.zhy_fragments.FragmentTwo.FTwoBtnClickListener;

public class MainActivity extends Activity implements FOneBtnClickListener,
		FTwoBtnClickListener
{

	private FragmentOne mFOne;
	private FragmentTwo mFTwo;
	private FragmentThree mFThree;

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

		mFOne = new FragmentOne();
		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.add(R.id.id_content, mFOne, "ONE");
		tx.commit();
	}

	/**
	 * FragmentOne 按钮点击时的回调
	 */
	@Override
	public void onFOneBtnClick()
	{

		if (mFTwo == null)
		{
			mFTwo = new FragmentTwo();
			mFTwo.setfTwoBtnClickListener(this);
		}
		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.replace(R.id.id_content, mFTwo, "TWO");
		tx.addToBackStack(null);
		tx.commit();
	}

	/**
	 * FragmentTwo 按钮点击时的回调
	 */
	@Override
	public void onFTwoBtnClick()
	{
		if (mFThree == null)
		{
			mFThree = new FragmentThree();

		}
		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.hide(mFTwo);
		tx.add(R.id.id_content, mFThree, "THREE");
		// tx.replace(R.id.id_content, fThree, "THREE");
		tx.addToBackStack(null);
		tx.commit();
	}

}

代码重构结束，与开始的效果一模一样。上面两种通信方式都是值得推荐的，随便选择一种自己喜欢的。这里再提一下：虽然Fragment和Activity可以通过getActivity与findFragmentByTag或者findFragmentById，进行任何操作，甚至在Fragment里面操作另外的Fragment，但是没有特殊理由是绝对不提倡的。Activity担任的是Fragment间类似总线一样的角色，应当由它决定Fragment如何操作。另外虽然Fragment不能响应Intent打开，但是Activity可以，Activity可以接收Intent，然后根据参数判断显示哪个Fragment。
4、如何处理运行时配置发生变化
运行时配置发生变化，最常见的就是屏幕发生旋转，如果你不知道如何处理屏幕变化可以参考：Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案
这里提一下：很多人觉得强制设置屏幕的方向就可以了，但是有一点，当你的应用被至于后台（例如用户点击了home），长时间没有返回的时候，你的应用也会被重新启动。比如上例：如果你把上面的例子你至于FragmentThree界面，然后处于后台状态，长时间后你会发现当你再次通过home打开时，上面FragmentThree与FragmentOne叠加在一起，这就是因为你的Activity重新启动，在原来的FragmentThree上又绘制了一个FragmentOne。
好了，下面看一段代码：
Activity:
package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.Window;

public class MainActivity extends Activity

{
	private FragmentOne mFOne;

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

		mFOne = new FragmentOne();
		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.add(R.id.id_content, mFOne, "ONE");
		tx.commit();

	}

}

Fragment
package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class FragmentOne extends Fragment
{
	private static final String TAG = "FragmentOne";

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		Log.e(TAG, "onCreateView");
		View view = inflater.inflate(R.layout.fragment_one, container, false);
		return view;
	}

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);

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

	@Override
	public void onDestroyView()
	{
		// TODO Auto-generated method stub
		super.onDestroyView();
		Log.e(TAG, "onDestroyView");
	}

	@Override
	public void onDestroy()
	{
		// TODO Auto-generated method stub
		super.onDestroy();
		Log.e(TAG, "onDestroy");
	}

}

很简单的代码，当你运行之后，不断的旋转屏幕，你会发现每旋转一次屏幕，屏幕上就多了一个FragmentOne的实例，并且后台log会打印出许多套生命周期的回调。
类似：
07-20 08:18:46.651: E/FragmentOne(1633): onCreate
07-20 08:18:46.651: E/FragmentOne(1633): onCreate
07-20 08:18:46.651: E/FragmentOne(1633): onCreate
07-20 08:18:46.681: E/FragmentOne(1633): onCreateView
07-20 08:18:46.831: E/FragmentOne(1633): onCreateView
07-20 08:18:46.891: E/FragmentOne(1633): onCreateView

这是为什么呢，因为当屏幕发生旋转，Activity发生重新启动，默认的Activity中的Fragment也会跟着Activity重新创建；这样造成当旋转的时候，本身存在的Fragment会重新启动，然后当执行Activity的onCreate时，又会再次实例化一个新的Fragment，这就是出现的原因。
那么如何解决呢：
其实通过检查onCreate的参数Bundle savedInstanceState就可以判断，当前是否发生Activity的重新创建：
默认的savedInstanceState会存储一些数据，包括Fragment的实例：通过打印可以看出：
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实例：
package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.util.Log;
import android.view.Window;

public class MainActivity extends Activity

{
	private static final String TAG = "FragmentOne";
	private FragmentOne mFOne;

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

		Log.e(TAG, savedInstanceState+"");
		
		if(savedInstanceState == null)
		{
			mFOne = new FragmentOne();
			FragmentManager fm = getFragmentManager();
			FragmentTransaction tx = fm.beginTransaction();
			tx.add(R.id.id_content, mFOne, "ONE");
			tx.commit();
		}
		
		

	}

}

现在无论进行多次旋转都只会有一个Fragment实例在Activity中。
现在还存在一个问题，就是重新绘制时，Fragment发生重建，原本的数据如何保持？
其实和Activity类似，Fragment也有onSaveInstanceState的方法，在此方法中进行保存数据，然后在onCreate或者onCreateView或者onActivityCreated进行恢复都可以。
由于篇幅原因，就不贴测试代码了。
5、Fragmeny与ActionBar和MenuItem集成
Fragment可以添加自己的MenuItem到Activity的ActionBar或者可选菜单中。
a、在Fragment的onCreate中调用 setHasOptionsMenu(true);
b、然后在Fragment子类中实现onCreateOptionsMenu
c、如果希望在Fragment中处理MenuItem的点击，也可以实现onOptionsItemSelected；当然了Activity也可以直接处理该MenuItem的点击事件。
代码：
Fragment
package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;

public class FragmentOne extends Fragment
{

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setHasOptionsMenu(true);
	}

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		View view = inflater.inflate(R.layout.fragment_one, container, false);
		return view;
	}

	@Override
	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater)
	{
		inflater.inflate(R.menu.fragment_menu, menu);
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		switch (item.getItemId())
		{
		case R.id.id_menu_fra_test:
			Toast.makeText(getActivity(), "FragmentMenuItem1", Toast.LENGTH_SHORT).show();
			break;
		}
		return true;
	}

}

Activity
package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.Window;
import android.widget.Toast;

public class MainActivity extends Activity

{
	private static final String TAG = "FragmentOne";
	private FragmentOne mFOne;

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

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

		if (savedInstanceState == null)
		{
			mFOne = new FragmentOne();
			FragmentManager fm = getFragmentManager();
			FragmentTransaction tx = fm.beginTransaction();
			tx.add(R.id.id_content, mFOne, "ONE");
			tx.commit();
		}

	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu)
	{
		super.onCreateOptionsMenu(menu);
		getMenuInflater().inflate(R.menu.main, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		switch (item.getItemId())
		{
		case R.id.action_settings:
			Toast.makeText(this, "setting", Toast.LENGTH_SHORT).show();
			return true;
		default:
			//如果希望Fragment自己处理MenuItem点击事件，一定不要忘了调用super.xxx
			return super.onOptionsItemSelected(item);
		}
	}

}

效果图：
好了，可以很好的看到，Fragment可以添加MenuItem，也可以自己处理点击~~~
6、没有布局的Fragment的作用
没有布局文件Fragment实际上是为了保存，当Activity重启时，保存大量数据准备的
请参考博客：Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案

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

好了，终于把Fragment相关的联系到一起了，上述基本包含了Fragment所有的用法~~~相信大家如果能够看完，一定有不少的收获~~~

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