本文将带你了解Android应用开发Android：Fragment学习，希望本文对大家学Android有所帮助。

    1 Fragment 介绍
    Fragment作为Android最基本，最重要的基础概念之一，在开发中经常会和他打交道。Fragment，简称碎片，是Android 3.0（API   11）提出的（Android 3.0系统只针对平板电脑，且闭源，那时候针对手机和针对平板是两套源代码，后来Android   4.0时整合了手机和平板的源码，因此市面上很难看到Android 3.0系统。），为了兼容低版本，support-v4库中也开发了一套Fragment   API，最低兼容Android 1.6。
   
    过去support-v4库是一个jar包，24.2.0版本开始，将support-v4库模块化为多个jar包，包含：support-fragment,   support-ui,   support-media-compat等，这么做是为了减少APK包大小，你需要用哪个模块就引入哪个模块。如果想引入整个support-v4库，则compile   ‘com.android.support:support-v4:24.2.1’，如果只想引入support-fragment库，则com.android.support:support-fragment:24.2.1。
   
      注意：因为support库是不断更新的，因此建议使用support库中的android.support.v4.app.Fragment，而不要用系统自带的android.app.Fragment。而如果要使用support库的Fragment，Activity必须要继承FragmentActivity（AppCompatActivity是FragmentActivity的子类）。
   
    Fragment 官方定义如下：
   
    A Fragment represents a behavior or a portion of user interface in an   Activity. You can combine multiple fragments in a single activity to build a   multi-pane UI and reuse a fragment in multiple activities. You can think of a   fragment as a modular section of an activity, which has its own lifecycle,   receives its own input events, and which you can add or remove while the   activity is running.
   
    根据上面的定义我们知道：
   
    Fragment是依赖于Activity的，不能独立存在的。 一个Activity里可以有多个Fragment。   一个Fragment可以被多个Activity重用。 Fragment有自己的生命周期，并能接收输入事件。   我们能在Activity运行时动态地添加或删除Fragment。
    优点
   
    模块化（Modularity）：我们不必把所有代码全部写在Activity中，而是把代码写在各自的Fragment中。
    可重用（Reusability）：多个Activity可以重用一个Fragment。
    可适配（Adaptability）：根据硬件的屏幕尺寸、屏幕方向，能够方便地实现不同的布局，这样用户体验更好。
   
    核心类
   
    Fragment：Fragment的基类，任何创建的Fragment都需要继承该类。
   
    FragmentManager：管理和维护Fragment。他是抽象类，具体的实现类是FragmentManagerImpl。
   
    FragmentTransaction：对Fragment的添加、删除等操作都需要通过事务方式进行。他是抽象类，具体的实现类是BackStackRecord。
   
    Nested Fragment（Fragment内部嵌套Fragment的能力）是Android   4.2提出的，support-fragment库可以兼容到1.6。通过getChildFragmentManager()能够获得管理子Fragment的FragmentManager，在子Fragment中可以通过getParentFragment()获得父Fragment。
   
    2 Fragment 使用方式
    这里给出Fragment最基本的使用方式。首先，创建继承Fragment的类，名为Fragment1：
   
 

    public class Fragment1 extends Fragment {
        private static String ARG_PARAM =   param_key;
        private String mParam;
        private Activity mActivity;
        public void onAttach(Context   context) {
              super.onAttach(context);
            mActivity = (Activity)   context;
            mParam =   getArguments().getString(ARG_PARAM);    //获取参数
        }
        public View   onCreateView(LayoutInflater inflater, ViewGroup container, Bundle   savedInstanceState) {
            View root =   inflater.inflate(R.layout.fragment_blank, container, false);
            TextView view =   root.findViewById(R.id.text);
            view.setText(mParam);
            return root;
        }
        public static Fragment1   newInstance(String str) {
            Fragment1 fragment = new   Fragment1();
            Bundle bundle = new   Bundle();
            bundle.putString(ARG_PARAM,   str);
              fragment.setArguments(bundle);     //设置参数
            return fragment;
        }
    }
      Fragment有很多可以复写的方法，其中最常用的就是onCreateView()，该方法返回Fragment的UI布局，需要注意的是inflate()的第三个参数是false，因为在Fragment内部实现中，会把该布局添加到container中，如果设为true，那么就会重复做两次添加，则会抛如下异常：
   
    Caused by: java.lang.IllegalStateException: The specified child already has   a parent. You must call removeView() on the child’s parent first.
   
    如果在创建Fragment时要传入参数，必须要通过setArguments(Bundle   bundle)方式添加，而不建议通过为Fragment添加带参数的构造函数，因为通过setArguments()方式添加，在由于内存紧张导致Fragment被系统杀掉并恢复（re-instantiate）时能保留这些数据。官方建议如下：
   
    It is strongly recommended that subclasses do not have other constructors   with parameters, since these constructors will not be called when the   fragment is re-instantiated.
   
    我们可以在Fragment的onAttach()中通过getArguments()获得传进来的参数，并在之后使用这些参数。如果要获取Activity对象，不建议调用getActivity()，而是在onAttach()中将Context对象强转为Activity对象。
   
      创建完Fragment后，接下来就是把Fragment添加到Activity中。在Activity中添加Fragment的方式有两种：静态添加、动态添加。
   
    静态添加：在xml中通过的方式添加，缺点是一旦添加就不能在运行时删除。
    1）MainActivity
   
 
    public class MainActivity extends FragmentActivity {
     
        @Override
        protected void onCreate(Bundle   savedInstanceState) {
              super.onCreate(savedInstanceState);
              setContentView(R.layout.activity_main);
        }
        }
    2)创建 Fragment
   

    public class MyFragment extends Fragment {
        @Override
        public View   onCreateView(LayoutInflater inflater, ViewGroup container,Bundle   savedInstanceState) {
            /** * Inflate the layout for   this fragment */
            return     inflater.inflate(R.layout.left_fragment,   container, false);
                }
         }
    3)创建 Fragment 的XML布局

   
    4)创建 Activity的布局
   
 
   
    注意事项：在Activity 的布局文件 中，必须指定   fragment的class或android:name为对应的Fragment的全包名类名。
    缺点：fragment的类型必须指定，因此通用性，灵活性不强。
   
    动态添加：运行时添加，这种方式比较灵活，因此建议使用这种方式。
    首先Activity需要有一个容器存放Fragment，一般是FrameLayout，因此在Activity的布局文件中加入FrameLayout：
   

   
    然后在Activity加入下列代码：
   

    if (bundle == null) {
          getSupportFragmentManager().beginTransaction()
            .add(R.id.container,   Fragment1.newInstance(hello world), f1)          //.addToBackStack(fname)
            .commit();
    }
    这里需要注意几点：
   
    因为我们使用了support库的Fragment，因此需要使用getSupportFragmentManager()获取FragmentManager。   add()是对Fragment众多操作中的一种，还有remove(),   replace()等，第一个参数是根容器的id（FrameLayout的id，即”@id/container”），第二个参数是Fragment对象，第三个参数是fragment的tag名，指定tag的好处是后续我们可以通过Fragment1   frag =   getSupportFragmentManager().findFragmentByTag(“f1”)从FragmentManager中查找Fragment对象。   在一次事务中，可以做多个操作，比如同时做add().remove().replace()。   commit()操作是异步的，内部通过mManager.enqueueAction()加入处理队列。对应的同步方法为commitNow()，commit()内部会有checkStateLoss()操作，如果开发人员使用不当（比如commit()操作在onSaveInstanceState()之后），可能会抛出异常，而commitAllowingStateLoss()方法则是不会抛出异常版本的commit()方法，但是尽量使用commit()，而不要使用commitAllowingStateLoss()。   addToBackStack(“fname”)是可选的。FragmentManager拥有回退栈（BackStack），类似于Activity的任务栈，如果添加了该语句，就把该事务加入回退栈，当用户点击返回按钮，会回退该事务（回退指的是如果事务是add(frag1)，那么回退操作就是remove(frag1)）；如果没添加该语句，用户点击返回按钮会直接销毁Activity。   Fragment有一个常见的问题，即Fragment重叠问题，这是由于Fragment被系统杀掉，并重新初始化时再次将fragment加入activity，因此通过在外围加if语句能判断此时是否是被系统杀掉并重新初始化的情况。
    Fragment有个常见的异常：
   
    java.lang.IllegalStateException: Can not perform this action after
    onSaveInstanceState
    at android.support.v4.app.FragmentManagerImpl.checkStateLoss(FragmentManager.java:1341)
    at   android.support.v4.app.FragmentManagerImpl.enqueueAction(FragmentManager.java:1352)
    at   android.support.v4.app.BackStackRecord.commitInternal(BackStackRecord.java:595)
    at   android.support.v4.app.BackStackRecord.commit(BackStackRecord.java:574)
   
      该异常出现的原因是：commit()在onSaveInstanceState()后调用。首先，onSaveInstanceState()在onPause()之后，onStop()之前调用。onRestoreInstanceState()在onStart()之后，onResume()之前。
   
    因此避免出现该异常的方案有：
   
      不要把Fragment事务放在异步线程的回调中，比如不要把Fragment事务放在AsyncTask的onPostExecute()，因此onPostExecute()可能会在onSaveInstanceState()之后执行。   逼不得已时使用commitAllowingStateLoss()。
    2.1 add 和 replace 区别
    添加和替换，是最常用的两个方法，从字面的意思上看能够非常明确的理解，添加就是往容器中添加（add），替换（replace）则是把容器清空再添加，也就是把容器中的所有内容都替换掉。
   
    1）首先获取FragmentTransaction对象：
   
 
    FragmentTransaction transaction =   getSupportFragmentManager().beginTransaction();
    2）添加

    transaction.add(R.id.fragment_container, oneFragment).commit();
    第一个参数是容器id，   第二个参数是要添加的fragment，添加不会清空容器中的内容，不停的往里面添加，值得强调的是，如果一个fragment已经进来的话，再次添加（指的是同一个对象）的话会报异常错误的，不重复添加同一fragment，这是非常重要的特点。
   
    添加进来的fragment都是可见的（visible），后添加的fragment会展示在先添加的fragment上面，在绘制界面的时候会绘制所有可见的view，所以大多数add都是和hide或者是remove同时使用的，例如：
   
  

    transaction.add(R.id.fragment_container,   oneFragment).hide(twoFragment).commit();
    这样可以节省绘制界面的时间，节省内存消耗，是推荐的用法。
   
    3)替换
   
    transaction.replace(R.id.fragment_container, oneFragment).commit();
    替换会把容器中的所以内容全都替换掉，有一些app会使用这样的做法，保持只有一个fragment在显示，减少了界面的层级关系。
   
    不同之处
    就是是否要清空容器再添加fragment的区别，用法上add配合hide或是remove使用，replace一般单独出现。
   
    相同之处
    每次add和replace都要重新走一遍fragment 的周期。
   
    3 Fragment 生命周期
    Fragment的生命周期和Activity类似，但比Activity的生命周期复杂一些，基本的生命周期方法如下图：
   
   
   
    onAttach()：Fragment和Activity相关联时调用。可以通过该方法获取Activity引用，还可以通过getArguments()获取参数。   onCreate()：Fragment被创建时调用。 onCreateView()：创建Fragment的布局。   onActivityCreated()：当Activity完成onCreate()时调用。 onStart()：当Fragment可见时调用。   onResume()：当Fragment可见且可交互时调用。 onPause()：当Fragment不可交互但可见时调用。   onStop()：当Fragment不可见时调用。 onDestroyView()：当Fragment的UI从视图结构中移除时调用。   onDestroy()：销毁Fragment时调用。 onDetach()：当Fragment和Activity解除关联时调用。
    上面的方法中，只有onCreateView()在重写时不用写super方法，其他都需要。
   
      因为Fragment是依赖Activity的，因此为了讲解Fragment的生命周期，需要和Activity的生命周期方法一起讲，即Fragment的各个生命周期方法和Activity的各个生命周期方法的关系和顺序，如图：
   
   
   
      我们这里举个例子来理解Fragment生命周期方法。功能如下：共有两个Fragment：F1和F2，F1在初始化时就加入Activity，点击F1中的按钮调用replace替换为F2。
   
    当F1在Activity的onCreate()中被添加时，日志如下：
   
   
   
    可以看出：
   
    Fragment的onAttach()->onCreate()->onCreateView()->onActivityCreated()->onStart()都是在Activity的onStart()中调用的。
   
    Fragment的onResume()在Activity的onResume()之后调用。
   
    3.1 加不加 addToBackStack() 区别
    接下去分两种情况，分别是不加addToBackStack()和加addToBackStack()，即是否把fragment加入回退栈的区别。
   
    1、当点击F1的按钮，调用replace()替换为F2，且不加addToBackStack()时，日志如下：
   
   
   
    可以看到，F1最后调用了onDestroy()和onDetach()。当点击返回按钮时 日志如下：
   
   
   
    2、当点击F1的按钮，调用replace()替换为F2，且加addToBackStack()时，日志如下：
   
   
   
      可以看到，F1被替换时，最后只调到了onDestroyView()，并没有调用onDestroy()和onDetach()。当用户点返回按钮回退事务时，F1会调onCreateView()->onStart()->onResume()，日志如下：
   
   
   
    因此在Fragment事务中加不加addToBackStack()会影响Fragment的生命周期。
   
    FragmentTransaction有一些基本方法，下面给出调用这些方法时，Fragment生命周期的变化：
   
    add(): onAttach()->…->onResume()。 remove():   onPause()->…->onDetach()。 replace():   相当于旧Fragment调用remove()，新Fragment调用add()。 show(): 不调用任何生命周期方法，调用该方法的前提是要显示的Fragment已经被添加到容器，只是纯粹把Fragment   UI的setVisibility为true。 hide():   不调用任何生命周期方法，调用该方法的前提是要显示的Fragment已经被添加到容器，只是纯粹把Fragment   UI的setVisibility为false。 detach():   onPause()->onStop()->onDestroyView()。UI从布局中移除，但是仍然被FragmentManager管理。   attach(): onCreateView()->onStart()->onResume()。
    3.2 回退栈的内部实现
      我们知道Activity有任务栈，用户通过startActivity将Activity加入栈，点击返回按钮将Activity出栈。Fragment也有类似的栈，称为回退栈（Back   Stack），回退栈是由FragmentManager管理的。默认情况下，Fragment事务是不会加入回退栈的，如果想将Fragment事务加入回退栈，则可以加入addToBackStack(“”)。如果没有加入回退栈，则用户点击返回按钮会直接将Activity出栈；如果加入了回退栈，则用户点击返回按钮会回滚Fragment事务。
   
    我们将通过最常见的Fragment用法，讲解Back Stack的实现原理：

    getSupportFragmentManager().beginTransaction()
        .add(R.id.container, f1,   f1)
        .addToBackStack()
        .commit();
    上面这个代码的功能就是将Fragment加入Activity中，内部实现为：创建一个BackStackRecord对象，该对象记录了这个事务的全部操作轨迹（这里只做了一次add操作，并且加入回退栈），随后将该对象提交到FragmentManager的执行队列中，等待执行。
   
    BackStackRecord类的定义如下
   
 
    class BackStackRecord extends FragmentTransaction implements   FragmentManager.BackStackEntry, Runnable {}
    从定义可以看出，BackStackRecord有三重含义：
   
    继承了FragmentTransaction，即是事务，保存了整个事务的全部操作轨迹。   实现了BackStackEntry，作为回退栈的元素，正是因为该类拥有事务全部的操作轨迹，因此在popBackStack()时能回退整个事务。   继承了Runnable，即被放入FragmentManager执行队列，等待被执行。
    先看第一层含义，getSupportFragmentManager.beginTransaction()返回的就是BackStackRecord对象，代码如下：
   

    public FragmentTransaction beginTransaction() {
        return new   BackStackRecord(this);
    }
    BackStackRecord类包含了一次事务的整个操作轨迹，是以链表形式存在的，链表的元素是Op类，表示其中某个操作，定义如下：

    static final class Op {
        Op next; //链表后一个节点
        Op prev; //链表前一个节点
        int cmd;  //操作是add或remove或replace或hide或show等
    body{ }  

本文由职坐标整理并发布，希望对同学们有所帮助。了解更多详情请关注职坐标移动开发之Android频道！