zoukankan      html  css  js  c++  java

  • Fragment详解之三——管理Fragment（1）

    相关文章：

    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（）获得 
    常用的方法有：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. manager.findFragmentById();  //根据ID来找到对应的Fragment实例，主要用在静态添加fragment的布局中，因为静态添加的fragment才会有ID  
    2. manager.findFragmentByTag();//根据TAG找到对应的Fragment实例，主要用于在动态添加的fragment中，根据TAG来找到fragment实例  
    3. manager.getFragments();//获取所有被ADD进Activity中的Fragment  

    2、FragmentTransaction

    一般用来对当前的Fragment进行管理，包括add,replace,remove；
    常用的针对Fragment的方法有：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. //将一个fragment实例添加到Activity的最上层  
    2. add(int containerViewId, Fragment fragment, String tag);  
    3. //将一个fragment实例从Activity的fragment队列中删除  
    4. remove(Fragment fragment);  
    5. //替换containerViewId中的fragment实例，注意，它首先把containerViewId中所有fragment删除，然后再add进去当前的fragment  
    6. 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:

    [html] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    2.     android:layout_width="match_parent"  
    3.     android:layout_height="match_parent"  
    4.     android:background="#ff00f0"  
    5.     android:orientation="vertical" >  
    6.       
    7.     <TextView  
    8.         android:layout_width="wrap_content"  
    9.         android:layout_height="wrap_content"  
    10.         android:text="This is fragment 1"  
    11.         android:textColor="#000000"  
    12.         android:textSize="25sp" />  
    13.   
    14. </LinearLayout>  

    fragment2.xml:

    [html] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    2.     android:layout_width="match_parent"  
    3.     android:layout_height="match_parent"  
    4.     android:background="#ffff00"  
    5.     android:orientation="vertical" >  
    6.       
    7.     <TextView  
    8.         android:id="@+id/fragment2_tv"  
    9.         android:layout_width="wrap_content"  
    10.         android:layout_height="wrap_content"  
    11.         android:text="This is fragment 2"  
    12.         android:textColor="#000000"  
    13.         android:textSize="25sp" />  
    14.       
    15. </LinearLayout>  

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

    Fragment1:

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import android.os.Bundle;  
    2. import android.support.v4.app.Fragment;  
    3. import android.view.LayoutInflater;  
    4. import android.view.View;  
    5. import android.view.ViewGroup;  
    6.   
    7. public class Fragment1 extends Fragment {  
    8.     @Override  
    9.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  
    10.             Bundle savedInstanceState) {  
    11.         return inflater.inflate(R.layout.fragment1, container, false);  
    12.     }  
    13.   
    14. }  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. import android.os.Bundle;  
    2. import android.support.v4.app.Fragment;  
    3. import android.view.LayoutInflater;  
    4. import android.view.View;  
    5. import android.view.ViewGroup;  
    6.   
    7. public class Fragment2 extends Fragment {  
    8.     @Override  
    9.     public View onCreateView(LayoutInflater inflater, ViewGroup container,  
    10.                              Bundle savedInstanceState) {  
    11.         return inflater.inflate(R.layout.fragment2, container, false);  
    12.     }  
    13. }  

    3、MainActivity的布局

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

    [html] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"  
    2.     android:layout_width="match_parent"  
    3.     android:layout_height="match_parent"  
    4.     android:orientation="vertical">  
    5.   
    6.     <Button  
    7.         android:id="@+id/btn_add_frag1"  
    8.         android:layout_width="match_parent"  
    9.         android:layout_height="wrap_content"  
    10.         android:text="ADD  Fragment1" />  
    11.   
    12.     <Button  
    13.         android:id="@+id/btn_add_frag2"  
    14.         android:layout_width="match_parent"  
    15.         android:layout_height="wrap_content"  
    16.         android:text="ADD  Fragment2" />  
    17.   
    18.     <Button  
    19.         android:id="@+id/btn_remove_frag2"  
    20.         android:layout_width="match_parent"  
    21.         android:layout_height="wrap_content"  
    22.         android:text="Remove  Fragment2" />  
    23.   
    24.     <Button  
    25.         android:id="@+id/btn_repalce_frag1"  
    26.         android:layout_width="match_parent"  
    27.         android:layout_height="wrap_content"  
    28.         android:text="replace  Fragment1" />  
    29.   
    30.     <FrameLayout  
    31.         android:id="@+id/fragment_container"  
    32.         android:layout_width="match_parent"  
    33.         android:layout_height="match_parent"/>  
    34.   
    35. </LinearLayout>  

    4、MainActivity的实现：

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private void addFragment(Fragment fragment, String tag) {  
    2.     FragmentManager manager = getSupportFragmentManager();  
    3.     FragmentTransaction transaction = manager.beginTransaction();  
    4.     transaction.add(R.id.fragment_container, fragment, tag);  
    5.     transaction.commit();  
    6. }  
    • 先是传进来两个参数，一个是要添加的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”按钮时：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. Fragment1 fragment1 = new Fragment1();  
    2. addFragment(fragment1, "fragment1");  

    当点击“ADD Fragment2”按钮时：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. Fragment2 fragment2 = new Fragment2();  
    2. addFragment(fragment2, "fragment2");  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private void removeFragment2() {  
    2.     FragmentManager manager = getSupportFragmentManager();  
    3.     Fragment fragment = manager.findFragmentByTag("fragment2");  
    4.     FragmentTransaction transaction = manager.beginTransaction();  
    5.     transaction.remove(fragment);  
    6.     transaction.commit();  
    7. }  

    首先是通过

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. 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的代码：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private void replaceFragment1() {  
    2.     FragmentManager manager = getSupportFragmentManager();  
    3.     Fragment2 fragment2 = new Fragment2();  
    4.     FragmentTransaction transaction = manager.beginTransaction();  
    5.     transaction.replace(R.id.fragment_container, fragment2);  
    6.     transaction.commit();  
    7. }  

    这里有个注意的问题：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. 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()将其添加到回退栈中。

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. transaction.addToBackStack(String tag);  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. manager.popBackStack();  

    这里的popBackStack()是弹出默认的最上层的栈顶内容。
    当栈中有多层时，我们可以根据id或TAG标识来指定弹出到的操作所在层。函数如下：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. void popBackStack(int id, int flags);  
    2. 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时，表示连着参数一指定的这一层一起退出栈； 
    • 除了这几个函数，还有下面几个函数：有关他们的使用，我们在这小部分结尾时会提到
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. popBackStackImmediate()  
    2. popBackStackImmediate(String tag)  
    3. popBackStackImmediate(String tag, int flag)  
    4. 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”，其实调用的方法是：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. manager.popBackStack("fragment2",0);//方法一,通过TAG回退  

    从这里可以看出，要回退到添加ADD Fragment2的状态，注意最后一个参数，这里设为0，表明，要回退ADD Fragment2的之后的操作，将ADD Fragment2的操作置为栈顶。从效果图中也可以看出，点击后的视图在Fragment2的位置
    4、最后仍然是先点击"Add Fragment3"和"ADD Fragment4"，将栈还原到操作1完成后的栈状态。然后点击“BackToStack2_INCLUSIVE”;其调用的方法是：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. Fragment1 fragment1 = new Fragment1();  
    2. stackID1 = addFragment(fragment1,"fragment1");  

    其中：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private int stackID1,stackID2,stackID3,stackID4;  
    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private int addFragment(Fragment fragment,String stackName){  
    2.     FragmentManager manager = getSupportFragmentManager();  
    3.     FragmentTransaction transaction = manager.beginTransaction();  
    4.     transaction.add(R.id.fragment_container,fragment);  
    5.     transaction.addToBackStack(stackName);  
    6.     return transaction.commit();  
    7. }  

    首先，这里的stackID1,stackID2,stackID3,stackID4是用来保存每次commit()后返回的Transaction的ID值。在void popBackStack(int id, int flags);时，其中的参数id就是这个值
    然后在每次ADD操作后，利用addToBackStack(string name)将每次ADD操作添加进回退栈中；
    同样，添加Fragment2的代码如下，添加Fragment3,Fragment4的方法同理

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. Fragment2 fragment2 = new Fragment2();  
    2. stackID2 = addFragment(fragment2,"fragment2");  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private void popBackStack(){  
    2.     FragmentManager manager = getSupportFragmentManager();  
    3.     manager.popBackStack();  
    4. }  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private void popBackStackToFrag2_0(){  
    2.     FragmentManager manager = getSupportFragmentManager();  
    3.     manager.popBackStack("fragment2",0);//方法一,通过TAG回退  
    4.     // manager.popBackStack(stackID2,0);//方法二,通过Transaction ID回退  
    5. }  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private void popBackStackToFrag2_Inclusive(){  
    2.     FragmentManager manager = getSupportFragmentManager();  
    3.     manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退  
    4. // manager.popBackStack(stackID2,FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法二,通过Transaction ID回退  
    5. }  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. popBackStackImmediate()  
    2. popBackStackImmediate(String tag)  
    3. popBackStackImmediate(String tag, int flag)  
    4. popBackStackImmediate(int id, int flag)  

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

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. FragmentManager::addOnBackStackChangedListener(listener);//添加监听器  
    2. FragmentManager::removeOnBackStackChangedListener(listener);//移除监听器  

    通过添加监听器，就可以在回退栈内容改变时，及时收到通知；
    我们在上面代码的基础上，在MainAcitivy中为FragmentManager添加一个监听器，当回退栈状态改变时，打出一个LOG。具体实现如下：
    （1）、OnCreate()中：
    为fragmentManger添加一个监听器：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. FragmentManager manager = getSupportFragmentManager();  
    2. listener = new FragmentManager.OnBackStackChangedListener() {  
    3.       
    4.     @Override  
    5.     public void onBackStackChanged() {  
    6.         // TODO Auto-generated method stub  
    7.         Log.d("qijian","backstack changed");  
    8.     }  
    9. };  
    10. manager.addOnBackStackChangedListener(listener);  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. protected void onDestroy() {  
    2.     // TODO Auto-generated method stub  
    3.     super.onDestroy();  
    4.     FragmentManager manager = getSupportFragmentManager();  
    5.     manager.removeOnBackStackChangedListener(listener);  
    6. }  

    大家一定要注意，不管是这里的回退栈的监听还是其它的监听器，在页面对应的销毁时，都要记得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的代码如下：

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private void addFragment1() {  
    2.     Fragment1 fragment1 = new Fragment1();  
    3.     FragmentManager manager = getSupportFragmentManager();  
    4.     FragmentTransaction transaction = manager.beginTransaction();  
    5.     transaction.add(R.id.fragment_container, fragment1);  
    6.     transaction.addToBackStack("fragment1");  
    7.     transaction.commit();  
    8. }  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private void addOtherFragments() {  
    2.     Fragment2 fragment2 = new Fragment2();  
    3.     Fragment3 fragment3 = new Fragment3();  
    4.     Fragment4 fragment4 = new Fragment4();  
    5.     FragmentManager manager = getSupportFragmentManager();  
    6.     FragmentTransaction transaction = manager.beginTransaction();  
    7.     transaction.add(R.id.fragment_container, fragment2);  
    8.     transaction.add(R.id.fragment_container, fragment3);  
    9.     transaction.add(R.id.fragment_container, fragment4);  
    10.     transaction.addToBackStack("other fragments");  
    11.     transaction.commit();  
    12. }  

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

    [java] view plain copy
     
     在CODE上查看代码片派生到我的代码片
    1. private void popBackStack() {  
    2.     FragmentManager manager = getSupportFragmentManager();  
    3.     manager.popBackStack();  
    4. }  

    好了，到这里这篇文章就结束了，这篇文章太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， 谢谢！
  • 相关阅读:
    thinkphp传递参数
    $this->display输出模板
    ConterReplaceBehavior.class.php模板内容替换，如__PUBLIC__
    Index/Common目录下文件
    thikphp创建共享数据config.php
    thinkphp连接数据库
    thinkphp笔记
    thinkphp安装 版本 3.1.3
    DIV CSS 网页兼容全搞定 （IE6 IE7 IE8 IE9 火狐 谷歌）
    js倒计时
  • 原文地址：https://www.cnblogs.com/wangfeng520/p/6026336.html
Copyright © 2011-2022 走看看