Fragment总结

零、前言

今年可能要实习了，准备把之前学过的知识点重头开始回顾下，不学习新东西了，这篇讲Fragment。

一、生命周期

onAttach(Activity activity)

当Fragment第一次被添加到宿主Activity上时调用。

onCreate(@Nullable Bundle savedInstanceState)

初始化Fragment时调用，调用时期：在onAttach()方法之后，在onCreateView()方法之前。

onCreateView(inflater,container,savedInstanceState)

当已经有了一个fragment实例，一般我们在这里创建Fragment的视图。
在onCreate()之后，onActivityCreated(Bundle)之前调用。
如果在这里返回了一个View，那么当在释放时将会调用onDestroyView().

onActivityCreated(Bundle)

当Fragment的宿主Activity已经被create()了并且这个Fragment的视图也被实例化了的时候调用。在这个函数里，我们可以进行一些状态的恢复，加载数据等操作。当然，这里可以调用
setRetainInstance(boolean)来保存他们的实例。这个函数的调用时期：onCreateView()之前，
onViewStateRestored()之后。

接着几个生命周期方法对应着Activity的生命周期。就不叙述了。

onDestoryView()

上面提过，和onCreateView相对应，当onCreateView方法已经返回一个视图，那么在释放资源时，将调用该方法。

onDetach(Activity activity)

与onAttach相对应，当Fragment从宿主上面移除时调用。

注意：除了onCreateView方法外，其它方法重写的话必须调用父类对该方法的实现，也就是super()。

二、Fragment的使用

1、静态使用

1. 继承Fragment，在onCreateView中初始化视图
2. 在Activity的布局中使用fragment 布局，并且添加name属性，属性的值为第一步创建的Fragment类。
   就这样两步就实现了。

2、动态使用

1. 获取FragmentManager对象
2. 调用FragmentManager的beginTransaction()方法，获取FragmentTransaction 对象
3. 创建一个继承了Fragment对象的类
4. 调用FragmentTransaction 的replace()方法
5. 调用 FragmentTransaction 的commit()

3、Fragment的回退栈

类似与Activity，Fragment也有自己的回退栈，当我们把一个Fragment放入栈中，这个Fragment实例并不会被销毁，但是界面会被销毁，也就会调用onDestoryView()方法，当我们从另一个Fragment回退到放入回退栈中的Fragment时，会调用onCreateView()方法。

三、常用API

在上面动态使用中涉及了几个常用的API，还有未介绍的API

FragmentTransaction 类

transaction.add() ：往一个Activity中添加一个Fragment

transaction.remove() ：如果这个Fragment没有被添加到回退站，则这个Fragment则会被销毁，也就是调用onDestoryView()方法。

transaction.replace()：remove()和add()合体。

addToBackStack(null)：将当前Fragment添加到回退栈

transaction.hide()：隐藏当前的Fragment，仅仅是设为不可见，并不会销毁

transaction.show()：显示之前隐藏的Fragment

transatcion.commit()：提交一个事务，注意：一定要在Activity.onSaveInstance()之前调用，否则会报State loss这样的错误。

Fragment类

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

attach()：重建view视图，附加到UI上并显示。

四、和ViewPager结合使用

Fragment和ViewPager结合使用的情况还是比较多大。将每一个Fragment作为ViewPager的一页。我们不用操作事务，利用adapter帮助我们完成。

1、FragmentPagerAdapter

FragmentPagerAdapter 继承自 PagerAdapter。相比通用的 PagerAdapter，该类更专注于每一页均为 Fragment 的情况。这个adapter每生成一个Fragment都会报错在内存中，因此适合页面比较少的情况。使用该类需要重写两个方法

getItem()
这个函数在instantiateItem()函数中被调用。看看源码。

  @Override
    public Object instantiateItem(ViewGroup container, int position) {
        if (mCurTransaction == null) {
            mCurTransaction = mFragmentManager.beginTransaction();
        }

        final long itemId = getItemId(position);

        // Do we already have this fragment?
        String name = makeFragmentName(container.getId(), itemId);
        Fragment fragment = mFragmentManager.findFragmentByTag(name);
        if (fragment != null) {
            if (DEBUG) Log.v(TAG, "Attaching item #" + itemId + ": f=" + fragment);
            mCurTransaction.attach(fragment);
        } else {
            fragment = getItem(position);
            if (DEBUG) Log.v(TAG, "Adding item #" + itemId + ": f=" + fragment);
            mCurTransaction.add(container.getId(), fragment,
                    makeFragmentName(container.getId(), itemId));
        }
        if (fragment != mCurrentPrimaryItem) {
            fragment.setMenuVisibility(false);
            fragment.setUserVisibleHint(false);
        }

        return fragment;
    }

首先判断事务是否为null，如果为空，则开启事务，接着调用getItemId(position)方法获取对应位置的itemid，通过itemid获取Fragment绑定的name，再获取Fragment。
然后判断Fragment是否为null，如果不为null，则调用事务的attach()方法，如果为null，则调用getItem()返回一个Fragment。从这里可以看出并不是每次创建都会创建Fragment，也就是说，不是每次都会调用getItem()方法，只有在第一次调用才会调用。这也是为什么有时候调用notifyDataSetChanged()不起作用的原因

getCount()
这个函数比较简单，只是单纯返回数量。

destroyItem() ：该函数被调用后，会对 Fragment 进行 FragmentTransaction.detach()。Fragment 所占用的资源不会被释放。

@Override
    public void destroyItem(ViewGroup container, int position, Object object) {
        if (mCurTransaction == null) {
            mCurTransaction = mFragmentManager.beginTransaction();
        }
        if (DEBUG) Log.v(TAG, "Detaching item #" + getItemId(position) + ": f=" + object
                + " v=" + ((Fragment)object).getView());
        mCurTransaction.detach((Fragment)object);
    }

2、FragmentPagerStateAdapter

FragmentStatePagerAdapter 和前面的 FragmentPagerAdapter 一样，是继承子 PagerAdapter。但是，和 FragmentPagerAdapter 不一样的是，该 PagerAdapter 的实现将只保留当前页面，当页面离开视线后，就会被消除，释放其资源；而在页面需要显示时，生成新的页面(就像 ListView 的实现一样)。这么实现的好处就是当拥有大量的页面时，不必在内存中占用大量的内存。

instantiateItem()源码:

 @Override
    public Object instantiateItem(ViewGroup container, int position) {
        // If we already have this item instantiated, there is nothing
        // to do.  This can happen when we are restoring the entire pager
        // from its saved state, where the fragment manager has already
        // taken care of restoring the fragments we previously had instantiated.
        if (mFragments.size() > position) {
            Fragment f = mFragments.get(position);
            if (f != null) {
                return f;
            }
        }

        if (mCurTransaction == null) {
            mCurTransaction = mFragmentManager.beginTransaction();
        }

        Fragment fragment = getItem(position);
        if (DEBUG) Log.v(TAG, "Adding item #" + position + ": f=" + fragment);
        if (mSavedState.size() > position) {
            Fragment.SavedState fss = mSavedState.get(position);
            if (fss != null) {
                fragment.setInitialSavedState(fss);
            }
        }
        while (mFragments.size() <= position) {
            mFragments.add(null);
        }
        fragment.setMenuVisibility(false);
        fragment.setUserVisibleHint(false);
        mFragments.set(position, fragment);
        mCurTransaction.add(container.getId(), fragment);

        return fragment;
    }

destroyItem() ：将 Fragment 移除，即调用 FragmentTransaction.remove()，并释放其资源。

 @Override
    public void destroyItem(ViewGroup container, int position, Object object) {
        Fragment fragment = (Fragment) object;

        if (mCurTransaction == null) {
            mCurTransaction = mFragmentManager.beginTransaction();
        }
        if (DEBUG) Log.v(TAG, "Removing item #" + position + ": f=" + object
                + " v=" + ((Fragment)object).getView());
        while (mSavedState.size() <= position) {
            mSavedState.add(null);
        }
        mSavedState.set(position, fragment.isAdded()
                ? mFragmentManager.saveFragmentInstanceState(fragment) : null);
        mFragments.set(position, null);

        mCurTransaction.remove(fragment);
    }

五、横竖屏切换时的问题

解决这个问题之前我们先了解下当手机横竖屏切换时，Activity的生命周期方法的调用情况。

进入Activity

02-16 18:28:50.341 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onCreate
02-16 18:28:50.345 4655-4655/com.lw.fragment I/System.out: ScreenFragment-----无参构造器
02-16 18:28:50.345 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onStart
02-16 18:28:50.345 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onResume

切换为横屏之后

02-16 18:28:50.341 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onCreate
02-16 18:28:50.345 4655-4655/com.lw.fragment I/System.out: ScreenFragment-----无参构造器
02-16 18:28:50.345 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onStart
02-16 18:28:50.345 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onResume
02-16 18:29:41.861 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onPause
02-16 18:29:41.861 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onStop
02-16 18:29:41.861 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onDestroy
02-16 18:29:41.873 4655-4655/com.lw.fragment I/System.out: ScreenFragment-----无参构造器
02-16 18:29:41.885 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onCreate
02-16 18:29:41.885 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onStart
02-16 18:29:41.885 4655-4655/com.lw.fragment I/System.out: ScreenActivity:onResume

从上面可以知道，当从竖屏切到横屏时，依次调用了onPause、onStop、onDestroy、onCreate、onStart、onResume。这就相当于重新启动了一个Activity。

OK、结合Fragment来看。

这里我贴上我的代码

Activity

public class ScreenActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_screen);
        System.out.println("ScreenActivity:onCreate");
        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction().add(R.id.fl_content, new ScreenFragment("我是参数")).commit();
//            getSupportFragmentManager().beginTransaction().add(R.id.fl_content, ScreenFragment.newInstance("我是参数")).commit();
        }

    }

    @Override
    protected void onStart() {
        super.onStart();
        System.out.println("ScreenActivity:onStart");
    }

    @Override
    protected void onResume() {
        super.onResume();
        System.out.println("ScreenActivity:onResume");
    }

    @Override
    protected void onPause() {
        super.onPause();
        System.out.println("ScreenActivity:onPause");
    }

    @Override
    protected void onStop() {
        super.onStop();
        System.out.println("ScreenActivity:onStop");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        System.out.println("ScreenActivity:onDestroy");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        System.out.println("ScreenActivity:onRestart");
    }
}

Fragment

public class ScreenFragment extends Fragment {

    private String arg = "无参构造器";

    public ScreenFragment() {
        System.out.println("ScreenFragment-----无参构造器");
    }

    public ScreenFragment(String arg) {
        this.arg = arg;
    }

    public static ScreenFragment newInstance(String arg) {
        Bundle bundle = new Bundle();
        bundle.putString("arg", arg);
        ScreenFragment fragment = new ScreenFragment();
        fragment.setArguments(bundle);
        return fragment;
    }

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {

        View view = inflater.inflate(R.layout.fragment_screen, container, false);
        TextView tv = (TextView) view.findViewById(R.id.tv);
        tv.setText(arg);
//        tv.setText(getArguments().getString("arg"));
        return view;
    }

}

如果安照上面的代码执行，则在从竖屏切换成为横屏时呈现无参构造器。解决方法：将Activity和Fragment两个地方的注释取消，并把注释上面的代码删除即可。

OK，关于Fragment就复习到这里了，以后要是又学到新东西再添加。

这篇博客所用到的代码： 源码下载