android之Fragment

最新推荐文章于 2024-04-08 03:20:59 发布

大漠孤烟123412

最新推荐文章于 2024-04-08 03:20:59 发布

阅读量2.7k

点赞数 2

分类专栏： android学习笔记文章标签： android java

本文链接：https://blog.csdn.net/qindong123412/article/details/121517351

版权

android学习笔记专栏收录该内容

5 篇文章 0 订阅

订阅专栏

一Fragment的简介和生命周期：

<1> Fragment的简介

<2> Fragment的生命周期

二将Fragment添加到Activty中使用

<1>概述

<2>使用不兼容方法将Fragemnt添加到Activity中使用

<2.1>不兼容方法的大概步骤：

<2.2>不兼容方法的实际代码展示

<3>使用兼容方法将Fragment添加到Activity中使用

<3.1>不兼容方法的大概步骤：

<3.2>不兼容方法的实际代码展示：

<3.3>不兼容方法的一个实际例子：

三Fragment和Fragment之间的通信

<1>在fragment中如何修改activity界面中的相关内容：

<2>在activity中如何修改Fragment界面中的相关内容：

<3>在activity中如何给Fragment传递信息

四.Fragment使用中的重要方法的讲解

五Fragment的压栈出栈

<1>.第一种方式：使用add（）+addToBackStack（）

<2>.第二种方式：使用add（）+addToBackStack（）+直接重写onBackPressed()

<3>第三种方式：使用add()+ArrayList+重写onbackProcess()方法

六Fragment的hide（）和show（）方法的使用

<6.1>.两个方法如何使用：

<6.2>两个方法的使用场景

<6.3>.模拟微信首页的形式

<1> 微信首页大致原理讲解

<2>微信首页具体的代码

<6.4>正常的使用(将所有的fragment添加到了回退栈中，这种场景我暂时没有见过****不太重要，有时间了再看吧)：

<6.5>在项目4中出现了一个问题,解决方法如下（这个也不太重要，当有充足时间的时候，再看这个）：

一Fragment的简介和生命周期：

<1> Fragment的简介

Fragment就是activity界面的一部分，简称碎片，在一个app中如果只是要求一个页面的部分不断的变化，这个不断变化的部分就可用用fragment来替代，该类是android 3.0新出来的（api是11）。

<2> Fragment的生命周期

Fragment有11个生命周期方法，每个方法调用的时机和activity和生命周期调用方法的时机的关系，如图所示

       --onAttach()    当fragment和它的activity第一次关联的时候调用
       --onCreate()    调用这个方法去初始化fragment的创建
       --onCreateView()  调用这个方法去实例化Fragment的用户界面(这个方法的返回值是View)
       --onActivityCreated()   当fragment绑定的activity已经创建了，fragment已经被实例化了的时候，这个方法会被调用；
       --onStart()  当fragment可见但是没有焦点的时候调用，绑定Activity的onStart（）方法（在activity的onstart()方法之后调用）
       --onResume() 当fragment可见且获取焦点的时候调用，绑定Activity的onResume()方法（在activity的onresume()方法之后调用）
       --onPause() 当Fragment可见但是失去焦点的时候调用，绑定Activity的onPause()方法（在activity的onPause（)方法之后调用）
       --onStop() 当Fragment不可见的时候调用，绑定Activity的onStop（）方法（在activity的onstop（)方法之后调用）
       --onDestroyView() 当Fragement的用户界面和Fragment解除关联的时候调用
       --onDestroy()  当Fragment不再有用的时候（）调用
       --onDetach()  当Fragment和activity解除关联的时候调用。

二将Fragment添加到Activty中使用

<1>概述

<1>Fragemnt出现的api是11，也就是android3.0出现的， 当我们的app是兼容Android 3.0之下的版本的时候，此时我们在activity中添加Fragment就必须要使用兼容版的方式进行添加了；但是如果我们
    		的app不需要兼容到android 3.0之下的话，此时就可以直接使用不兼容版本的方式在activty中添加Fragment。
    <2>将Fragment添加到Activity中的兼容版本的本质是：    
            	每个android系统都有v4包或者v7包（v7包中包含大部分v4东西），所以说直接使用v4包中的类，不管什么版本的android版本都可以运行，因为都可以找到这个类。所以该种方式使用的Fragemnt的就是		V4包中的，FragmentManager也是V4包中的，这样不管在任何的android中版本中，都可以找到这个类了，那么Fragment在任何版本中也都可以展示了。
	<3>现况是：   
               google现在除了Androidx替代了v4，v7等扩展包了，所以现在使用的Fragment以及相关的FragmentActivity都是androidx包中的东西。其他不变。

<2>使用不兼容方法将Fragemnt添加到Activity中使用

<2.1>不兼容方法的大概步骤：

				<1>创建一个类继承Fragment(该Fragment为android.jar包中的类)，复写其中的onCreateView()方法
                <2>创建一个类继承Activity（该Activity是android.jar包中的类，这个不受限制）
                <3>在Activity中开始添加Fragment：
                		<3.1>创建Fragment子类对象
                        <3.2>获取到FragmentManager对象（该Fragment是android.jar包中的类）
                        <3.3>通过FragmentManager对象获取到FragmentTransaction对象（FragmentTransaction是android.jar包中的类）
                        <3.4>调用FragmentTransaction对象的相关方法添加Fragmen到activity中。
                        			具体的方法：add（）,replace(),hide(),show(),commit()等方法。

<2.2>不兼容方法的实际代码展示

<1>创建一个类继承Fragment
import android.app.Fragment;//是android.jar中的Fragment，不是v4包中的

public class MySelftFragment extends Fragment {

    private TextView tv_two;
    private Button bt_callback;

    @Nullable
    @Override  
    //这个方法必须要重写，作用：实例化fragnment的用户界面。
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
        View inflate = inflater.inflate(R.layout.fragment_myself, null);
        return inflate;

    }
}

<2>创建一个普通的Activity
<3>添加Fragment到Activiyt中

        //1。创建Fragment的对象。
         MySelftFragment fragment=new MySelftFragment();
        //2.获取FragmentManager对象
        FragmentManager fragmentManager = getFragmentManager();
        //3.开启事务
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        //4.调用添加方法，（使用穿进去的Fragment对象的xml文件替换R.id.ll_content的控件）
        fragmentTransaction.add(R.id.ll_content,fragment,"mySelftFragment").addToBackStack("qindong");
        //5.提交事务，mySelftFragmentId就是这个特定的fragment的id值了，在activity中可以通过findFragmentById（id）来获取到相应的fragment对象。
        mySelftFragmentId = fragmentTransaction.commit();

<3>使用兼容方法将Fragment添加到Activity中使用

<3.1>兼容方法的大概步骤：

<1>创建一个类继承Fragment，这个Fragment是v4包中的Fragment，不是android.jar中的Fragment
                       <2>创建一个类继承FragmentActivity，该FragmentActivity是V4包中的类，该类也是继承与activity的。
                       <3>在FragmentActivity中，将fragment添加到actiivty中：
                       			<1>创建Frgment对象
                                <2>获取到FragmentManager对象（该FragmentManager是v4包下的类）
                                <3>通过FragmentManager对象，获取到FragmentTransaction（该FragmentTransaction是v4包下的类）
                                <4>调用FragmentTransaction的相关方法将Fragment对象添加到Activity中。
                                		具体方法：add（）,replace(),hide(),show(),commit()等方法
                                        
                                        
                                        
                  跟新：
                  		但是现在androidx已经替换了v4，v7等扩展包，所以第一步中继承的Fragment，现在已经变成了Androidx中的Fragmnet，如：androidx.fragment.app.Fragment；
                        		第二步中继承的FragmentActivity，也变成了androidx包中的了，如：import androidx.fragment.app.FragmentActivity;
                    	而其他的步骤则保持不变。

<3.2>兼容方法的实际代码展示：

        /**
         * 注意：一下的Fragment,FragmentManager,FragmentTransaction都是v4包中的类。
         * */
        //0.创建相应的Fragment对象
        RedFragment redFragment = new RedFragment();
        //1.获取到相应的fagnmentManager对象,注意此时使用的getSupportFragmentManager（）方法
        FragmentManager supportFragmentManager = getSupportFragmentManager();
        //2.开启FragmentManager对象的事务管理器
        FragmentTransaction fragmentTransaction = supportFragmentManager.beginTransaction();
        //3.调用事物管理器中的方法replace（）或者add（），将fragment对象添加到当前的activity中，并指定其要替换的xml中的控件的id
        //该方法的第三个参数为这个Fragment的tag，可以根据findFragmentByTag(String tag);来获取相应的Fragment对象。
        fragmentTransaction.replace(R.id.fl_frameLayout_content, redFragment, "redFragment");
        //4.向fragment事务管理器提交，创建fragment
        fragmentTransaction.commit();

<3.3>不兼容方法的一个实际例子：

<1>创建三个类均继承Fragment（V4包中的fragment）
//这是第一个Fragment的子类
public class RedFragment extends Fragment {

    @Nullable
    @Override
    //该方法用于实例化fragment的用户界面（该方法返回一个view）
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_home, null);
        return view;
    }
}

//这是第二个Fragment子类
public class GreenFragment extends BaseFragment {
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view=inflater.inflate(R.layout.fragment_green,null);
        return view;
    }
}


//这是第三个Fragment的子类
public class BlueFragment extends BaseFragment {

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


<2>创建一个类FragmentOneActivity继承FragmentActivitry（V4包中的类）

public class FragmentOneActivity extends FragmentActivity {

    private Button bt_red;
    private Button bt_green;
    private Button bt_blue;
    private FrameLayout fl_content;
    private ArrayList<BaseFragment> arrayList=new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.d("qindong", "onCreate");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_fragment_one);
        initView();
        initEvent();
        ShowRedFragment();
    }

    private void initView() {
        bt_red = (Button) findViewById(R.id.bt_red);
        bt_green = (Button) findViewById(R.id.bt_green);
        bt_blue = (Button) findViewById(R.id.bt_blue);
        fl_content = (FrameLayout) findViewById(R.id.fl_frameLayout_content);
    }

    private void initEvent() {
        bt_red.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ShowRedFragment();
            }
        });
        bt_green.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ShowGreenFragment();
            }
        });
        bt_blue.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ShowBlueFragment();
            }
        });
    }


    private void ShowRedFragment() {
        /**
         * 注意：一下的Fragment,FragmentManager,FragmentTransaction都是v4包中的类。
         * */
        //0.创建相应的Fragment对象
        RedFragment redFragment = new RedFragment();
        redFragment.setLogName("RedFragment:");
        //1.获取到相应的fagnmentManager对象,注意此时使用的getSupportFragmentManager（）方法
        FragmentManager supportFragmentManager = getSupportFragmentManager();
        //2.开启FragmentManager对象的事务管理器
        FragmentTransaction fragmentTransaction = supportFragmentManager.beginTransaction();
        //3.调用事物管理器中的方法replace（）或者add（），将fragment对象添加到当前的activity中，并指定其要替换的xml中的控件的id
        //该方法的第三个参数为这个Fragment的tag，可以根据findFragmentByTag(String tag);来获取相应的Fragment对象。
        fragmentTransaction.replace(R.id.fl_frameLayout_content, redFragment, "redFragment");
        //4.向fragment事务管理器提交，创建fragment
        fragmentTransaction.commit();
    }

    private void ShowGreenFragment() {
        GreenFragment greenFragment = new GreenFragment();
        FragmentManager supportFragmentManager = getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = supportFragmentManager.beginTransaction();
        fragmentTransaction.replace(R.id.fl_frameLayout_content, greenFragment, null);
        fragmentTransaction.commit();
        arrayList.add(greenFragment);

    }

    private void ShowBlueFragment() {
        BlueFragment blueFragment = new BlueFragment();
        FragmentManager supportFragmentManager = getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = supportFragmentManager.beginTransaction();
        fragmentTransaction.replace(R.id.fl_frameLayout_content, blueFragment, null);
        fragmentTransaction.commit();
        arrayList.add(blueFragment);
    }
}

<3>这是activity对应的xml布局文件。

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

    <FrameLayout
        android:id="@+id/fl_frameLayout_content"
        android:layout_width="match_parent"
        android:layout_height="400dp">

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center"
            android:text="这是默认显示的内容" />
    </FrameLayout>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:id="@+id/bt_red"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="红色" />

        <Button
            android:id="@+id/bt_green"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="绿色" />

        <Button
            android:id="@+id/bt_blue"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="蓝色" />
    </LinearLayout>

</LinearLayout>

三Fragment和Activity之间的通信

<1>在fragment中如何修改activity界面中的相关内容：

思路：通过方法getActivity())得到frgment所绑定的那个activity对象，然后调用该activity类中的方法，就可以达到目的了

//这是在fragment中的方法，setInfo(String s)是其绑定的activity中的方法
        String s = tv_two.getText().toString();
        ((FragmentActivity) getActivity()).setInfo(s);

<2>在activity中如何修改Fragment界面中的相关内容：

思路：在actiivty中获取到特定的Fragment的对象，然后通过对象调用Fragment中的方法即可。而在activity中获取到特定的Fragment对象，有两种方式，分别是通过target和ID，如下：

//1.第一种方式：在actiivty中，通过target值来获取到特定的Fragment对象
HomeFragment homeFragment = (HomeFragment) getFragmentManager().findFragmentByTag("homeFragment");


//2.第二种方式：在actiivty中，通过id值来获取到特定的Fragment对象
       MySelftFragment mySelfFragment = (MySelftFragment) getFragmentManager().findFragmentById(mySelftFragmentId);//通过id来获取特定的对象




//3如何给特定的Fragment设置tag和id，则是如下：
        //MySelftFragment是自定义的一个类，继承Fragment。-----这些方法是不考虑兼容的版本。
        MySelftFragment fragment=new MySelftFragment();
        //1.获取FragmentManager对象
        FragmentManager fragmentManager = getFragmentManager();
        //2.开启事务
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        //3.调用添加方法replace()或者add()方法，其中第三个参数就是为本Fragment设置的tag
        fragmentTransaction.replace(R.id.ll_content,fragment,"mySelftFragment");
//        fragmentTransaction.add(R.id.ll_content,fragment,"mySelftFragment");
        //提交事务 ，此时返回的int型值就是本Fragment的id值。
        int  mySelftFragmentId = fragmentTransaction.commit();

<3>在activity中如何给Fragment传递信息

思路:在Fragment中有一个方法，即setArguments(Bundle bundle)，我们可以将要传递的数据封装在bundle中；然后当我们在Fragmnet中获取该bundle对象，进而提取到我们的数据即可。

	1>在activity中创建一个Fragment对象，然后将数据封装在Bundle中。
    
    			Fragment fragment=new GoodsFragment();
                Bundle bundle=new Bundle();
                bundle.putString("seller_id",seller_id);
                fragment.setArguments(bundle);
		...(正常的将Fragment添加到Activity中的代码，此处省略)
    
    2>在对应的Fragment中，获取到该Bundle对象，然后获取到该数据。
    
    	public class GoodsFragment extends BaseFragment {

    @Override
    public View onCreateView( LayoutInflater inflater,  ViewGroup container,  Bundle savedInstanceState) {
        View inflate = inflater.inflate(R.layout.fragment_goods, null);
        Bundle bundle=getArguments();
        String seller_id=bundle.getString("seller_id");
        return inflate;
    }
}

四Fragment使用中的重要方法的讲解：

       < 1>.replace(int id,Fragment fragment,String tag)----会直接将之前的所有的Fragment直接销毁（直接调用之前所有的Fragment的onpause()--onstop()----ondestroyView()----ondestroy()---onedetach()），然后在创建本Fragment（onAttach()---onCreate()----onCreateView()---onActivityCreate()--onStart()---onResume()）；
                        当在调用replace（）方法的同时调用了addToBackStack（），那么此时之前所有的的fragment执行的就是（onpause()--onstop()----ondestroyView()），然后在回退到他们的fragment页面的时候，其会执行（oncreateView()----onActivityCreated()--onstart()--onresume()）；
                        
                        
       <2>.add(int id ,Fragment fragment,String tag)-------当调用这个方法的时候，此时对于上一个Fragmnet（是其本身或者是另一个Fragment），系统什么都不会做，其还是处于onResume()执行完的状态，也就是说其Fragment对象不会销毁；对于本Fragment，会执行以下方法（onAttach()--oncreate()---oncreateView()---onActivityCreated()--onstart()---onResume()）；
                    使用add（）方法添加同一Fragmnet的同一个对象，不能添加多次，否则应用会崩掉（测试过，同一对象也就是要说这个Fragment应该是一个全局变量或者静态全局变量）
                    
                    
                    
         3.当我们使用FragmentTransaction对象的add（）方法添加Fragment的时候，此时系统是以栈的形式来进行管理的，即先进后出。例子：一下三个Fragment对应的都是activity中同一个FrameLayout的时候，前两个是通过add（）方法添加的，此时管理fragment的结构数据（即栈）中有两个fragment对象，当第三个使用replace方法添加fragment的时候，此时调用fragment的生命周期方法（）来销毁栈中的所有的fragment对象，顺序为倒叙（即先销毁第二个fragment对象，然后在销毁第一个fragment对象）
                    使用replace(）方法添加同一个Fragmnet的同一个对象，添加多少次都没有关系，应用都不会崩掉（），因为此时这个Fragment对象不会走任何生命周期方法。
                    
                    
                    
        4.回退键即onBackProcess()中默认就是调用当前activity的finish（）方法，销毁当前activity。
        
        
        5.addToBackStack(String name)------------注意：   将三个fragmnet添加到回退栈中，调用该方法，传入的name值可以不同，这里基本没有意义，可以直接传入null。
                当前边的都是通过replace（）.addToBackStack(String stackName)--的时候添加的时候，此时，第二个fragment被添加的时候，第一个Fragment执行的onpause()--onstop--ondestroyView(),然后第一个fragment就处于这个状态了，之后的就以此类推；当开始回退的时候，从第四个fragment开始回退到第三个fragment的时候，此时第四个frament执行的方法是（onpause(0--onstop()---ondestroyView()---ondestroy()--ondetach()）,第三个fragment执行的方法是（oncreateView()---onactivityCreated()----onstart()---onresume()）,之后的就以此类推。
                当Fragment都是通过add().addToBackStack(String stackName）的时候添加的时候，此时，第二个fragment被添加的时候，第一个Fragmnet什么都不执行，而是一直处于onresume（）状态，而第二个fragment执行的方法是onAttach(）--onCreate()---onCreateView()---onActivityCreated()--onstart()---onResume().;当开始回退的时候，从第四个Fragment回退到第三个Fragment的时候，此时第四个Fragment执行的方法是onpause()-----onstop----ondestoryView()---ondestroy()----onDetach()，第三个fragment还是什么方法都不执行。
                当fragment前两个是通过add().addToBackStack(String stackName）添加,第三个是通过replace（）.addToBackStack(String stackName)--的时候添加，当添加第三个fragment的时候，此时第一个和第二个都会执行其本身fragmen相应的方法（onpause()--onstop---ondestroyView()）方法，而第三个Fragment执行的则是（onAttach(0--onCreate()---onCreateView()---onActivityCreated()--onstart()---onResume()）；当从第三个回退到第二个的时候，此时第三个fragment执行的方法是（onpause()-----onstop----ondestoryView()---ondestroy()----onDetach()），然后执行的第一个和第二个Fragment相应的方法（onCreaeView()--onactivityCreated()---onstart()--onResume()）;从第二个Fragment回退到第一个Fragment的时候，此时第二个Fragment执行的（onpause()-----onstop----ondestoryView()---ondestroy()----onDetach()），第一个Fragemnt则是什么都不执行。
                重点：当使用该方法addToBackStack（String name）往activity中添加了一个fragment，此时在在内存就存在一个回退栈了，当我们点击回退键的时候，系统首先销毁回退栈中的那个Fragment，当回退栈中的fragment已经没有的时候，此时点击返回键就会直接销毁activity和不在回退栈中的所有的Fragment。
                          例子：当第一个，第二个，第三个fragment都是通过add（）方法添加到activity的且没有使用addToBackStack（）方法，此时第四个fragment是通过replace（）添加的，                                            而且调用了addToBackStack（）方法，此时第一次点击回退键，就会销毁第四个fragment，返回到第三个fragment；然后在点击返回键，就直接销毁这个actiivty                                            和所有的fragment了

               注意：当replace方法同时调用过了addToBackStack（）方法的时候，此时这个replace对前面的fragment，不管是使用add还是repalce添加的，不管是不是调用的addbacktostack方法，前面的fragmnet执行的生命周期方法都是（onpause-----onstop------ondestroyView()），区别在于如果是通过add添加fragment，replace+addbacktostack的fragment在回退的时候，add所有的fragment都会执行（oncreateView---onactivityCreate---onstart---onresume）,而replac方法添加的fragtment则是推到那个fragment，执行那个frament的(oncreateview---onactivitycreate---onstart----onresume).；在回退的时候，主要是判断回退栈中是否还有fragment对象，如果有，则返回上一个fragment，如果没有则直接执行activity的finish（）方法。



          6.什么时候用add（）方法，什么时候用replace（）方法？
                    初步判断，当用户点击返回键，想要显示之前得页面（用户在该页面上做了一些操作）      ，此时就用add（）方法；否则就是replace（）方法。
                    
                    
         7.乡下兼容版本的fragment和不向下兼容的Fragment的FragmentTransction的commit（）只能调用一次，当第二次或者多次调用的时候，此时就会应用就会崩掉。

五Fragment的压栈出栈

<1`>.第一种方式：使用add（）+addToBackStack（）

<1.1>注意点

			<1> 为了保证activity在最后一个回退的时候，当前的activity的xml中FrameLayout位置有一个fragment，所以第一个添加到activity中的fragment就不能使用addToBackStack（）方法
           	<2>如果想要点击回退键在回退fragment的时候，保证之前的fragment页面的内容（有用户输入的信息），就要使用add（）方法；如果想要在点击回退键回退fragment的时候，让之前的fragment在重新走一次oncreateView()---onActivityCreated()--onstart()--onresume()方法，此时就要使用replace()方法。

<1.2>代码实例

public class FragmentOneActivity extends Activity {

    private Button bt_red;
    private Button bt_green;
    private Button bt_blue;
    private FrameLayout fl_content;
    private ArrayList<BaseFragment> arrayList = new ArrayList<>();
    private FragmentManager fragmentManager;
    BlueFragment blueFragment = new BlueFragment();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.d("qindong", "onCreate");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_fragment_one);
        initView();
        initEvent();
        getFragmentTransition();
        //第一次添加的fragment没有使用addToBackStack()方法
        ShowBlueFragmentOne();
    }
    
    private void initView() {
        bt_red = (Button) findViewById(R.id.bt_red);
        bt_green = (Button) findViewById(R.id.bt_green);
        bt_blue = (Button) findViewById(R.id.bt_blue);
        fl_content = (FrameLayout) findViewById(R.id.fl_frameLayout_content);
    }

    private void initEvent() {
        bt_red.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ShowRedFragment();
            }
        });
        bt_green.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ShowGreenFragment();
            }
        });
        bt_blue.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                ShowBlueFragment();
            }
        });
    }


    private void ShowRedFragment() {
        //0.创建相应的Fragment对象（这个类的内容无关紧要）
        RedFragment redFragment = new RedFragment();
        redFragment.setLogName("RedFragment:");
        //1.获取到相应的fagnmentManager对象,注意此时使用的getSupportFragmentManager（）方法
//        FragmentManager supportFragmentManager = getSupportFragmentManager();
        //2.开启FragmentManager对象的事务管理器
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        //3.调用事物管理器中的方法replace（）或者add（），将fragment对象添加到当前的activity中，并指定其要替换的xml中的控件的id
        //该方法的第三个参数为这个Fragment的tag，可以根据findFragmentByTag(String tag);来获取相应的Fragment对象。
        fragmentTransaction.add(R.id.fl_frameLayout_content, redFragment, "redFragment").addToBackStack(null);
        //4.向fragment事务管理器提交，创建fragment
        fragmentTransaction.commit();
    }

    private void ShowGreenFragment() {
        GreenFragment greenFragment = new GreenFragment();
        greenFragment.setLogName("greenFragment:");
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.add(R.id.fl_frameLayout_content, greenFragment, "GreenFragment").addToBackStack(null);
        fragmentTransaction.commit();

    }

    private void ShowBlueFragment() {
        BlueFragment blueFragment = new BlueFragment();
        blueFragment.setLogName("blueFragment:");
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.add(R.id.fl_frameLayout_content, blueFragment, "BlueFragment").addToBackStack(null);
        fragmentTransaction.commit();
    }

    private void ShowBlueFragmentOne() {
        BlueFragment blueFragment = new BlueFragment();
        blueFragment.setLogName("blueFragment:");
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        fragmentTransaction.add(R.id.fl_frameLayout_content, blueFragment, "blueFragment");
        fragmentTransaction.commit();
    }
}

<2>.第二种方式：使用add（）+addToBackStack（）+直接重写onBackPressed()

<1>第二种方法和第一种方法的区别：

<1>不用设置第一个添加到activity的fragment对象不能使用addToBackStack(）方法.
                <2>直接重写onBackProgress()方法，判断当前回退栈中Fragment的数目，如果该数目>1 ,那就让回退栈继续弹栈；如果该数目<=1 ,此时直接调用该activity的finish（）方法。

<2>第二种方法之重写onBackPressed（）

    @Override
    public void onBackPressed() {
        //获取当前回退栈中的fragment数目，如果为1，直接finish；如果>1,则调用方式进行弹栈
            if(getFragmentManager().getBackStackEntryCount()>1){
                getFragmentManager().popBackStack();
            }else {
                finish();
            }
    }