1.Fragment简介
 
在Android3.0之前的版本，通常程序是在较小屏幕的设备上（手机等）。尽管手机屏幕尺寸、分辨率、屏幕密度等参数存在较大的差异，但是手机交互界面的操作习惯基本相同。例如，对于一个联系人管理程序，通常都会首先用一个窗口显示所有的联系人名称以及少数的联系人的详细信息（如联系人电话号码等）。然后当单击某一个联系人时会另外显示一个窗口列出该联系人的详细信息，当然，更进一步的操作还可能有修改、删除联系人等。不管与手机屏幕相关参数如何变化，在手机上的联系人管理程序除了界面风格略有差异外，操作的流程都和这一过程基本上类似。
 
尽管界面的使用布局很容易实现，但是对于同时适应手机的平板电脑的APK程序就比较麻烦。通常是为不同的界面风格提供不同的布局文件，然后利用Android的本地化特性在不同的环境使用不同的布局文件。这种做法虽然可行，也能达到复用，但如果这类界面过多，就会造成布局文件过多，对于后期的维护就显得格外麻烦。为了解决这个问题，就需要一种可以布局、共享以及控制的通用式系统。
 
其目的是为了解决不同屏幕分辩率的动态和灵活UI设计。大屏幕如平板小屏幕如手机，平板电脑的设计使得其有更多的空间来放更多的UI组件，而多出来的空间存放UI使其会产生更多的交互，从而诞生了fragments。
 
2.Fragment的生命周期
 
Fragment必须依赖于Activity而存在，因此Activity的生命周期会直接影响到Fragment的生命周期。如果Activity是暂停状态，其中所有的Fragment都是暂停状态；如果Activity是stopped状态，这个Activity中所有Fragment都不能被启动；如果Activity被销毁，那么它其中的所有Fragment都会被销毁。但是，当Activity在活动状态时，可以独立控制Fragment的状态，比如加上或者移除Fragment。当进行fragment transaction（转换）的时候，可以把Fragment放入Activity的back stack中，这样用户就可以返回操作。
 
由图1可以看到，Fragment比Activity多了几个额外的生命周期回调函数。
 
 
图1.Activity与Fragment生命周期的关系
 
onAttach(Activity):当Fragment与Activity发生关联时调用，从该方法开始，就可以通过Fragment.getActivity方法获取与Fragment关联的窗口对象了，但在该方法中仍然无法操作Fragment中的控件。
onCreateView(LayoutInflater,ViewGroup,Bundle):创建该Fragment的视图。
onActivityCreate(Bundle):当Activity的onCreate方法返回时调用。
onDestroyView():与onCreateView相对应，当该Fragment的视图被移除时调用。
onDetach():与onAttach相对应，当Fragment与Activity关联被取消时调用。
3.Fragment的简单使用
 
1.静态地使用Fragment
 
在layout文件下分别创建fragment1.xml和fragment2.xml布局文件，然后在创建一个类Fragment1，这个类继承自Fragment，重写onCreateView()方法绑定fragment1.xml。重复此步，创建Fragment2。
 
package com.example.demo_test_for_fragment;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

public class Fragment1 extends Fragment {
    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment1, container, false);
    }
}
 
然后在activity_main.xml布局文件中，静态使用fragemnt1和fragment2。
 
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity"
    android:baselineAligned="false">
    <fragment
        android:layout_width="100dp"
        android:layout_height="match_parent"
        android:id="@+id/fragment1"
        android:name="com.example.demo_test_for_fragment.Fragment1"/>
    <fragment
        android:layout_width="100dp"
        android:layout_height="match_parent"
        android:id="@+id/fragment2"
        android:name="com.example.demo_test_for_fragment.Fragment2"/>
</LinearLayout>
 
2.动态调用
 
在activity_main.xml布局文件中，不静态使用fragment1和fragment2。在MainActivity的onCreate()方法根据屏幕的情况（竖屏或者横屏），使用不同的fragment。
 
package com.example.demo_test_for_fragment;

import androidx.appcompat.app.AppCompatActivity;

import android.annotation.SuppressLint;
import android.os.Bundle;
import android.view.Display;

public class MainActivity extends AppCompatActivity {

    @SuppressLint("ResourceType")
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Display display = getWindowManager().getDefaultDisplay();
        if (display.getWidth() > display.getHeight()){//横屏采用fragment1
            Fragment1 fragment1 = new Fragment1();
            getFragmentManager().beginTransaction().replace(R.id.main_layout,fragment1).commit();
        }else{//竖屏采用fragment2
            Fragment2 fragment2 = new Fragment2();
            getFragmentManager().beginTransaction().replace(R.id.main_layout,fragment2).commit();
        }
    }
}
 
3.Fragment之间的通信
 
Fragment的存在必须依附于Activity，FragmentActivity是继承自Activity的。Fragment之间通信的桥梁就是FragmentManager类，这个类是用来管理所有的Fragment的，所以可以找到任何一个所需要的Fragment类。另外，Activity一般都会包含多个Fragment，这时多个Fragment之间如何进行通信就是个非常重要的问题了。下面通过一个例子来演示一下，如何在一个Fragment中去访问另一个Fragment的视图。
 
在静态代码上做修改。
 
首先打开fragment2.xml，在这个布局里面添加一个按钮。
 
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="fragment2"
        android:textSize="25sp"
        android:textColor="#000000"/>
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/button"
        android:text="get fragemnt1 text"/>
</LinearLayout>
 
在fragment1.xml，为TextView添加一个id
 
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="fragment1"
        android:textSize="25sp"
        android:textColor="#000000"
        android:id="@+id/fragment1_text"/>

</LinearLayout>
 
打开Fragment2.java，添加onActivityCreated方法，并处理按钮的单击事件。
 
package com.example.demo_test_for_fragment;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.TextView;
import android.widget.Toast;

import androidx.annotation.Nullable;

public class Fragment2 extends Fragment {
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment2, container, false);
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        Button button = getActivity().findViewById(R.id.button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                TextView textView = getActivity().findViewById(R.id.fragment1_text);
                Toast.makeText(getActivity(),textView.getText(),Toast.LENGTH_SHORT).show();
            }
        });
    }
}
 
运行效果如下图。如何实现的呢？主要通过getActivity方法可以让Fragment获取关联的Activity，然后再调用Activity的findViewById方法，就可以获取和这个Activity关联的其他Fragment的视图了。
 
 
 

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/37970961
自从Fragment出现，曾经有段时间，感觉大家谈什么都能跟Fragment谈上关系，做什么都要问下Fragment能实现不~~~哈哈，是不是有点过~~~
本篇博客力求为大家说明Fragment如何产生，什么是Fragment，Fragment生命周期，如何静态和动态的使用Fragment，Fragment回退栈，Fragment事务；以及Fragment的一些特殊用途，例如：没有布局的Fragment有何用处？Fragment如何与Activity交互？Fragment如何创建对话框？Fragment如何与ActionBar集成等等。
1、Fragment的产生与介绍
Android运行在各种各样的设备中，有小屏幕的手机，超大屏的平板甚至电视。针对屏幕尺寸的差距，很多情况下，都是先针对手机开发一套App，然后拷贝一份，修改布局以适应平板神马超级大屏的。难道无法做到一个App可以同时适应手机和平板么，当然了，必须有啊。Fragment的出现就是为了解决这样的问题。你可以把Fragment当成Activity的一个界面的一个组成部分，甚至Activity的界面可以完全有不同的Fragment组成，更帅气的是Fragment拥有自己的生命周期和接收、处理用户的事件，这样就不必在Activity写一堆控件的事件处理的代码了。更为重要的是，你可以动态的添加、替换和移除某个Fragment。

2、Fragment的生命周期

Fragment必须是依存与Activity而存在的，因此Activity的生命周期会直接影响到Fragment的生命周期。官网这张图很好的说明了两者生命周期的关系：

可以看到Fragment比Activity多了几个额外的生命周期回调方法：


onAttach(Activity)



当Fragment与Activity发生关联时调用。


onCreateView(LayoutInflater, ViewGroup,Bundle)



创建该Fragment的视图


onActivityCreated(Bundle)



当Activity的onCreate方法返回时调用


onDestoryView()



与onCreateView想对应，当该Fragment的视图被移除时调用


onDetach()



与onAttach相对应，当Fragment与Activity关联被取消时调用

注意：除了onCreateView，其他的所有方法如果你重写了，必须调用父类对于该方法的实现，


3、静态的使用Fragment
嘿嘿，终于到使用的时刻了~~
这是使用Fragment最简单的一种方式，把Fragment当成普通的控件，直接写在Activity的布局文件中。步骤：
1、继承Fragment，重写onCreateView决定Fragemnt的布局
2、在Activity中声明此Fragment，就当和普通的View一样
下面展示一个例子（我使用2个Fragment作为Activity的布局，一个Fragment用于标题布局，一个Fragment用于内容布局）：
TitleFragment的布局文件:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="45dp"
    android:background="@drawable/title_bar" >

    <ImageButton
        android:id="@+id/id_title_left_btn"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerVertical="true"
        android:layout_marginLeft="3dp"
        android:background="@drawable/showleft_selector" />

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:gravity="center"
        android:text="我不是微信"
        android:textColor="#fff"
        android:textSize="20sp"
        android:textStyle="bold" />

</RelativeLayout>

TitleFragment


package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.ImageButton;
import android.widget.Toast;

public class TitleFragment extends Fragment
{

	private ImageButton mLeftMenu;

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		View view = inflater.inflate(R.layout.fragment_title, container, false);
		mLeftMenu = (ImageButton) view.findViewById(R.id.id_title_left_btn);
		mLeftMenu.setOnClickListener(new OnClickListener()
		{
			@Override
			public void onClick(View v)
			{
				Toast.makeText(getActivity(),
						"i am an ImageButton in TitleFragment ! ",
						Toast.LENGTH_SHORT).show();
			}
		});
		return view;
	}
}


同理还有ContentFragment的其布局文件：


<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <TextView
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:gravity="center"
        android:text="使用Fragment做主面板"
        android:textSize="20sp"
        android:textStyle="bold" />

</LinearLayout>


package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

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


package com.zhy.zhy_fragments;

import android.app.Activity;
import android.os.Bundle;
import android.view.Window;

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


<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <fragment
        android:id="@+id/id_fragment_title"
        android:name="com.zhy.zhy_fragments.TitleFragment"
        android:layout_width="fill_parent"
        android:layout_height="45dp" />

    <fragment
        android:layout_below="@id/id_fragment_title"
        android:id="@+id/id_fragment_content"
        android:name="com.zhy.zhy_fragments.ContentFragment"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" />

</RelativeLayout>

是不是把Fragment当成普通的View一样声明在Activity的布局文件中，然后所有控件的事件处理等代码都由各自的Fragment去处理，瞬间觉得Activity好干净有木有~~代码的可读性、复用性以及可维护性是不是瞬间提升了~~~下面看下效果图：



4、动态的使用Fragment
上面已经演示了，最简单的使用Fragment的方式~下面介绍如何动态的添加、更新、以及删除Fragment
为了动态使用Fragment，我们修改一下Actvity的布局文件，中间使用一个FrameLayout，下面添加四个按钮~~~嘿嘿~~不是微信的按钮- -！

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <fragment
        android:id="@+id/id_fragment_title"
        android:name="com.zhy.zhy_fragments.TitleFragment"
        android:layout_width="fill_parent"
        android:layout_height="45dp" />

    <include
        android:id="@+id/id_ly_bottombar"
        android:layout_width="fill_parent"
        android:layout_height="55dp"
        android:layout_alignParentBottom="true"
        layout="@layout/bottombar" />

    <FrameLayout
        android:id="@+id/id_content"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:layout_above="@id/id_ly_bottombar"
        android:layout_below="@id/id_fragment_title" />

</RelativeLayout>

底部四个按钮的布局就不贴了，到时看效果图就明白了~~

下面主Activity

package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.LinearLayout;

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()
	{
		FragmentManager fm = getFragmentManager();
		FragmentTransaction transaction = fm.beginTransaction();
		mWeixin = new ContentFragment();
		transaction.replace(R.id.id_content, mWeixin);
		transaction.commit();
	}

	@Override
	public void onClick(View v)
	{
		FragmentManager fm = getFragmentManager();
		// 开启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();
	}

}


可以看到我们使用FragmentManager对Fragment进行了动态的加载，这里使用的是replace方法~~下一节我会详细介绍FragmentManager的常用API。

注：如果使用Android3.0以下的版本，需要引入v4的包，然后Activity继承FragmentActivity，然后通过getSupportFragmentManager获得FragmentManager。不过还是建议版Menifest文件的uses-sdk的minSdkVersion和targetSdkVersion都改为11以上，这样就不必引入v4包了。
代码中间还有两个Fragment的子类，ContentFragment上面已经见过，FriendFragment其实类似：

package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class FriendFragment extends Fragment
{

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		return inflater.inflate(R.layout.fragment_friend, container, false);
	}

}


效果图：



可以看到很好的实现了效果，其实这个效果以前的博客中也出现过，在博客：Android项目Tab类型主界面大总结 Fragment+TabPageIndicator+ViewPager，有兴趣可以看看。ps:为了代码的简洁，就不添加按钮的点击变化什么的了，主要讲解功能了~~~
5、Fragment家族常用的API
Fragment常用的三个类：
android.app.Fragment 主要用于定义Fragment
android.app.FragmentManager 主要用于在Activity中操作Fragment
android.app.FragmentTransaction 保证一些列Fragment操作的原子性，熟悉事务这个词，一定能明白~
a、获取FragmentManage的方式：
getFragmentManager() // v4中，getSupportFragmentManager
b、主要的操作都是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状态不一致：State loss这样的错误。主要是因为：commit方法一定要在Activity.onSaveInstance()之前调用。

上述，基本是操作Fragment的所有的方式了，在一个事务开启到提交可以进行多个的添加、移除、替换等操作。
值得注意的是：如果你喜欢使用Fragment，一定要清楚这些方法，哪个会销毁视图，哪个会销毁实例，哪个仅仅只是隐藏，这样才能更好的使用它们。
a、比如：我在FragmentA中的EditText填了一些数据，当切换到FragmentB时，如果希望会到A还能看到数据，则适合你的就是hide和show；也就是说，希望保留用户操作的面板，你可以使用hide和show，当然了不要使劲在那new实例，进行下非null判断。
b、再比如：我不希望保留用户操作，你可以使用remove()，然后add()；或者使用replace()这个和remove,add是相同的效果。
c、remove和detach有一点细微的区别，在不考虑回退栈的情况下，remove会销毁整个Fragment实例，而detach则只是销毁其视图结构，实例并不会被销毁。那么二者怎么取舍使用呢？如果你的当前Activity一直存在，那么在不希望保留用户操作的时候，你可以优先使用detach。


上述已经介绍完成了Fragment常用的一些方法，相信看完，大家一定清楚了Fragment的产生理由，以及如何使用Fragment，再根据API的讲解，也能明白，曾经为何觉得Fragment会出现一些列乱七八槽的问题，终究是因为没有弄清楚其生命周期。
由于篇幅原因，剩下的内容留到下一篇了。在下一篇，会介绍：
1、如何管理Fragment回退栈
2、Fragment如何与Activity交互
3、Fragment与Activity交互的最佳实践
4、没有视图的Fragment的用处
5、使用Fragment创建对话框
6、如何与ActionBar，MenuItem集成等~~


下一篇：Android Fragment 真正的完全解析（下）



好了，有任何问题请留言~~










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

 


 

 

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/37992017
上篇博客中已经介绍了Fragment产生原因，以及一些基本的用法和各种API，如果你还不了解，请看：Android Fragment 真正的完全解析（上）。
本篇将介绍上篇博客提到的：如何管理Fragment回退栈，Fragment如何与Activity交互，Fragment与Activity交互的最佳实践，没有视图的Fragment的用处，使用Fragment创建对话框，如何与ActionBar，MenuItem集成等~~
1、管理Fragment回退栈
类似与Android系统为Activity维护一个任务栈，我们也可以通过Activity维护一个回退栈来保存每次Fragment事务发生的变化。如果你将Fragment任务添加到回退栈，当用户点击后退按钮时，将看到上一次的保存的Fragment。一旦Fragment完全从后退栈中弹出，用户再次点击后退键，则退出当前Activity。
看这样一个效果图：


点击第一个按钮，切换到第二个界面，点击第二个按钮，切换到第三个界面，然后点击Back键依次回退。这像不像初学Android时的Activity跳转，当然了，这里肯定不是，不然我就跪了。这里是Fragment实现的，用户点击Back，实际是Fragment回退栈不断的弹栈。
如何添加一个Fragment事务到回退栈：
FragmentTransaction.addToBackStack(String)

下面讲解代码：很明显一共是3个Fragment和一个Activity.
先看Activity的布局文件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <FrameLayout
        android:id="@+id/id_content"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent" >
    </FrameLayout>

</RelativeLayout>
不同的Fragment就在这个FrameLayout中显示。

MainActivity.java

package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.Window;

public class MainActivity extends Activity
{


	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.activity_main);

		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.add(R.id.id_content, new FragmentOne(),"ONE");
		tx.commit();
	}

}
很简单，直接将FragmentOne添加到布局文件中的FrameLayout中，注意这里并没有调用FragmentTransaction.addToBackStack(String)，因为我不喜欢在当前显示时，点击Back键出现白板。而是正确的相应Back键，即退出我们的Activity.

下面是FragmentOne

package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

public class FragmentOne extends Fragment implements OnClickListener
{

	private Button mBtn;

	@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;
	}

	@Override
	public void onClick(View v)
	{
		FragmentTwo fTwo = new FragmentTwo();
		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.replace(R.id.id_content, fTwo, "TWO");
		tx.addToBackStack(null);
		tx.commit();

	}

}


我们在点击FragmentOne中的按钮时，使用了replace方法，如果你看了前一篇博客，一定记得replace是remove和add的合体，并且如果不添加事务到回退栈，前一个Fragment实例会被销毁。这里很明显，我们调用tx.addToBackStack(null);将当前的事务添加到了回退栈，所以FragmentOne实例不会被销毁，但是视图层次依然会被销毁，即会调用onDestoryView和onCreateView，证据就是：仔细看上面的效果图，我们在跳转前在文本框输入的内容，在用户Back得到第一个界面的时候不见了。

接下来FragmentTwo

package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

public class FragmentTwo extends Fragment implements OnClickListener
{

	private Button mBtn ;
	@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)
	{
		FragmentThree fThree = new FragmentThree();
		FragmentManager fm = getFragmentManager();
		FragmentTransaction tx = fm.beginTransaction();
		tx.hide(this);
		tx.add(R.id.id_content , fThree, "THREE");
//		tx.replace(R.id.id_content, fThree, "THREE");
		tx.addToBackStack(null);
		tx.commit();
	}


}


这里点击时，我们没有使用replace，而是先隐藏了当前的Fragment，然后添加了FragmentThree的实例，最后将事务添加到回退栈。这样做的目的是为了给大家提供一种方案：如果不希望视图重绘该怎么做，请再次仔细看效果图，我们在FragmentTwo的EditText填写的内容，用户Back回来时，数据还在~~~

最后FragmentThree就是简单的Toast了：

package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.Toast;

public class FragmentThree extends Fragment implements OnClickListener
{

	private Button mBtn;

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		View view = inflater.inflate(R.layout.fragment_three, container, false);
		mBtn = (Button) view.findViewById(R.id.id_fragment_three_btn);
		mBtn.setOnClickListener(this);
		return view;
	}

	@Override
	public void onClick(View v)
	{
		Toast.makeText(getActivity(), " i am a btn in Fragment three",
				Toast.LENGTH_SHORT).show();
	}

}


好了，经过上面的介绍，应该已经知道Fragment回退栈是怎么一回事了，以及hide，replace等各自的应用的场景。

这里极其注意一点：上面的整体代码不具有任何参考价值，纯粹为了显示回退栈，在后面讲解了Fragment与Activity通信以后，会重构上面的代码！
2、Fragment与Activity通信
因为所有的Fragment都是依附于Activity的，所以通信起来并不复杂，大概归纳为：
a、如果你Activity中包含自己管理的Fragment的引用，可以通过引用直接访问所有的Fragment的public方法
b、如果Activity中未保存任何Fragment的引用，那么没关系，每个Fragment都有一个唯一的TAG或者ID,可以通过getFragmentManager.findFragmentByTag()或者findFragmentById()获得任何Fragment实例，然后进行操作。
c、在Fragment中可以通过getActivity得到当前绑定的Activity的实例，然后进行操作。
注：如果在Fragment中需要Context，可以通过调用getActivity(),如果该Context需要在Activity被销毁后还存在，则使用getActivity().getApplicationContext()。
3、Fragment与Activity通信的最佳实践
因为要考虑Fragment的重复使用，所以必须降低Fragment与Activity的耦合，而且Fragment更不应该直接操作别的Fragment，毕竟Fragment操作应该由它的管理者Activity来决定。
下面我通过两种方式的代码，分别重构，FragmentOne和FragmentTwo的点击事件，以及Activity对点击事件的响应：
首先看FragmentOne

package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

public class FragmentOne extends Fragment implements OnClickListener
{
	private Button mBtn;

	/**
	 * 设置按钮点击的回调
	 * @author zhy
	 *
	 */
	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是否实现了该接口，如果实现了则调用。

再看FragmentTwo

package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.Button;

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)。

最后看Activity :

package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.Window;

import com.zhy.zhy_fragments.FragmentOne.FOneBtnClickListener;
import com.zhy.zhy_fragments.FragmentTwo.FTwoBtnClickListener;

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);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		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();
	}

}


代码重构结束，与开始的效果一模一样。上面两种通信方式都是值得推荐的，随便选择一种自己喜欢的。这里再提一下：虽然Fragment和Activity可以通过getActivity与findFragmentByTag或者findFragmentById，进行任何操作，甚至在Fragment里面操作另外的Fragment，但是没有特殊理由是绝对不提倡的。Activity担任的是Fragment间类似总线一样的角色，应当由它决定Fragment如何操作。另外虽然Fragment不能响应Intent打开，但是Activity可以，Activity可以接收Intent，然后根据参数判断显示哪个Fragment。

4、如何处理运行时配置发生变化
运行时配置发生变化，最常见的就是屏幕发生旋转，如果你不知道如何处理屏幕变化可以参考：Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案
这里提一下：很多人觉得强制设置屏幕的方向就可以了，但是有一点，当你的应用被至于后台（例如用户点击了home），长时间没有返回的时候，你的应用也会被重新启动。比如上例：如果你把上面的例子你至于FragmentThree界面，然后处于后台状态，长时间后你会发现当你再次通过home打开时，上面FragmentThree与FragmentOne叠加在一起，这就是因为你的Activity重新启动，在原来的FragmentThree上又绘制了一个FragmentOne。
好了，下面看一段代码：
Activity:

package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.view.Window;

public class MainActivity extends Activity

{
	private FragmentOne mFOne;

	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		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();

	}

}


Fragment


package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class FragmentOne extends Fragment
{
	private static final String TAG = "FragmentOne";

	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState)
	{
		Log.e(TAG, "onCreateView");
		View view = inflater.inflate(R.layout.fragment_one, container, false);
		return view;
	}

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);

		Log.e(TAG, "onCreate");
	}

	@Override
	public void onDestroyView()
	{
		// TODO Auto-generated method stub
		super.onDestroyView();
		Log.e(TAG, "onDestroyView");
	}

	@Override
	public void onDestroy()
	{
		// TODO Auto-generated method stub
		super.onDestroy();
		Log.e(TAG, "onDestroy");
	}

}


很简单的代码，当你运行之后，不断的旋转屏幕，你会发现每旋转一次屏幕，屏幕上就多了一个FragmentOne的实例，并且后台log会打印出许多套生命周期的回调。

类似：

07-20 08:18:46.651: E/FragmentOne(1633): onCreate
07-20 08:18:46.651: E/FragmentOne(1633): onCreate
07-20 08:18:46.651: E/FragmentOne(1633): onCreate
07-20 08:18:46.681: E/FragmentOne(1633): onCreateView
07-20 08:18:46.831: E/FragmentOne(1633): onCreateView
07-20 08:18:46.891: E/FragmentOne(1633): onCreateView


这是为什么呢，因为当屏幕发生旋转，Activity发生重新启动，默认的Activity中的Fragment也会跟着Activity重新创建；这样造成当旋转的时候，本身存在的Fragment会重新启动，然后当执行Activity的onCreate时，又会再次实例化一个新的Fragment，这就是出现的原因。

那么如何解决呢：
其实通过检查onCreate的参数Bundle savedInstanceState就可以判断，当前是否发生Activity的重新创建：
默认的savedInstanceState会存储一些数据，包括Fragment的实例：通过打印可以看出：

07-20 08:23:12.952: E/FragmentOne(1782): Bundle[{android:fragments=android.app.FragmentManagerState@40d0b7b8, android:viewHierarchyState=Bundle[{android:focusedViewId=2131230721, android:views=android.util.SparseArray@40d0af68}]}]
所以，我们简单改一下代码，只有在savedInstanceState==null时，才进行创建Fragment实例：


package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.util.Log;
import android.view.Window;

public class MainActivity extends Activity

{
	private static final String TAG = "FragmentOne";
	private FragmentOne mFOne;

	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.activity_main);

		Log.e(TAG, savedInstanceState+"");
		
		if(savedInstanceState == null)
		{
			mFOne = new FragmentOne();
			FragmentManager fm = getFragmentManager();
			FragmentTransaction tx = fm.beginTransaction();
			tx.add(R.id.id_content, mFOne, "ONE");
			tx.commit();
		}
		
		

	}

}


现在无论进行多次旋转都只会有一个Fragment实例在Activity中。

现在还存在一个问题，就是重新绘制时，Fragment发生重建，原本的数据如何保持？
其实和Activity类似，Fragment也有onSaveInstanceState的方法，在此方法中进行保存数据，然后在onCreate或者onCreateView或者onActivityCreated进行恢复都可以。
由于篇幅原因，就不贴测试代码了。
5、Fragmeny与ActionBar和MenuItem集成
Fragment可以添加自己的MenuItem到Activity的ActionBar或者可选菜单中。
a、在Fragment的onCreate中调用 setHasOptionsMenu(true);
b、然后在Fragment子类中实现onCreateOptionsMenu
c、如果希望在Fragment中处理MenuItem的点击，也可以实现onOptionsItemSelected；当然了Activity也可以直接处理该MenuItem的点击事件。
代码：
Fragment

package com.zhy.zhy_fragments;

import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Toast;

public class FragmentOne extends Fragment
{

	@Override
	public void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		setHasOptionsMenu(true);
	}

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

	@Override
	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater)
	{
		inflater.inflate(R.menu.fragment_menu, menu);
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		switch (item.getItemId())
		{
		case R.id.id_menu_fra_test:
			Toast.makeText(getActivity(), "FragmentMenuItem1", Toast.LENGTH_SHORT).show();
			break;
		}
		return true;
	}

}


Activity


package com.zhy.zhy_fragments;

import android.app.Activity;
import android.app.FragmentManager;
import android.app.FragmentTransaction;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.Window;
import android.widget.Toast;

public class MainActivity extends Activity

{
	private static final String TAG = "FragmentOne";
	private FragmentOne mFOne;

	@Override
	protected void onCreate(Bundle savedInstanceState)
	{
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.activity_main);

		Log.e(TAG, savedInstanceState + "");

		if (savedInstanceState == null)
		{
			mFOne = new FragmentOne();
			FragmentManager fm = getFragmentManager();
			FragmentTransaction tx = fm.beginTransaction();
			tx.add(R.id.id_content, mFOne, "ONE");
			tx.commit();
		}

	}

	@Override
	public boolean onCreateOptionsMenu(Menu menu)
	{
		super.onCreateOptionsMenu(menu);
		getMenuInflater().inflate(R.menu.main, menu);
		return true;
	}

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		switch (item.getItemId())
		{
		case R.id.action_settings:
			Toast.makeText(this, "setting", Toast.LENGTH_SHORT).show();
			return true;
		default:
			//如果希望Fragment自己处理MenuItem点击事件，一定不要忘了调用super.xxx
			return super.onOptionsItemSelected(item);
		}
	}

}


效果图：


好了，可以很好的看到，Fragment可以添加MenuItem，也可以自己处理点击~~~
6、没有布局的Fragment的作用
没有布局文件Fragment实际上是为了保存，当Activity重启时，保存大量数据准备的
请参考博客：Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案


7、使用Fragment创建对话框
这是Google推荐的方式，我也单独写过博客介绍，请参考：Android 官方推荐 : DialogFragment 创建对话框


好了，终于把Fragment相关的联系到一起了，上述基本包含了Fragment所有的用法~~~相信大家如果能够看完，一定有不少的收获~~~


有任何问题，欢迎留言~~~
两篇结束，相信你对Fragment已经有了一定的了解，那么在项目中的最佳实践是什么呢？请移步：Android Fragment 你应该知道的一切

前言：follow your heart,be your own king
 
 
 
 
 
相关文章：
 
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（）获得
常用的方法有：
 
 
 
manager.findFragmentById();  //根据ID来找到对应的Fragment实例，主要用在静态添加fragment的布局中，因为静态添加的fragment才会有ID
manager.findFragmentByTag();//根据TAG找到对应的Fragment实例，主要用于在动态添加的fragment中，根据TAG来找到fragment实例
manager.getFragments();//获取所有被ADD进Activity中的Fragment
 
2、FragmentTransaction
 
 
 
一般用来对当前的Fragment进行管理，包括add,replace,remove；
 常用的针对Fragment的方法有：
 
 
 
 
 
 
 
//将一个fragment实例添加到Activity的最上层
add(int containerViewId, Fragment fragment, String tag);
//将一个fragment实例从Activity的fragment队列中删除
remove(Fragment fragment);
//替换containerViewId中的fragment实例，注意，它首先把containerViewId中所有fragment删除，然后再add进去当前的fragment
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:
 
 
 
 
 
 
 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ff00f0"
    android:orientation="vertical" >
    
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="This is fragment 1"
        android:textColor="#000000"
        android:textSize="25sp" />

</LinearLayout>
 
fragment2.xml:
 
 
 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:background="#ffff00"
    android:orientation="vertical" >
    
    <TextView
        android:id="@+id/fragment2_tv"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="This is fragment 2"
        android:textColor="#000000"
        android:textSize="25sp" />
    
</LinearLayout>
 
2、建立对应的Fragment类：Fragment1和Fragment2
 
 
 
Fragment1:
 
 
 
 
 
 
 
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class Fragment1 extends Fragment {
	@Override
	public View onCreateView(LayoutInflater inflater, ViewGroup container,
			Bundle savedInstanceState) {
		return inflater.inflate(R.layout.fragment1, container, false);
	}

}
 
与上一篇一样，也只是在onCreateView()时返回对应的布局。同样，Fragment2的定义如下：
 
import android.os.Bundle;
import android.support.v4.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;

public class Fragment2 extends Fragment {
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment2, container, false);
    }
}
 
3、MainActivity的布局
 
 
 
从上面的的效果图中也可以看出大概的布局，首先是三个Button，最下方是一个FrameLayout布局，它是用来做为container动态盛装fragment的；它就像是一个占位符，你设置多大，它其中的fragment就最大能有多大。记住，fragment也是Activity中的一个普通控件而已，只不过它可以像Activity一样用于显示的同时还能用来盛装其它控件！作为fragment的容器，即可以用FrameLayout也可以用LinearLayout或者RelativeLayout，都是一样的。activity_main.xml的布局代码如下：
 
 
 
 
 
 
 
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/btn_add_frag1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="ADD  Fragment1" />

    <Button
        android:id="@+id/btn_add_frag2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="ADD  Fragment2" />

    <Button
        android:id="@+id/btn_remove_frag2"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Remove  Fragment2" />

    <Button
        android:id="@+id/btn_repalce_frag1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="replace  Fragment1" />

    <FrameLayout
        android:id="@+id/fragment_container"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

</LinearLayout>
 
4、MainActivity的实现：
 
（1）首先，先写一个添加fragment到Activity中的函数：
 
 
 
 
 
private void addFragment(Fragment fragment, String tag) {
    FragmentManager manager = getSupportFragmentManager();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.add(R.id.fragment_container, fragment, tag);
    transaction.commit();
}
 
先是传进来两个参数，一个是要添加的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”按钮时：
 
 
 
Fragment1 fragment1 = new Fragment1();
addFragment(fragment1, "fragment1");
 
当点击“ADD Fragment2”按钮时：
 
Fragment2 fragment2 = new Fragment2();
addFragment(fragment2, "fragment2");
 
这里需要注意的是，当我们添加每个Fragment实例时，都传进去一个对应的TAG，fragment1对应的是“fragment1”，fragment2对应的是“fragment2”，通过这些TAG，我们就可以通过findFragmentByTag()来获取它们了。
（3）RemoveFragment2:
 下面就是当点击“RemoveFragment2”按钮时的代码操作了：
 
private void removeFragment2() {
    FragmentManager manager = getSupportFragmentManager();
    Fragment fragment = manager.findFragmentByTag("fragment2");
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.remove(fragment);
    transaction.commit();
}
 
首先是通过
 
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的代码：
 
private void replaceFragment1() {
    FragmentManager manager = getSupportFragmentManager();
    Fragment2 fragment2 = new Fragment2();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.replace(R.id.fragment_container, fragment2);
    transaction.commit();
}
 
这里有个注意的问题：
 
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()将其添加到回退栈中。
 
 
 
 
 
 
 
transaction.addToBackStack(String tag);
 
在需要回退时，使用popBackStack()将最上层的操作弹出回退栈。
 
manager.popBackStack();
 
这里的popBackStack()是弹出默认的最上层的栈顶内容。
 当栈中有多层时，我们可以根据id或TAG标识来指定弹出到的操作所在层。函数如下：
 
void popBackStack(int id, int flags);
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时，表示连着参数一指定的这一层一起退出栈； 
除了这几个函数，还有下面几个函数：有关他们的使用，我们在这小部分结尾时会提到
popBackStackImmediate()
popBackStackImmediate(String tag)
popBackStackImmediate(String tag, int flag)
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”，其实调用的方法是：
 
manager.popBackStack("fragment2",0);//方法一,通过TAG回退
 
从这里可以看出，要回退到添加ADD Fragment2的状态，注意最后一个参数，这里设为0，表明，要回退ADD Fragment2的之后的操作，将ADD Fragment2的操作置为栈顶。从效果图中也可以看出，点击后的视图在Fragment2的位置
 4、最后仍然是先点击"Add Fragment3"和"ADD Fragment4"，将栈还原到操作1完成后的栈状态。然后点击“BackToStack2_INCLUSIVE”;其调用的方法是：
 
manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退
 
这里与上面的主要不同点在于第二个参数，这里设置为POP_BACK_STACK_INCLUSIVE，即在出栈时连带ADD Fragment2的操作一块出栈，放在栈顶的是ADD Fragment1的操作，所以放在界面上就是显示的是Fragment1的视图。
下面我们看看具体实现：
(1)、首先，与上部分一样，先添加四个Fragment，并用背景色和文字来区分。这部分代码我们就不讲了。
 主要看看点击按钮的代码处理方法。
(2)、首先是添加Fragment1:
 
 
 
Fragment1 fragment1 = new Fragment1();
stackID1 = addFragment(fragment1,"fragment1");
 
其中：
 
 
 
private int stackID1,stackID2,stackID3,stackID4;
 
private int addFragment(Fragment fragment,String stackName){
    FragmentManager manager = getSupportFragmentManager();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.add(R.id.fragment_container,fragment);
    transaction.addToBackStack(stackName);
    return transaction.commit();
}
 
首先，这里的stackID1,stackID2,stackID3,stackID4是用来保存每次commit()后返回的Transaction的ID值。在void popBackStack(int id, int flags);时，其中的参数id就是这个值
 然后在每次ADD操作后，利用addToBackStack(string name)将每次ADD操作添加进回退栈中；
 同样，添加Fragment2的代码如下，添加Fragment3,Fragment4的方法同理
 
Fragment2 fragment2 = new Fragment2();
stackID2 = addFragment(fragment2,"fragment2");
 
(3)、然后是回退栈顶内容：
 
 
 
private void popBackStack(){
    FragmentManager manager = getSupportFragmentManager();
    manager.popBackStack();
}
 
(4)、接着是点击BackToFrag2_0按钮的内容，这里有两种方法实现，一种是指定TAG，一种是利用Commit()返回的ID
 
 
 
private void popBackStackToFrag2_0(){
	FragmentManager manager = getSupportFragmentManager();
	manager.popBackStack("fragment2",0);//方法一,通过TAG回退
	// manager.popBackStack(stackID2,0);//方法二,通过Transaction ID回退
}
 
（5）、最后是点击BackToFrag2_INCLUSIVE按钮的代码：
 
 
 
private void popBackStackToFrag2_Inclusive(){
    FragmentManager manager = getSupportFragmentManager();
    manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退
// manager.popBackStack(stackID2,FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法二,通过Transaction ID回退
}
 
好了，到这里，有关回滚的基本使用就结束了，需要要注意的是：
使用popBackStack()来弹出栈内容的话，调用该方法后会将事物操作插入到FragmentManager的操作队列，只有当轮询到该事物时才能执行。如果想立即执行事物的话，需要使用下面几个对应的方法：
 
 
 
popBackStackImmediate()
popBackStackImmediate(String tag)
popBackStackImmediate(String tag, int flag)
popBackStackImmediate(int id, int flag)
 
2、回退栈（back stack）状态改变监听
 
 
 
FragmentManager还为我们提供了监控回退栈状态改变的方法：
 
 
 
 
 
 
 
FragmentManager::addOnBackStackChangedListener(listener);//添加监听器
FragmentManager::removeOnBackStackChangedListener(listener);//移除监听器
 
通过添加监听器，就可以在回退栈内容改变时，及时收到通知；
 我们在上面代码的基础上，在MainAcitivy中为FragmentManager添加一个监听器，当回退栈状态改变时，打出一个LOG。具体实现如下：
（1）、OnCreate()中：
 为fragmentManger添加一个监听器：
 
FragmentManager manager = getSupportFragmentManager();
listener = new FragmentManager.OnBackStackChangedListener() {
	
	@Override
	public void onBackStackChanged() {
		// TODO Auto-generated method stub
		Log.d("qijian","backstack changed");
	}
};
manager.addOnBackStackChangedListener(listener);
 
(2)、当onDestory()中将监听器remove掉：
 
 
 
protected void onDestroy() {
	// TODO Auto-generated method stub
	super.onDestroy();
	FragmentManager manager = getSupportFragmentManager();
	manager.removeOnBackStackChangedListener(listener);
}
 
大家一定要注意，不管是这里的回退栈的监听还是其它的监听器，在页面对应的销毁时，都要记得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的代码如下：
 
 
 
private void addFragment1() {
    Fragment1 fragment1 = new Fragment1();
    FragmentManager manager = getSupportFragmentManager();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.add(R.id.fragment_container, fragment1);
    transaction.addToBackStack("fragment1");
    transaction.commit();
}
 
3、然后是添加其它三个Fragment的代码如下：
 
 
 
private void addOtherFragments() {
    Fragment2 fragment2 = new Fragment2();
    Fragment3 fragment3 = new Fragment3();
    Fragment4 fragment4 = new Fragment4();
    FragmentManager manager = getSupportFragmentManager();
    FragmentTransaction transaction = manager.beginTransaction();
    transaction.add(R.id.fragment_container, fragment2);
    transaction.add(R.id.fragment_container, fragment3);
    transaction.add(R.id.fragment_container, fragment4);
    transaction.addToBackStack("other fragments");
    transaction.commit();
}
 
再一次重申，从代码中也可以看到，是依次将Fragment2、Fragment3、Fragment4加入容器之后，再提交一次事务，所以下面回滚时，会将他们反顺序的依次删除。即remove(fragment4)、remove(fragment3)、remove(fragment2)
4、点击popBackStack按钮时的代码
 
 
 
private void popBackStack() {
    FragmentManager manager = getSupportFragmentManager();
    manager.popBackStack();
}
 
 
 
 
 
好了，到这里这篇文章就结束了，这篇文章太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， 谢谢！
 
 
 
如果你喜欢我的文章，你可能更喜欢我的公众号