基本介绍

1、Fragment是依赖于Activity的，不能独立存在。
2、一个Activity可以有多个Fragment。
3、一个Fragment可以被多个Activity重用。
4、Fragment有自己的生命周期，并能接收输入事件。
5、我们能在Activity运行时动态添加或删除Fragment。

生命周期

image

通过这张图可以看到Fragment的生命周期比Activity多几个。

onAttach(Activity)
当Fragment与Activity发生关联时调用
onCreateView(LayoutInflater, ViewGroup, Bundle)
创建该Fragment视图
onActivityCreated(Bundle)
当Activity的onCreate方法返回时调用
onDestoryView()
与onCreateView想对应，当该Fragment的视图被移除时调用
onDetach()
与onAttach相对应，当Fragment与Activity关联被取消时调用

注意：除了OnCreateView()，其他所有方法如果你重写了，必须调用父类对该方法是实现（super方法）。

静态使用Fragment

这是使用Fragment最简单的一种方式，把Fragment当成普通的控件，直接写在Activity的布局中。步骤：

1、继承Fragment，重写onCreateView方法，填入布局

2、在Activity中声明此Fragment，就相当普通控件一样

下面展示一个例子（将Fragment作为Activity的布局）
Fragment的布局文件：

类直接继承Fragment

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

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布局文件

就是把Fragment当成普通控件一样在Activity中声明，然后所有事件都交由Fragment处理。

动态使用Fragment

包括动态添加、更新、删除Fragment

MainActivity代码

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(){
        SupportFragmentManager fm = getSupportFragmentManager();
        FragmentTransaction transaction = fm.beginTransaction();
        mWeixin = new ContentFragment();
        transaction.replace(R.id.id_content, mWeixin);
        transaction.commit();
    }
 
    @Override
    public void onClick(View v){
        SupportFragmentManager fm = getSupportFragmentManager();
        // 开启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();
    }
}

Fragment常用api：

获取FragmentManager的方式（v4包），getSupportFragmentManager()
主要的操作方法都是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状态不一致：

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()之前，所以commit方法一定要在Activity.onSaveInstance()之前调用

为了更好的使用Fragment，一定要清楚这些方法，哪个会销毁视图，哪个会销毁实例，哪个仅仅只是隐藏。

比如：

我在FragmentA中的EditText填了一些数据，当切换到FragmentB时，如果希望回到A还能看到数据，则适合你的就是hide和show；也就是说，希望保留用户操作的面板，你可以使用hide和show，当然了不要使劲在那new实例，进行下非null判断。
我不希望保留用户操作，你可以使用remove()，然后add()；或者使用replace()这个和remove,add是相同的效果
remove和detach有一点细微的区别，在不考虑回退栈的情况下，remove会销毁整个Fragment实例，点击back键后会销毁Activity，而detach则只是销毁其视图结构，实例并不会被销毁。那么二者怎么取舍使用呢？如果你的当前Activity一直存在，那么在不希望保留用户操作的时候，你可以优先使用detach！

回退栈理解

类似与Android系统为Activity维护一个任务栈，我们也可以通过Activity维护一个回退栈来保存每次Fragment事务发生的变化。如果你将Fragment任务添加到回退栈，当用户点击后退按钮时，将看到上一次的保存的Fragment。一旦Fragment完全从后退栈中弹出，用户再次点击后退键，则退出当前Activity。

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

事务添加这个方法 addToBackStack(String sr)

下面通过例子说明一下，功能如下：共有三个Fragment：F1, F2, F3，F1在初始化时就加入Activity，点击F1中的按钮跳转到F2，点击F2的按钮跳转到F3，点击F3的按钮回退到F1。
1、在Activity的onCreate()中，将F1加入Activity中，并将F1添加到回退栈：

getSupportFragmentManager().beginTransaction()
    .add(R.id.container, f1, "f1")
    .addToBackStack(Fragment1.class.getSimpleName())
    .commit();

F1按钮的onClick()内容如下，将F2添加到回退栈：

getFragmentManager().beginTransaction()
    .replace(R.id.container, f2, "f2")
    .addToBackStack(Fragment2.class.getSimpleName())
    .commit();

F2按钮的onClick()如下，将F3添加到回退栈：

getFragmentManager().beginTransaction()
    .replace(R.id.container, f3, "f3")
    .addToBackStack(Fragment3.class.getSimpleName())
    .commit();

F3按钮的onClick()如下：

getFragmentManager().popBackStack(Fragment2.class.getSimpleName(),
             FragmentManager.POP_BACK_STACK_INCLUSIVE);

这样就回退到F1了，上面出现了一个popBackStack，这个是干什么用的呢？下面来说一下：
1、addToBackStack()是加入回退栈，那么与之对应的是什么呢？就是上面提到的popBackStack()。他有几种变化：

popBackStack()：将回退栈的栈顶弹出，并回退该事务。
popBackStack(String name, int flag)：name为addToBackStack(String name)的参数，通过name能找到回退栈的特定元素，flag可以为0或者FragmentManager.POP_BACK_STACK_INCLUSIVE，0表示只弹出该元素以上的所有元素，POP_BACK_STACK_INCLUSIVE表示弹出包含该元素及以上的所有元素。这里说的弹出所有元素包含回退这些事务。
popBackStack()是异步执行的，是丢到主线程的MessageQueue执行，popBackStackImmediate()是同步版本。

通过上面的一些例子我们大致对这个回退栈有了一些了解。

Fragment与Activity通信

因为fragment是依赖于Activity存在的，通信并不复杂，大概归纳为：

1、如果你Activity中包含自己管理的Fragment的引用，可以通过引用直接访问所有的Fragment的public方法

2、如果Activity中未保存任何Fragment的引用，那么没关系，每个Fragment都有一个唯一的TAG或者ID,可以通过getFragmentManager.findFragmentByTag()或者findFragmentById()获得任何Fragment实例，然后进行操作。

3、在Fragment中可以通过getActivity得到当前绑定的Activity的实例，然后进行操作。

*Fragment与Activity通信最佳实践

因为要考虑Fragment的重复使用，所以必须降低Fragment与Activity的耦合，而且Fragment更不应该直接操作别的Fragment，毕竟Fragment操作应该由它的管理者Activity来决定。
下面通过两种方式实现fragment和Activity通信方式：
1、先看FragmentOne代码：

public class FragmentOne extends Fragment implements OnClickListener{
    private Button mBtn;
 
    /**
     * 设置按钮点击的回调
     */
    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是否实现了该接口，如果实现了则调用。
2、再看FragmentTwo：

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)。
3、最后看MainActivity

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);
        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();
    }
}

上面两种方法都能实现操作，到这里就结束了。

好文阅读
https://mp.weixin.qq.com/s/dUuGSVhWinAnN9uMiBaXgw
https://blog.csdn.net/lmj623565791/article/details/37970961

Android Fragment 解析

基本介绍

生命周期

注意：除了OnCreateView()，其他所有方法如果你重写了，必须调用父类对该方法是实现（super方法）。

静态使用Fragment

1、继承Fragment，重写onCreateView方法，填入布局

2、在Activity中声明此Fragment，就相当普通控件一样

动态使用Fragment

注意：常用Fragment的哥们，可能会经常遇到这样Activity状态不一致：

该异常出现的原因是：commit()在onSaveInstanceState()后调用。首先，onSaveInstanceState()在onPause()之后，onStop()之前调用。onRestoreInstanceState()在onStart()之后，onResume()之前，所以commit方法一定要在Activity.onSaveInstance()之前调用

回退栈理解

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

Fragment与Activity通信

1、如果你Activity中包含自己管理的Fragment的引用，可以通过引用直接访问所有的Fragment的public方法

2、如果Activity中未保存任何Fragment的引用，那么没关系，每个Fragment都有一个唯一的TAG或者ID,可以通过getFragmentManager.findFragmentByTag()或者findFragmentById()获得任何Fragment实例，然后进行操作。

3、在Fragment中可以通过getActivity得到当前绑定的Activity的实例，然后进行操作。

*Fragment与Activity通信最佳实践

你可能感兴趣的:(Android Fragment 解析)

Android Fragment 解析

基本介绍

生命周期

注意：除了OnCreateView()，其他所有方法如果你重写了，必须调用父类对该方法是实现（super方法）。

静态使用Fragment

1、 继承Fragment，重写onCreateView方法，填入布局

2、在Activity中声明此Fragment，就相当普通控件一样

动态使用Fragment

注意：常用Fragment的哥们，可能会经常遇到这样Activity状态不一致：

该异常出现的原因是：commit()在onSaveInstanceState()后调用。首先，onSaveInstanceState()在onPause()之后，onStop()之前调用。onRestoreInstanceState()在onStart()之后，onResume()之前，所以commit方法一定要在Activity.onSaveInstance()之前调用

回退栈理解

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

Fragment与Activity通信

1、如果你Activity中包含自己管理的Fragment的引用，可以通过引用直接访问所有的Fragment的public方法

2、如果Activity中未保存任何Fragment的引用，那么没关系，每个Fragment都有一个唯一的TAG或者ID,可以通过getFragmentManager.findFragmentByTag()或者findFragmentById()获得任何Fragment实例，然后进行操作。

3、在Fragment中可以通过getActivity得到当前绑定的Activity的实例，然后进行操作。

*Fragment与Activity通信最佳实践

你可能感兴趣的:(Android Fragment 解析)

1、继承Fragment，重写onCreateView方法，填入布局