史上最全Fragment介绍，包括fragment的定义，生命周期，用法

淩亂°似流年 2022-07-19 00:21 224阅读 0赞

**一、为什么要使用Fragment**

1、当我们需要动态的多界面切换的时候，就需要将UI元素和Activity融合成一个模块。在2.3中我们一般通过各种Activity中进行跳转来实现多界面的跳转和单个界面动态改变。在4.0或以上系统中就可以使用新的特性来方便的达到这个效果--Fragment类。Fragment类似一个嵌套Activity，可以定义自己的layout和自己的生命周期。

2、 多个Fragment可以放在一个Activity中（所以上面讲到类似一个嵌套Activity），而这个类可以对这些Fragment进行配置以适应不同的屏幕尺寸（比如平板和手机）。

**二、使用Fragment**

1、Fragment 是 activity 的界面中的一部分或一种行为。可以把多个 Fragment 组合到一个 activity 中来创建一 个多面界面并且可以在多个 activity 中重用一个 Fragment。可以把 Fragment 认为模块化的一段 activity,它具 有自己的生命周期,接收它自己的事件,并可以在 activity 运行时被添加或删除。

2、Fragment 不能独立存在,它必须嵌入到 activity 中,而且 Fragment 的生命周期直接受所在的 activity 的影 响。

3、当向 activity 中添加一个 Fragment 时,它须置于 ViewGroup 控件中,并且需定义 Fragment 自己的界面。可 以在 layoutxml 文件中声明 Fragment,元素为:;也可以在代码中创建 Fragment,然后把它加入到 ViewGroup 控件中。然而,Fragment 不一定非要放在 activity 的界面中,它可以隐藏在后台为 actvitiy 工作。

**三、 生命周期**

通常, 应当至少实现如下的生命周期方法:

onCreate()  
当创建fragment时, 系统调用该方法.

在实现代码中,应当初始化想要在fragment中保持的必要组件, 当fragment被暂停或者停止后可以恢复.

onCreateView()  
fragment第一次绘制它的用户界面的时候, 系统会调用此方法. 为了绘制fragment的UI,此方法必须返回一个View, 这个view是你的fragment布局的根view. 如果fragment不提供UI, 可以返回null.

onPause()

用户将要离开fragment时,系统调用这个方法作为第一个指示(然而它不总是意味着fragment将被销毁.) 在当前用户会话结束之前,通常应当在这里提交任何应该持久化的变化(因为用户有可能不会返回).

大多数程序应最少对 fragment 实现这三个方法。当然还有其它几个回调方法可应该按情况实现之。  
下图为 fragment 的生命周期(它所在的 activity 处于运行状态)。

![\\][20140811054117_0.gif]

**四、如何使用Fragment**

**1、添加一个用户界面**   
fragment通常用来作为一个activity的用户界面的一部分,并将它的layout提供给activity.为了给一个fragment提供一 个layout,你必须实现 onCreateView()回调方法, 当到了fragment绘制它自己的layout的时候,Android系统调用它.你的此方法的实现代码必须返回一个你的fragment的 layout的根view.

从onCreateView()返回的View, 也可以从一个layout的xml资源文件中读取并生成. 为了帮助你这么做, onCreateView() 提供了一个LayoutInflater 对象.  
  
举个例子, 这里有一个Fragment的子类, 从文件 frament\_main.xml 加载了一个layout:

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

PS  
传入onCreateView()的container参数是你的fragmentlayout将被插入的父ViewGroup(来自activity的layout) savedInstanceState 参数是一个Bundle, 如果fragment是被恢复的,它提供关于fragment的之前的实例的数据,  
  
inflate() 方法有3个参数:  
  
a、想要加载的layout的resource ID.  
b、加载的layout的父ViewGroup.传入container是很重要的, 目的是为了让系统接受所要加载的layout的根view的layout参数,由它将挂靠的父view指定.  
c、布尔值指示在加载期间, 展开的layout是否应当附着到ViewGroup (第二个参数).

**2、将fragment添加到activity**  
通常地, fragment为宿主activity提供UI的一部分, 被作为activity的整个viewhierarchy的一部分被嵌入. 有2种方法你可以添加一个fragment到activity layout:  
  
  
**2.1、使用XML将Fragment添加到一个Activity中**  
在这种情况下，你可以像为View一样, 为fragment指定layout属性。

`PS 1、 中的 android:name属性指定了在layout中实例化的Fragment类.当系统创建这个activity layout时,它实例化每一个在layout中指定的fragment,并调用每一个上的onCreateView()方法,来获取每一个 fragment的layout.系统将从fragment返回的 View直接插入到元素所在的地方.2、通过在xml中定义fragment的方式，我们不能在运行时移除fragment。如果我们想要通过切换fragments来跟用户有更好的互动，那么就需要在activity启动的时候定义fragment了。 2.2、在运行时添加一个Fragment到Activity 上面一节的在activity的布局文件（layout xml）中添加Fragment的方法我们已经知道了。现在我们将学习另外一种方式，这种方式允许我们在运行时动态的显示和隐藏fragment。为了达到在activity中动态管理Fragment，我们需要用到FragmentManager，并且通过它创建FragmentTransaction。 activity允许移除或者替换fragment需要有如下条件：1、activity的onCreate()方法中添加初始化的fragment2、fragment放置位置的布局中必须有一个视图容器比如:res/layout/news_articles.xml文件提供了视图容器。`

Activity中使用getSupportFragmentManager()获取FragmentManager，之后调用beginTransaction去创建一个FragmentTransaction对象， 再调用add()方法即可添加一个fragment。 在activity中可以使用同一个FragmentTransaction对象去执行多个fragment事务，当做这样操作时，必须调用commint()方法。 下面的代码演示怎样添加一个fragment到res/layout/news\_articles.xml的layout:

import android.os.Bundle;
    import android.support.v4.app.FragmentActivity;
    
    public class MainActivity extends FragmentActivity {
        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.news_articles);
    
            if (findViewById(R.id.fragment_container) != null) {
    
                if (savedInstanceState != null) {
                    return;
                }
    
                HeadlinesFragment firstFragment = new HeadlinesFragment();
    
                firstFragment.setArguments(getIntent().getExtras());
                
                // Add the fragment to the 'fragment_container' FrameLayout
                getSupportFragmentManager().beginTransaction()
                        .add(R.id.fragment_container, firstFragment).commit();
            }
        }
    }

add()的第一个参数是fragment要放入的ViewGroup, 由resource ID指定,第二个参数是需要添加的fragment.一旦用FragmentTransaction做了改变,为了使改变生效,必须调用commit().

现在再来说明另外一个实例，实例图如下，我要在四个标签页面切换（主页，手机，配件，购物车）

![\\][20140811054117_1.gif]

代码如下，具体就是通过影藏和显示fragment来实现切换

import android.os.Bundle;
    import android.support.v4.app.Fragment;
    import android.support.v4.app.FragmentActivity;
    import android.view.View;
    import android.view.Window;
    
    public class FramentMainActivity extends FragmentActivity {
    
    	private Fragment[] fragments;
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		requestWindowFeature(Window.FEATURE_NO_TITLE);
    		setContentView(R.layout.activity_frament_main);
    
    		fragments = new Fragment[4];
    		fragments[0] = getSupportFragmentManager().findFragmentById(R.id.farment_main);
    		fragments[1] = getSupportFragmentManager().findFragmentById(R.id.farment_phone);
    		fragments[2] = getSupportFragmentManager().findFragmentById(R.id.farment_accessory);
    		fragments[3] = getSupportFragmentManager().findFragmentById(R.id.farment_cart);
    		getSupportFragmentManager().beginTransaction().
    		hide(fragments[1]).hide(fragments[2]).hide(fragments[3]).show(fragments[0]).commit();
    
    	}
    
    	public void mainClick(View view){
    		getSupportFragmentManager().beginTransaction().hide(fragments[1]).hide(fragments[2]).hide(fragments[3]).show(fragments[0]).commit();
    	}
    	public void phoneClick(View view){
    		getSupportFragmentManager().beginTransaction().hide(fragments[0]).hide(fragments[2]).hide(fragments[3]).show(fragments[1]).commit();
    	}
    	public void accessoryClick(View view){
    		getSupportFragmentManager().beginTransaction().hide(fragments[0]).hide(fragments[1]).hide(fragments[3]).show(fragments[2]).commit();
    	}
    	public void cartClick(View view){
    		getSupportFragmentManager().beginTransaction().hide(fragments[0]).hide(fragments[1]).hide(fragments[2]).show(fragments[3]).commit();
    	}
    }

**3、Frament 管理**

要管理 fragment,需使用 FragmentManager,要获取它,需在 activity 中调用方法 getFragmentManager()。 可以用 FragmentManager 来做以上事情:

使用方法 findFragmentById()或 findFragmentByTag(),获取 activity 中已存在的 fragment

使用方法 popBackStack()从 activity 的后退栈中弹出 fragment(这可以模拟后退键引发的动作)

用方法 addOnBackStackChangedListerner()注册一个侦听器以监视后退栈的变化

还可以使用 FragmentManager 打开一个 FragmentTransaction 来执行 fragment 的事务,比如添加或删除 fragment。

在 activity 中使用 fragment 的一个伟大的好处是能跟据用户的输入对 fragment 进行添加、删除、替换以及执行 其它动作的能力。提交的一组 fragment 的变化叫做一个事务。事务通过 FragmentTransaction 来执行。还可以把每个 事务保存在 activity 的后退栈中,这样就可以让用户在 fragment 变化之间导航(跟在 activity 之间导航一样)。

可以通过 FragmentManager 来取得 FragmentTransaction 的实例,如下:

FragmentManagerfragmentManager = getFragmentManager();
    FragmentTransactionfragmentTransaction =fragmentManager.beginTransaction();

一个事务是在同一时刻执行的一组动作(很像数据库中的事务)。可以用 add(),remove(),replace()等方法构成事务,最后使用 commit()方法提交事务。在调用 commint()之前,可以用addToBackStack()把事务添加到一个后退栈中, 这个后退栈属于所在的 activity。有了它,就可以在用户按下返回键时,返回到 fragment 执行事务之前的状态。如 下例:演示了如何用一个 fragment 代替另一个 fragment,同时在后退栈中保存被代替的 fragment 的状态。

4、回退栈管理

######  ######

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

看这样一个效果图：

![20140720144355734][]

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

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

**FragmentTransaction.addToBackStack(String)**

下面讲解代码：很明显一共是3个Fragment和一个Activity.

先看Activity的布局文件：

**\[html\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
2.  xmlns:tools="http://schemas.android.com/tools"
3.  android:layout\_width="match\_parent"
4.  android:layout\_height="match\_parent" >
5.  
6.  <FrameLayout
7.  android:id="@+id/id\_content"
8.  android:layout\_width="fill\_parent"
9.  android:layout\_height="fill\_parent" >
10. </FrameLayout>
11. 
12. </RelativeLayout>

![save_snippets.png][]

不同的Fragment就在这个FrameLayout中显示。

MainActivity.java

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Activity;
4.  import android.app.FragmentManager;
5.  import android.app.FragmentTransaction;
6.  import android.os.Bundle;
7.  import android.view.Window;
8.  
9.  public class MainActivity extends Activity
10. \{
11. 
12. 
13. @Override
14. protected void onCreate(Bundle savedInstanceState)
15. \{
16. super.onCreate(savedInstanceState);
17. requestWindowFeature(Window.FEATURE\_NO\_TITLE);
18. setContentView(R.layout.activity\_main);
19. 
20. FragmentManager fm = getFragmentManager();
21. FragmentTransaction tx = fm.beginTransaction();
22. tx.add(R.id.id\_content, new FragmentOne(),"ONE");
23. tx.commit();
24. \}
25. 
26. \}

![save_snippets.png][]

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

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Fragment;
4.  import android.app.FragmentManager;
5.  import android.app.FragmentTransaction;
6.  import android.os.Bundle;
7.  import android.view.LayoutInflater;
8.  import android.view.View;
9.  import android.view.View.OnClickListener;
10. import android.view.ViewGroup;
11. import android.widget.Button;
12. 
13. public class FragmentOne extends Fragment implements OnClickListener
14. \{
15. 
16. private Button mBtn;
17. 
18. @Override
19. public View onCreateView(LayoutInflater inflater, ViewGroup container,
20. Bundle savedInstanceState)
21. \{
22. View view = inflater.inflate(R.layout.fragment\_one, container, false);
23. mBtn = (Button) view.findViewById(R.id.id\_fragment\_one\_btn);
24. mBtn.setOnClickListener(this);
25. return view;
26. \}
27. 
28. @Override
29. public void onClick(View v)
30. \{
31. FragmentTwo fTwo = new FragmentTwo();
32. FragmentManager fm = getFragmentManager();
33. FragmentTransaction tx = fm.beginTransaction();
34. tx.replace(R.id.id\_content, fTwo, "TWO");
35. tx.addToBackStack(null);
36. tx.commit();
37. 
38. \}
39. 
40. \}

![save_snippets.png][]

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

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Fragment;
4.  import android.app.FragmentManager;
5.  import android.app.FragmentTransaction;
6.  import android.os.Bundle;
7.  import android.view.LayoutInflater;
8.  import android.view.View;
9.  import android.view.View.OnClickListener;
10. import android.view.ViewGroup;
11. import android.widget.Button;
12. 
13. public class FragmentTwo extends Fragment implements OnClickListener
14. \{
15. 
16. private Button mBtn ;
17. @Override
18. public View onCreateView(LayoutInflater inflater, ViewGroup container,
19. Bundle savedInstanceState)
20. \{
21. View view = inflater.inflate(R.layout.fragment\_two, container, false);
22. mBtn = (Button) view.findViewById(R.id.id\_fragment\_two\_btn);
23. mBtn.setOnClickListener(this);
24. return view ;
25. \}
26. @Override
27. public void onClick(View v)
28. \{
29. FragmentThree fThree = new FragmentThree();
30. FragmentManager fm = getFragmentManager();
31. FragmentTransaction tx = fm.beginTransaction();
32. tx.hide(this);
33. tx.add(R.id.id\_content , fThree, "THREE");
34. // tx.replace(R.id.id\_content, fThree, "THREE");
35. tx.addToBackStack(null);
36. tx.commit();
37. \}
38. 
39. 
40. \}

![save_snippets.png][]

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了：

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Fragment;
4.  import android.os.Bundle;
5.  import android.view.LayoutInflater;
6.  import android.view.View;
7.  import android.view.View.OnClickListener;
8.  import android.view.ViewGroup;
9.  import android.widget.Button;
10. import android.widget.Toast;
11. 
12. public class FragmentThree extends Fragment implements OnClickListener
13. \{
14. 
15. private Button mBtn;
16. 
17. @Override
18. public View onCreateView(LayoutInflater inflater, ViewGroup container,
19. Bundle savedInstanceState)
20. \{
21. View view = inflater.inflate(R.layout.fragment\_three, container, false);
22. mBtn = (Button) view.findViewById(R.id.id\_fragment\_three\_btn);
23. mBtn.setOnClickListener(this);
24. return view;
25. \}
26. 
27. @Override
28. public void onClick(View v)
29. \{
30. Toast.makeText(getActivity(), " i am a btn in Fragment three",
31. Toast.LENGTH\_SHORT).show();
32. \}
33. 
34. \}

![save_snippets.png][]

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通信以后，会重构上面的代码！

###### 5、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()。

###### 6、Fragment与Activity通信的最佳实践 ######

因为要考虑Fragment的重复使用，所以必须降低Fragment与Activity的耦合，而且Fragment更不应该直接操作别的Fragment，毕竟Fragment操作应该由它的管理者Activity来决定。

下面我通过两种方式的代码，分别重构，FragmentOne和FragmentTwo的点击事件，以及Activity对点击事件的响应：

首先看FragmentOne

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Fragment;
4.  import android.os.Bundle;
5.  import android.view.LayoutInflater;
6.  import android.view.View;
7.  import android.view.View.OnClickListener;
8.  import android.view.ViewGroup;
9.  import android.widget.Button;
10. 
11. public class FragmentOne extends Fragment implements OnClickListener
12. \{
13. private Button mBtn;
14. 
15. /\*\*
16.  \* 设置按钮点击的回调
17.  \* @author zhy
18.  \*
19.  \*/
20. public interface FOneBtnClickListener
21. \{
22. void onFOneBtnClick();
23. \}
24. 
25. @Override
26. public View onCreateView(LayoutInflater inflater, ViewGroup container,
27. Bundle savedInstanceState)
28. \{
29. View view = inflater.inflate(R.layout.fragment\_one, container, false);
30. mBtn = (Button) view.findViewById(R.id.id\_fragment\_one\_btn);
31. mBtn.setOnClickListener(this);
32. return view;
33. \}
34. 
35. /\*\*
36.  \* 交给宿主Activity处理，如果它希望处理
37.  \*/
38. @Override
39. public void onClick(View v)
40. \{
41. if (getActivity() instanceof FOneBtnClickListener)
42. \{
43. ((FOneBtnClickListener) getActivity()).onFOneBtnClick();
44. \}
45. \}
46. 
47. \}

![save_snippets.png][]

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

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Fragment;
4.  import android.os.Bundle;
5.  import android.view.LayoutInflater;
6.  import android.view.View;
7.  import android.view.View.OnClickListener;
8.  import android.view.ViewGroup;
9.  import android.widget.Button;
10. 
11. public class FragmentTwo extends Fragment implements OnClickListener
12. \{
13. 
14. 
15. private Button mBtn ;
16. 
17. private FTwoBtnClickListener fTwoBtnClickListener ;
18. 
19. public interface FTwoBtnClickListener
20. \{
21. void onFTwoBtnClick();
22. \}
23. //设置回调接口
24. public void setfTwoBtnClickListener(FTwoBtnClickListener fTwoBtnClickListener)
25. \{
26. this.fTwoBtnClickListener = fTwoBtnClickListener;
27. \}
28. @Override
29. public View onCreateView(LayoutInflater inflater, ViewGroup container,
30. Bundle savedInstanceState)
31. \{
32. View view = inflater.inflate(R.layout.fragment\_two, container, false);
33. mBtn = (Button) view.findViewById(R.id.id\_fragment\_two\_btn);
34. mBtn.setOnClickListener(this);
35. return view ;
36. \}
37. @Override
38. public void onClick(View v)
39. \{
40. if(fTwoBtnClickListener != null)
41. \{
42. fTwoBtnClickListener.onFTwoBtnClick();
43. \}
44. \}
45. 
46. \}

![save_snippets.png][]

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 :

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Activity;
4.  import android.app.FragmentManager;
5.  import android.app.FragmentTransaction;
6.  import android.os.Bundle;
7.  import android.view.Window;
8.  
9.  import com.zhy.zhy\_fragments.FragmentOne.FOneBtnClickListener;
10. import com.zhy.zhy\_fragments.FragmentTwo.FTwoBtnClickListener;
11. 
12. public class MainActivity extends Activity implements FOneBtnClickListener,
13. FTwoBtnClickListener
14. \{
15. 
16. private FragmentOne mFOne;
17. private FragmentTwo mFTwo;
18. private FragmentThree mFThree;
19. 
20. @Override
21. protected void onCreate(Bundle savedInstanceState)
22. \{
23. super.onCreate(savedInstanceState);
24. requestWindowFeature(Window.FEATURE\_NO\_TITLE);
25. setContentView(R.layout.activity\_main);
26. 
27. mFOne = new FragmentOne();
28. FragmentManager fm = getFragmentManager();
29. FragmentTransaction tx = fm.beginTransaction();
30. tx.add(R.id.id\_content, mFOne, "ONE");
31. tx.commit();
32. \}
33. 
34. /\*\*
35.  \* FragmentOne 按钮点击时的回调
36.  \*/
37. @Override
38. public void onFOneBtnClick()
39. \{
40. 
41. if (mFTwo == null)
42. \{
43. mFTwo = new FragmentTwo();
44. mFTwo.setfTwoBtnClickListener(this);
45. \}
46. FragmentManager fm = getFragmentManager();
47. FragmentTransaction tx = fm.beginTransaction();
48. tx.replace(R.id.id\_content, mFTwo, "TWO");
49. tx.addToBackStack(null);
50. tx.commit();
51. \}
52. 
53. /\*\*
54.  \* FragmentTwo 按钮点击时的回调
55.  \*/
56. @Override
57. public void onFTwoBtnClick()
58. \{
59. if (mFThree == null)
60. \{
61. mFThree = new FragmentThree();
62. 
63. \}
64. FragmentManager fm = getFragmentManager();
65. FragmentTransaction tx = fm.beginTransaction();
66. tx.hide(mFTwo);
67. tx.add(R.id.id\_content, mFThree, "THREE");
68. // tx.replace(R.id.id\_content, fThree, "THREE");
69. tx.addToBackStack(null);
70. tx.commit();
71. \}
72. 
73. \}

![save_snippets.png][]

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。

###### 7、如何处理运行时配置发生变化 ######

运行时配置发生变化，最常见的就是屏幕发生旋转，如果你不知道如何处理屏幕变化可以参考：[Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案][Android _ _ AsyncTask _ ProgressDialog]

这里提一下：很多人觉得强制设置屏幕的方向就可以了，但是有一点，当你的应用被至于后台（例如用户点击了home），长时间没有返回的时候，你的应用也会被重新启动。比如上例：如果你把上面的例子你至于FragmentThree界面，然后处于后台状态，长时间后你会发现当你再次通过home打开时，上面FragmentThree与FragmentOne叠加在一起，这就是因为你的Activity重新启动，在原来的FragmentThree上又绘制了一个FragmentOne。

好了，下面看一段代码：

Activity:

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Activity;
4.  import android.app.FragmentManager;
5.  import android.app.FragmentTransaction;
6.  import android.os.Bundle;
7.  import android.view.Window;
8.  
9.  public class MainActivity extends Activity
10. 
11. \{
12. private FragmentOne mFOne;
13. 
14. @Override
15. protected void onCreate(Bundle savedInstanceState)
16. \{
17. super.onCreate(savedInstanceState);
18. requestWindowFeature(Window.FEATURE\_NO\_TITLE);
19. setContentView(R.layout.activity\_main);
20. 
21. mFOne = new FragmentOne();
22. FragmentManager fm = getFragmentManager();
23. FragmentTransaction tx = fm.beginTransaction();
24. tx.add(R.id.id\_content, mFOne, "ONE");
25. tx.commit();
26. 
27. \}
28. 
29. \}

![save_snippets.png][]

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

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Fragment;
4.  import android.os.Bundle;
5.  import android.util.Log;
6.  import android.view.LayoutInflater;
7.  import android.view.View;
8.  import android.view.ViewGroup;
9.  
10. public class FragmentOne extends Fragment
11. \{
12. private static final String TAG = "FragmentOne";
13. 
14. @Override
15. public View onCreateView(LayoutInflater inflater, ViewGroup container,
16. Bundle savedInstanceState)
17. \{
18. Log.e(TAG, "onCreateView");
19. View view = inflater.inflate(R.layout.fragment\_one, container, false);
20. return view;
21. \}
22. 
23. @Override
24. public void onCreate(Bundle savedInstanceState)
25. \{
26. // TODO Auto-generated method stub
27. super.onCreate(savedInstanceState);
28. 
29. Log.e(TAG, "onCreate");
30. \}
31. 
32. @Override
33. public void onDestroyView()
34. \{
35. // TODO Auto-generated method stub
36. super.onDestroyView();
37. Log.e(TAG, "onDestroyView");
38. \}
39. 
40. @Override
41. public void onDestroy()
42. \{
43. // TODO Auto-generated method stub
44. super.onDestroy();
45. Log.e(TAG, "onDestroy");
46. \}
47. 
48. \}

![save_snippets.png][]

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会打印出许多套生命周期的回调。

类似：

**\[html\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  07-20 08:18:46.651: E/FragmentOne(1633): onCreate
2.  07-20 08:18:46.651: E/FragmentOne(1633): onCreate
3.  07-20 08:18:46.651: E/FragmentOne(1633): onCreate
4.  07-20 08:18:46.681: E/FragmentOne(1633): onCreateView
5.  07-20 08:18:46.831: E/FragmentOne(1633): onCreateView
6.  07-20 08:18:46.891: E/FragmentOne(1633): onCreateView

![save_snippets.png][]

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的实例：通过打印可以看出：

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  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\}\]\}\]

![save_snippets.png][]

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实例：

**\[java\]** [ view plain][view plain] [ copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  package com.zhy.zhy\_fragments;
2.  
3.  import android.app.Activity;
4.  import android.app.FragmentManager;
5.  import android.app.FragmentTransaction;
6.  import android.os.Bundle;
7.  import android.util.Log;
8.  import android.view.Window;
9.  
10. public class MainActivity extends Activity
11. 
12. \{
13. private static final String TAG = "FragmentOne";
14. private FragmentOne mFOne;
15. 
16. @Override
17. protected void onCreate(Bundle savedInstanceState)
18. \{
19. super.onCreate(savedInstanceState);
20. requestWindowFeature(Window.FEATURE\_NO\_TITLE);
21. setContentView(R.layout.activity\_main);
22. 
23. Log.e(TAG, savedInstanceState+"");
24. 
25. if(savedInstanceState == null)
26. \{
27. mFOne = new FragmentOne();
28. FragmentManager fm = getFragmentManager();
29. FragmentTransaction tx = fm.beginTransaction();
30. tx.add(R.id.id\_content, mFOne, "ONE");
31. tx.commit();
32. \}
33. 
34. 
35. 
36. \}
37. 
38. \}

![save_snippets.png][]

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进行恢复都可以。

由于篇幅原因，就不贴测试代码了。

[20140811054117_0.gif]: http://www.android100.org/uploadfile/2014/0811/20140811054117_0.gif
[20140811054117_1.gif]: http://www.android100.org/uploadfile/2014/0811/20140811054117_1.gif
[20140720144355734]: /images/20220718/66df0bdf07b24a5ab220a3d9d1f2adcc.png
[view plain]: http://blog.csdn.net/lmj623565791/article/details/37992017#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/431546
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/431546/fork
[save_snippets.png]: /images/20220718/80d1bb0c4c3f41b399203e9674da6d96.png
[Android _ _ AsyncTask _ ProgressDialog]: http://blog.csdn.net/lmj623565791/article/details/37936275