Fragment AutoCompleteTextView xml动画（补间属性动画）

灰太狼 2022-07-29 10:41 283阅读 0赞

![category_icon.jpg][]分类：

【Android 源码解析】*（28）*![arrow_triangle_20_down.jpg][]![arrow_triangle_up.jpg][]

[作者同类文章][Link 1] *X*

【android 进阶之路】*（61）*![arrow_triangle_20_down.jpg][]![arrow_triangle_up.jpg][]

[作者同类文章][Link 2] *X*

目录[(?)][Link 3][\[+\]][Link 3]

1.  [Fragment的产生与介绍][Fragment]
2.  [Fragment的生命周期][Fragment 1]
3.  [静态的使用Fragment][Fragment 2]
4.  [动态的使用Fragment][Fragment 3]
5.  [Fragment家族常用的API][Fragment_API]

转载请标明出处：[http://blog.csdn.net/lmj623565791/article/details/37970961][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的生命周期。官网这张图很好的说明了两者生命周期的关系：

![SouthEast][]

可以看到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的布局文件:

**\[html\]** [ view plain][Link 3] [ copy][Link 3] [ print][Link 3] [?][Link 3]

1.  <?xml  version="1.0"  encoding="utf-8"?>
2.  <RelativeLayout  xmlns:android="http://schemas.android.com/apk/res/android"
3.  android:layout\_width="match\_parent"
4.  android:layout\_height="45dp"
5.  android:background="@drawable/title\_bar">
6.    
    
7.  <ImageButton
8.  android:id="@+id/id\_title\_left\_btn"
9.  android:layout\_width="wrap\_content"
10. android:layout\_height="wrap\_content"
11. android:layout\_centerVertical="true"
12. android:layout\_marginLeft="3dp"
13. android:background="@drawable/showleft\_selector"/>
14.   
    
15. <TextView
16. android:layout\_width="fill\_parent"
17. android:layout\_height="fill\_parent"
18. android:gravity="center"
19. android:text="我不是微信"
20. android:textColor="\#fff"
21. android:textSize="20sp"
22. android:textStyle="bold"/>
23.   
    
24. </RelativeLayout>

<?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

**\[java\]** [ view plain][Link 3] [ copy][Link 3] [ print][Link 3] [?][Link 3]

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.ImageButton;
10. import android.widget.Toast;
11.   
    
12. public class TitleFragmentextends Fragment
13. \{
14.   
    
15. private ImageButton mLeftMenu;
16.   
    
17. @Override
18. public View onCreateView(LayoutInflater inflater, ViewGroup container,
19. Bundle savedInstanceState)
20. \{
21. View view = inflater.inflate(R.layout.fragment\_title, container,  false);
22. mLeftMenu = (ImageButton) view.findViewById(R.id.id\_title\_left\_btn);
23. mLeftMenu.setOnClickListener(new OnClickListener()
24. \{
25. @Override
26. public void onClick(View v)
27. \{
28. Toast.makeText(getActivity(),
29. "i am an ImageButton in TitleFragment ! ",
30. Toast.LENGTH\_SHORT).show();
31. \}
32. \});
33. return view;
34. \}
35. \}

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

**\[html\]** [ view plain][Link 3] [ copy][Link 3] [ print][Link 3] [?][Link 3]

1.  <?xml  version="1.0"  encoding="utf-8"?>
2.  <LinearLayout  xmlns:android="http://schemas.android.com/apk/res/android"
3.  android:layout\_width="match\_parent"
4.  android:layout\_height="match\_parent"
5.  android:orientation="vertical">
6.    
    
7.  <TextView
8.  android:layout\_width="fill\_parent"
9.  android:layout\_height="fill\_parent"
10. android:gravity="center"
11. android:text="使用Fragment做主面板"
12. android:textSize="20sp"
13. android:textStyle="bold"/>
14.   
    
15. </LinearLayout>

<?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>

**\[java\]** [ view plain][Link 3] [ copy][Link 3] [ print][Link 3] [?][Link 3]

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.ViewGroup;
8.    
    
9.  public class ContentFragmentextends Fragment
10. \{
11.   
    
12. @Override
13. public View onCreateView(LayoutInflater inflater, ViewGroup container,
14. Bundle savedInstanceState)
15. \{
16. return inflater.inflate(R.layout.fragment\_content, container,false);
17. \}
18.   
    
19. \}

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

**\[java\]** [ view plain][Link 3] [ copy][Link 3] [ print][Link 3] [?][Link 3]

1.  package com.zhy.zhy\_fragments;
2.    
    
3.  import android.app.Activity;
4.  import android.os.Bundle;
5.  import android.view.Window;
6.    
    
7.  public class MainActivityextends Activity
8.  \{
9.    
    
10. @Override
11. protected void onCreate(Bundle savedInstanceState)
12. \{
13. super.onCreate(savedInstanceState);
14. requestWindowFeature(Window.FEATURE\_NO\_TITLE);
15. setContentView(R.layout.activity\_main);
16. \}
17.   
    
18. \}

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

**\[java\]** [ view plain][Link 3] [ copy][Link 3] [ print][Link 3] [?][Link 3]

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.  <fragment
7.  android:id="@+id/id\_fragment\_title"
8.  android:name="com.zhy.zhy\_fragments.TitleFragment"
9.  android:layout\_width="fill\_parent"
10. android:layout\_height="45dp" />
11.   
    
12. <fragment
13. android:layout\_below="@id/id\_fragment\_title"
14. android:id="@+id/id\_fragment\_content"
15. android:name="com.zhy.zhy\_fragments.ContentFragment"
16. android:layout\_width="fill\_parent"
17. android:layout\_height="fill\_parent" />
18.   
    
19. </RelativeLayout>

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

![20140719230904593][]

###### 4、动态的使用Fragment ######

上面已经演示了，最简单的使用Fragment的方式~下面介绍如何动态的添加、更新、以及删除Fragment

为了动态使用Fragment，我们修改一下Actvity的布局文件，中间使用一个FrameLayout，下面添加四个按钮~~~嘿嘿~~不是微信的按钮- -！

**\[html\]** [ view plain][Link 3] [ copy][Link 3] [ print][Link 3] [?][Link 3]

1.  <RelativeLayoutxmlns: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.  <fragment
7.  android:id="@+id/id\_fragment\_title"
8.  android:name="com.zhy.zhy\_fragments.TitleFragment"
9.  android:layout\_width="fill\_parent"
10. android:layout\_height="45dp"/>
11.   
    
12. <include
13. android:id="@+id/id\_ly\_bottombar"
14. android:layout\_width="fill\_parent"
15. android:layout\_height="55dp"
16. android:layout\_alignParentBottom="true"
17. layout="@layout/bottombar"/>
18.   
    
19. <FrameLayout
20. android:id="@+id/id\_content"
21. android:layout\_width="fill\_parent"
22. android:layout\_height="fill\_parent"
23. android:layout\_above="@id/id\_ly\_bottombar"
24. android:layout\_below="@id/id\_fragment\_title"/>
25.   
    
26. </RelativeLayout>

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

下面主Activity

**\[java\]** [ view plain][Link 3] [ copy][Link 3] [ print][Link 3] [?][Link 3]

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.View;
8.  import android.view.View.OnClickListener;
9.  import android.view.Window;
10. import android.widget.LinearLayout;
11.   
    
12. public class MainActivityextends Activityimplements OnClickListener
13. \{
14. private LinearLayout mTabWeixin;
15. private LinearLayout mTabFriend;
16.   
    
17. private ContentFragment mWeixin;
18. private FriendFragment mFriend;
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. // 初始化控件和声明事件
28. mTabWeixin = (LinearLayout) findViewById(R.id.tab\_bottom\_weixin);
29. mTabFriend = (LinearLayout) findViewById(R.id.tab\_bottom\_friend);
30. mTabWeixin.setOnClickListener(this);
31. mTabFriend.setOnClickListener(this);
32.   
    
33. // 设置默认的Fragment
34. setDefaultFragment();
35. \}
36.   
    
37. private void setDefaultFragment()
38. \{
39. FragmentManager fm = getFragmentManager();
40. FragmentTransaction transaction = fm.beginTransaction();
41. mWeixin = new ContentFragment();
42. transaction.replace(R.id.id\_content, mWeixin);
43. transaction.commit();
44. \}
45.   
    
46. @Override
47. public void onClick(View v)
48. \{
49. FragmentManager fm = getFragmentManager();
50. // 开启Fragment事务
51. FragmentTransaction transaction = fm.beginTransaction();
52.   
    
53. switch (v.getId())
54. \{
55. case R.id.tab\_bottom\_weixin:
56. if (mWeixin == null)
57. \{
58. mWeixin = new ContentFragment();
59. \}
60. // 使用当前Fragment的布局替代id\_content的控件
61. transaction.replace(R.id.id\_content, mWeixin);
62. break;
63. case R.id.tab\_bottom\_friend:
64. if (mFriend == null)
65. \{
66. mFriend = new FriendFragment();
67. \}
68. transaction.replace(R.id.id\_content, mFriend);
69. break;
70. \}
71. // transaction.addToBackStack();
72. // 事务提交
73. transaction.commit();
74. \}
75.   
    
76. \}

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其实类似：

**\[java\]** [ view plain][Link 3] [ copy][Link 3] [ print][Link 3] [?][Link 3]

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.ViewGroup;
8.    
    
9.  public class FriendFragmentextends Fragment
10. \{
11.   
    
12. @Override
13. public View onCreateView(LayoutInflater inflater, ViewGroup container,
14. Bundle savedInstanceState)
15. \{
16. return inflater.inflate(R.layout.fragment\_friend, container,false);
17. \}
18.   
    
19. \}

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

效果图：

![20140720002532641][]

可以看到很好的实现了效果，其实这个效果以前的博客中也出现过，在博客：[Android项目Tab类型主界面大总结 Fragment+TabPageIndicator+ViewPager][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集成等~~

转载请标明出处：[http://blog.csdn.net/lmj623565791/article/details/37992017][http_blog.csdn.net_lmj623565791_article_details_37992017]

上篇博客中已经介绍了Fragment产生原因，以及一些基本的用法和各种API，如果你还不了解，请看：[Android Fragment 真正的完全解析（上）][http_blog.csdn.net_lmj623565791_article_details_37970961]。

本篇将介绍上篇博客提到的：如何管理Fragment回退栈，Fragment如何与Activity交互，Fragment与Activity交互的最佳实践，没有视图的Fragment的用处，使用Fragment创建对话框，如何与ActionBar，MenuItem集成等~~

###### 1、管理Fragment回退栈 ######

类似与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]

不同的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 MainActivityextends 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. \}

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

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 FragmentOneextends Fragmentimplements 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. \}

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

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 FragmentTwoextends Fragmentimplements 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. \}

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

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 FragmentThreeextends Fragmentimplements 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. \}

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

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 FragmentOneextends Fragmentimplements 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. \}

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

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 FragmentTwoextends Fragmentimplements 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. \}

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 :

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 MainActivityextends Activityimplements 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. \}

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 的最佳方案][Android _ _ AsyncTask _ ProgressDialog]

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

好了，下面看一段代码：

Activity:

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 MainActivityextends 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. \}

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

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 FragmentOneextends 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. \}

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

类似：

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

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

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

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

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 MainActivityextends Activity
11.   
    
12. \{
13. private staticfinal 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. \}

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

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.Menu;
7.  import android.view.MenuInflater;
8.  import android.view.MenuItem;
9.  import android.view.View;
10. import android.view.ViewGroup;
11. import android.widget.Toast;
12.   
    
13. public class FragmentOneextends Fragment
14. \{
15.   
    
16. @Override
17. public void onCreate(Bundle savedInstanceState)
18. \{
19. super.onCreate(savedInstanceState);
20. setHasOptionsMenu(true);
21. \}
22.   
    
23. @Override
24. public View onCreateView(LayoutInflater inflater, ViewGroup container,
25. Bundle savedInstanceState)
26. \{
27. View view = inflater.inflate(R.layout.fragment\_one, container,  false);
28. return view;
29. \}
30.   
    
31. @Override
32. public void onCreateOptionsMenu(Menu menu, MenuInflater inflater)
33. \{
34. inflater.inflate(R.menu.fragment\_menu, menu);
35. \}
36.   
    
37. @Override
38. public boolean onOptionsItemSelected(MenuItem item)
39. \{
40. switch (item.getItemId())
41. \{
42. case R.id.id\_menu\_fra\_test:
43. Toast.makeText(getActivity(), "FragmentMenuItem1", Toast.LENGTH\_SHORT).show();
44. break;
45. \}
46. return true;
47. \}
48.   
    
49. \}

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

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.Menu;
9.  import android.view.MenuItem;
10. import android.view.Window;
11. import android.widget.Toast;
12.   
    
13. public class MainActivityextends Activity
14.   
    
15. \{
16. private static  final String TAG = "FragmentOne";
17. private FragmentOne mFOne;
18.   
    
19. @Override
20. protected void onCreate(Bundle savedInstanceState)
21. \{
22. super.onCreate(savedInstanceState);
23. requestWindowFeature(Window.FEATURE\_NO\_TITLE);
24. setContentView(R.layout.activity\_main);
25.   
    
26. Log.e(TAG, savedInstanceState + "");
27.   
    
28. if (savedInstanceState ==  null)
29. \{
30. mFOne = new FragmentOne();
31. FragmentManager fm = getFragmentManager();
32. FragmentTransaction tx = fm.beginTransaction();
33. tx.add(R.id.id\_content, mFOne, "ONE");
34. tx.commit();
35. \}
36.   
    
37. \}
38.   
    
39. @Override
40. public boolean onCreateOptionsMenu(Menu menu)
41. \{
42. super.onCreateOptionsMenu(menu);
43. getMenuInflater().inflate(R.menu.main, menu);
44. return true;
45. \}
46.   
    
47. @Override
48. public boolean onOptionsItemSelected(MenuItem item)
49. \{
50. switch (item.getItemId())
51. \{
52. case R.id.action\_settings:
53. Toast.makeText(this,  "setting", Toast.LENGTH\_SHORT).show();
54. return true;
55. default:
56. //如果希望Fragment自己处理MenuItem点击事件，一定不要忘了调用super.xxx
57. return super.onOptionsItemSelected(item);
58. \}
59. \}
60.   
    
61. \}

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

效果图：

![20140720164313421][]

好了，可以很好的看到，Fragment可以添加MenuItem，也可以自己处理点击~~~

###### 6、没有布局的Fragment的作用 ######

没有布局文件Fragment实际上是为了保存，当Activity重启时，保存大量数据准备的

请参考博客：[Android 屏幕旋转 处理 AsyncTask 和 ProgressDialog 的最佳方案][Android _ _ AsyncTask _ ProgressDialog]

###### 7、使用Fragment创建对话框 ######

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

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

有任何问题，欢迎留言~~~

两篇结束，相信你对Fragment已经有了一定的了解，那么在项目中的最佳实践是什么呢？请移步：[Android Fragment 你应该知道的一切][Android Fragment]

如果想获得建议，当在一个可编辑的文本字段中键入，可以通过AutoCompleteTextView做到这一点。当用户输入它会自动提供建议。建议列表显示在下拉菜单，从中用户可以选择一个项目，以取代与编辑框的内容。

为了使用AutoCompleteTextView 需要首先在XML中创建一个AutoCompletTextView字段。其语法如下给出。

在此之后，必须在java中得到这个TextView，参考语法如下给出：

private AutoCompleteTextView actv;
    actv = (AutoCompleteTextView) findViewById(R.id.autoCompleteTextView1);

需要做的下一件事就是指定要显示的建议项目列表。可以指定列表项为ava字符串数组或在strings.xml中。其语法如下给出。

String[] countries = getResources().
       getStringArray(R.array.list_of_countries);
       ArrayAdapter adapter = new ArrayAdapter
       (this,android.R.layout.simple_list_item_1,countries);
       actv.setAdapter(adapter);

数组适配器类负责显示数据列表中的文本字段的视图。setAdapter方法用于设置autoCompleteTextView的适配器。除了这些方法，自动完成的其它方法在下面列出。

<table style="margin:8px 0px; padding:0px; border-color:rgb(214,214,214); width:560px; border-collapse:collapse; vertical-align:top; color:rgb(0,0,0); background-color:rgb(247,247,247)"> 
 <tbody style="margin:0px; padding:0px"> 
  <tr style="margin:0px; padding:0px"> 
   <th style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214); background-color:rgb(238,238,238)"> Sr.No</th> 
   <th style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214); background-color:rgb(238,238,238)"> 方法及说明</th> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 1</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> <strong style="margin:0px; padding:0px">getAdapter()</strong><br style="margin:0px; padding:0px"> 这个方法返回用于自动完成筛选列表适配器</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 2</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> <strong style="margin:0px; padding:0px">getCompletionHint()</strong><br style="margin:0px; padding:0px"> 此方法返回在匹配列表的底部显示可选的提示文本</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 3</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> <strong style="margin:0px; padding:0px">getDropDownAnchor()</strong><br style="margin:0px; padding:0px"> 此方法返回返回ID视图自动完成下拉列表固定</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 4</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> <strong style="margin:0px; padding:0px">getListSelection()</strong><br style="margin:0px; padding:0px"> 此方法返回下拉视图选择的位置（如果有一个）</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 5</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> <strong style="margin:0px; padding:0px">isPopupShowing()</strong><br style="margin:0px; padding:0px"> 此方法指示弹出式菜单是否显示</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 6</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> <strong style="margin:0px; padding:0px">setText(CharSequence text, boolean filter)</strong><br style="margin:0px; padding:0px"> 此方法设置的文本，但它可以禁用过滤</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 7</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> <strong style="margin:0px; padding:0px">showDropDown()</strong><br style="margin:0px; padding:0px"> 此方法显示在下拉屏幕上</td> 
  </tr> 
 </tbody> 
</table>

## 例子 ##

下面的例子演示了如何使用AutoCompleteTextView类。创建了一个基本的应用程序，在输入并在设备上会显示建议。

为了试验这个例子，需要在实际设备或模拟器运行此程序。

<table style="margin:8px 0px; padding:0px; border-color:rgb(214,214,214); width:560px; border-collapse:collapse; vertical-align:top; color:rgb(0,0,0); background-color:rgb(247,247,247)"> 
 <tbody style="margin:0px; padding:0px"> 
  <tr style="margin:0px; padding:0px"> 
   <th style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214); background-color:rgb(238,238,238)"> 步骤</th> 
   <th style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214); background-color:rgb(238,238,238)"> 描述</th> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 1</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 使用Android Studio创建Android应用程序，并将其命名为AutoComplete，创建这个项目确保目标SDK编译在Android SDK的最新版本以及使用更高级别的API。</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 2</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 修改&nbsp;src/MainActivity.java文件添加AutoCompleteTextView代码</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 3</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 修改所需的布局XML文件res/layout/activity_main.xml&nbsp;添加GUI组件</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 4</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 修改 res/values/string.xml&nbsp;文件，并添加必要的字符串组件</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 5</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 修改 AndroidManifest.xml 以添加必要的权限</td> 
  </tr> 
  <tr style="margin:0px; padding:0px"> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 6</td> 
   <td style="margin:0px; padding:5px; border-collapse:collapse; border-color:rgb(214,214,214)"> 运行应用程序并选择运行Android的设备，并在其上安装的应用并验证结果</td> 
  </tr> 
 </tbody> 
</table>

下面是文件 **src/com.yiibai.autocomplete/MainActivity.java**的内容：

package com.yiibai.autocomplete;
    
    import android.os.Bundle;
    import android.app.Activity;
    import android.view.Menu;
    import android.widget.ArrayAdapter;
    import android.widget.AutoCompleteTextView;
    import android.widget.MultiAutoCompleteTextView;
    
    public class MainActivity extends Activity {
    
       private AutoCompleteTextView actv;
       private MultiAutoCompleteTextView mactv;
    
       @Override
       protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
    
    
           String[] countries = getResources().
           getStringArray(R.array.list_of_countries);
            ArrayAdapter adapter = new ArrayAdapter
           (this,android.R.layout.simple_list_item_1,countries);
    
    
           actv = (AutoCompleteTextView) findViewById(R.id.autoCompleteTextView1);
           mactv = (MultiAutoCompleteTextView) findViewById
           (R.id.multiAutoCompleteTextView1);
    
           actv.setAdapter(adapter);
           mactv.setAdapter(adapter);
    
           mactv.setTokenizer(new MultiAutoCompleteTextView.CommaTokenizer());
    
    
       }
    
       @Override
       public boolean onCreateOptionsMenu(Menu menu) {
          // Inflate the menu; this adds items to the action bar if it is present.
          getMenuInflater().inflate(R.menu.main, menu);
          return true;
       }
    
    }

下面是文件 **activity\_main.xml **的内容

下面是文件 **Strings.xml **的内容

<?xml version="1.0" encoding="utf-8"?>
    <resources>
    
       <string name="app_name">AutoComplete</string>
       <string name="action_settings">Settings</string>
       <string name="hello_world">Hello world!</string>
       <string name="auto_complete">AutoComplete</string>
       <string name="multi_auto_complete">Multi AutoComplete</string>
       <string-array name="list_of_countries">
          <item >USA</item>
          <item >Uk</item>
          <item >Canada</item>
          <item >Australia</item>
          <item >France</item>
          <item >Italy</item>
          <item >China</item>
          <item >Japan</item>
          <item >Spain</item>
          </string-array>
    
    </resources>

下面是文件 **AndroidManifest.xml** 的内容

<?xml version="1.0" encoding="utf-8"?>
    <manifest xmlns:android="http://schemas.android.com/apk/res/android"
       package="com.yiibai.autocomplete"
       android:versionCode="1"
       android:versionName="1.0" >
    
       <uses-sdk
          android:minSdkVersion="8"
          android:targetSdkVersion="17" />
    
       <application
          android:allowBackup="true"
          android:icon="@drawable/ic_launcher"
          android:label="@string/app_name"
          android:theme="@style/AppTheme" >
          <activity
             android:name="com.yiibai.autocomplete.MainActivity"
             android:label="@string/app_name" >
             <intent-filter>
                <action android:name="android.intent.action.MAIN" />
    
                <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
          </activity>
       </application>
    
    </manifest>

让我们试着运行Androidmanager应用程序。将安装该应用程序在AVD，AVD将显示如下画面。

![Anroid Capture Tutorial][]

现在只是在文本视图以查看国家的建议。正如输入两个两个字母这是**ca**，它显示的建议是：canada

![Anroid Capture Tutorial][Anroid Capture Tutorial 1]

multiAutoCompleteTextView演示建议不仅是一个单词，同样也可以对于整个文本。由于写第一个字母，当开始写入第二个字后，它会显示建议。这可以示出在下面的图片。

![Anroid Capture Tutorial][Anroid Capture Tutorial 2]

以上代码下载： [http://pan.baidu.com/s/1o6G8Lq6][http_pan.baidu.com_s_1o6G8Lq6]

[效果: http://www.56.com/u82/v\_OTM4MDk5MTk.html][http_www.56.com_u82_v_OTM4MDk5MTk.html]  
**第一步: 创建anim文件夹放置动画xml文件**  
在res文件夹下，创建一个anim的子文件夹。

![201307110843082.jpg][]  
  
**第二步: 加载动画**  
接着在Activity创建一个Animation类，然后使用AnimationUtils类加载动画xml

复制代码 代码如下:

Animation animFadein;  
  
@Override  
protected void onCreate(Bundle savedInstanceState) \{  
super.onCreate(savedInstanceState);  
setContentView(R.layout.activity\_fadein);  
  
txtMessage = (TextView) findViewById(R.id.txtMessage);  
btnStart = (Button) findViewById(R.id.btnStart);  
  
// 加载动画  
animFadein = AnimationUtils.loadAnimation(getApplicationContext(),  
R.anim.fade\_in);  
  
｝

**第三步: 设置动画监听器**  
如果你要监听动画的事件，如开始，结束等，你需要实现AnimationListener监听器，重写以下方法。  
onAnimationEnd(Animation animation) - 当动画结束时调用  
onAnimationRepeat(Animation animation) - 当动画重复时调用  
onAniamtionStart(Animation animation) - 当动画启动时调用

复制代码 代码如下:

@Override  
public void onAnimationEnd(Animation animation) \{  
// 在动画结束后使用  
  
// check for fade in animation  
if (animation == animFadein) \{  
Toast.makeText(getApplicationContext(), "Animation Stopped",  
Toast.LENGTH\_SHORT).show();  
\}  
  
\}  
  
@Override  
public void onAnimationRepeat(Animation animation) \{  
//当动画重复时使用  
  
\}  
  
@Override  
public void onAnimationStart(Animation animation) \{  
//当动画开始使用  
  
\}

最后一步: 让动画动起来啦。可以使用任何UI元素调用startAnimation方法。  
以下是一个Textview元素调用的。  
txtMessage.startAnimation(animFadein);  
 **完整代码:**

复制代码 代码如下:

FadeInActivity(淡入动画)  
?package com.chaowen.androidanimations;  
  
import info.androidhive.androidanimations.R;  
import android.app.Activity;  
import android.os.Bundle;  
import android.view.View;  
import android.view.animation.Animation;  
import android.view.animation.AnimationUtils;  
import android.view.animation.Animation.AnimationListener;  
import android.widget.Button;  
import android.widget.TextView;  
import android.widget.Toast;  
  
/\*\*  
 \*   
 \* @author chaowen  
 \*  
 \*/  
public class FadeInActivity extends Activity implements AnimationListener \{  
  
    TextView txtMessage;  
    Button btnStart;  
  
    Animation animFadein;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) \{  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity\_fadein);  
  
        txtMessage = (TextView) findViewById(R.id.txtMessage);  
        btnStart = (Button) findViewById(R.id.btnStart);  
  
        // 加载动画  
        animFadein = AnimationUtils.loadAnimation(getApplicationContext(),  
                R.anim.fade\_in);  
  
        // 设置监听  
        animFadein.setAnimationListener(this);  
  
        // 按钮  
        btnStart.setOnClickListener(new View.OnClickListener() \{  
  
            @Override  
            public void onClick(View v) \{  
                txtMessage.setVisibility(View.VISIBLE);  
  
                // 开始动画  
                txtMessage.startAnimation(animFadein);  
            \}  
        \});  
  
    \}  
  
    @Override  
    public void onAnimationEnd(Animation animation) \{  
        // 在动画结束后使用  
  
        // check for fade in animation  
        if (animation == animFadein) \{  
            Toast.makeText(getApplicationContext(), "Animation Stopped",  
                    Toast.LENGTH\_SHORT).show();  
        \}  
  
    \}  
  
    @Override  
    public void onAnimationRepeat(Animation animation) \{  
        //当动画重复时使用  
  
    \}  
  
    @Override  
    public void onAnimationStart(Animation animation) \{  
        //当动画开始使用  
  
    \}  
  
\}

**一些重要的XML属性**  
重要的XML动画属性  
android:duration 动画持续时间,时间以毫秒为单位  
android:startOffset 动画之间的时间间隔，从上次动画停多少时间开始执行下个动画  
android:interpolator 指定一个动画的插入器  
android:fillAfter 当设置为true ，该动画转化在动画结束后被应用  
android:repeatMode 定义重复的行为  
android:repeatCount 动画的重复次数  
 **   
以下是一些基本的动画XML.**  
Fade In:  淡入  
alpha是渐变透明度效果，值由0到1  
**fade\_in.xml **

复制代码 代码如下:

<?xml version="1.0" encoding="utf-8"?>  
<set xmlns:android="http://schemas.android.com/apk/res/android"  
    android:fillAfter="true" >  
  
    <alpha  
        android:duration="1000"  
        android:fromAlpha="0.0"  
        android:interpolator="@android:anim/accelerate\_interpolator"  
        android:toAlpha="1.0" />  
  
</set>

Fade Out ： 淡出  
 以Fade In刚好相反，值由1到0.  
**fade\_out.xml**

复制代码 代码如下:

<?xml version="1.0" encoding="utf-8"?>  
<set xmlns:android="http://schemas.android.com/apk/res/android"  
    android:fillAfter="true" >  
  
    <alpha  
        android:duration="1000"  
        android:fromAlpha="1.0"  
        android:interpolator="@android:anim/accelerate\_interpolator"  
        android:toAlpha="0.0" />  
  
</set>

Cross Fading:  交叉的淡入和淡出  
 同时使用Fade in和Fade out可以达到交叉的效果

复制代码 代码如下:

public class CrossfadeActivity extends Activity implements AnimationListener \{  
  
    TextView txtMessage1, txtMessage2;  
    Button btnStart;  
  
       
    Animation animFadeIn, animFadeOut;  
  
    @Override  
    protected void onCreate(Bundle savedInstanceState) \{  
        // TODO Auto-generated method stub  
        super.onCreate(savedInstanceState);  
        setContentView(R.layout.activity\_crossfade);  
  
        txtMessage1 = (TextView) findViewById(R.id.txtMessage1);  
        txtMessage2 = (TextView) findViewById(R.id.txtMessage2);  
        btnStart = (Button) findViewById(R.id.btnStart);  
  
        // load animations  
        animFadeIn = AnimationUtils.loadAnimation(getApplicationContext(),  
                R.anim.fade\_in);  
        animFadeOut = AnimationUtils.loadAnimation(getApplicationContext(),  
                R.anim.fade\_out);  
  
        // set animation listeners  
        animFadeIn.setAnimationListener(this);  
        animFadeOut.setAnimationListener(this);  
  
        // button click event  
        btnStart.setOnClickListener(new View.OnClickListener() \{  
  
            @Override  
            public void onClick(View v) \{  
  
                txtMessage2.setVisibility(View.VISIBLE);  
  
                txtMessage2.startAnimation(animFadeIn);  
  
                   
                txtMessage1.startAnimation(animFadeOut);  
            \}  
        \});  
  
    \}  
  
    @Override  
    public void onAnimationEnd(Animation animation) \{  
  
   
  
        if (animation == animFadeOut) \{  
            txtMessage1.setVisibility(View.GONE);  
        \}  
  
        if(animation == animFadeIn)\{  
            txtMessage2.setVisibility(View.VISIBLE);  
        \}  
  
    \}  
  
    @Override  
    public void onAnimationRepeat(Animation animation) \{  
        // TODO Auto-generated method stub  
  
    \}  
  
    @Override  
    public void onAnimationStart(Animation animation) \{  
        // TODO Auto-generated method stub  
  
    \}  
  
\}

BLink:  若隐若现，酷  
**blink.xml**

复制代码 代码如下:

<?xml version="1.0" encoding="utf-8"?>  
<set xmlns:android="http://schemas.android.com/apk/res/android">  
    <alpha android:fromAlpha="0.0"  
        android:toAlpha="1.0"  
        android:interpolator="@android:anim/accelerate\_interpolator"  
        android:duration="600"  
        android:repeatMode="reverse"  
        android:repeatCount="infinite"/>  
</set>

Zoom In : 放大  
**zoom\_in.xml **

复制代码 代码如下:

<?xml version="1.0" encoding="utf-8"?>  
<set xmlns:android="http://schemas.android.com/apk/res/android"  
    android:fillAfter="true" >  
  
    <scale  
        xmlns:android="http://schemas.android.com/apk/res/android"  
        android:duration="1000"  
        android:fromXScale="1"  
        android:fromYScale="1"  
        android:pivotX="50%"  
        android:pivotY="50%"  
        android:toXScale="3"  
        android:toYScale="3" >  
    </scale>  
  
</set>

Zoom Out: 缩小  
**zoom\_out.xml**

复制代码 代码如下:

<?xml version="1.0" encoding="utf-8"?>  
<set xmlns:android="http://schemas.android.com/apk/res/android"  
    android:fillAfter="true" >  
  
    <scale  
        xmlns:android="http://schemas.android.com/apk/res/android"  
        android:duration="1000"  
        android:fromXScale="1.0"  
        android:fromYScale="1.0"  
        android:pivotX="50%"  
        android:pivotY="50%"  
        android:toXScale="0.5"  
        android:toYScale="0.5" >  
    </scale>  
  
</set>

Rotate: 旋转  
**rotate.xml**

复制代码 代码如下:

<?xml version="1.0" encoding="utf-8"?>  
<set xmlns:android="http://schemas.android.com/apk/res/android">  
    <rotate android:fromDegrees="0"  
        android:toDegrees="360"  
        android:pivotX="50%"  
        android:pivotY="50%"  
        android:duration="600"  
        android:repeatMode="restart"  
        android:repeatCount="infinite"  
        android:interpolator="@android:anim/cycle\_interpolator"/>  
  
</set>

还有几个就不再列出，有兴趣下源码看。 **[点击下载  
][Link 4]**

#### 您可能感兴趣的文章: ####

*  [用Android MenuInflater创建菜单项的方法步骤][Android MenuInflater]
 *  [解析Android开发优化之:对界面UI的优化详解(一)][Android_UI]
 *  [解析Android开发优化之:对界面UI的优化详解(二)][Android_UI 1]
 *  [Android 在其他线程中更新UI线程的解决方法][Android _UI]
 *  [android UI进阶之android中隐藏的layout 抽屉的使用方法][android UI_android_layout]
 *  [android使用多线程更新ui示例分享][android_ui]
 *  [android使用handler ui线程和子线程通讯更新ui示例][android_handler ui_ui]
 *  [android 使用uinput模拟输入设备的方法][android _uinput]
 *  [android开发教程之handler异步更新ui][android_handler_ui]
 *  [Android UI效果之绘图篇（一）][Android UI]

[category_icon.jpg]: /images/20220728/c7ba52029c964cb189ec64bac74ac123.png
[arrow_triangle_20_down.jpg]: http://static.blog.csdn.net/images/arrow_triangle%20_down.jpg
[arrow_triangle_up.jpg]: /images/20220728/270404d27e1e48c9b74a32a99437c2c3.png
[Link 1]: http://blog.csdn.net/lmj623565791/article/category/2680605
[Link 2]: http://blog.csdn.net/lmj623565791/article/category/2210589
[Link 3]: http://blog.csdn.net/lmj623565791/article/details/37970961#
[Fragment]: http://blog.csdn.net/lmj623565791/article/details/37970961#t0
[Fragment 1]: http://blog.csdn.net/lmj623565791/article/details/37970961#t1
[Fragment 2]: http://blog.csdn.net/lmj623565791/article/details/37970961#t2
[Fragment 3]: http://blog.csdn.net/lmj623565791/article/details/37970961#t3
[Fragment_API]: http://blog.csdn.net/lmj623565791/article/details/37970961#t4
[http_blog.csdn.net_lmj623565791_article_details_37970961]: http://blog.csdn.net/lmj623565791/article/details/37970961
[SouthEast]: /images/20220728/97a579b71505484e9693933316fb1d18.png
[20140719230904593]: /images/20220728/376fedb079bf45909f8ad166c0f116e6.png
[20140720002532641]: /images/20220728/b33ac50294dc44468d9d43944a1104a8.png
[Android_Tab_ Fragment_TabPageIndicator_ViewPager]: http://blog.csdn.net/lmj623565791/article/details/24740977
[http_blog.csdn.net_lmj623565791_article_details_37992017]: http://blog.csdn.net/lmj623565791/article/details/37992017
[20140720144355734]: /images/20220728/b8499fdf3cbc4dbfb1b90d580a6b211a.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
[Android _ _ AsyncTask _ ProgressDialog]: http://blog.csdn.net/lmj623565791/article/details/37936275
[20140720164313421]: /images/20220728/e555e9466a2649158dddded91b634e7b.png
[Android _ _ DialogFragment]: http://blog.csdn.net/lmj623565791/article/details/37815413
[Android Fragment]: http://blog.csdn.net/lmj623565791/article/details/42628537
[Anroid Capture Tutorial]: /images/20220728/4350fe7ae643483bbc3f5729bdf17d60.png
[Anroid Capture Tutorial 1]: /images/20220728/839e23dbe4504e1398a469b6a3e0b71d.png
[Anroid Capture Tutorial 2]: /images/20220728/a3e389db4d3943fc89e54f4368083718.png
[http_pan.baidu.com_s_1o6G8Lq6]: http://pan.baidu.com/s/1o6G8Lq6
[http_www.56.com_u82_v_OTM4MDk5MTk.html]: http://www.56.com/u82/v_OTM4MDk5MTk.html
[201307110843082.jpg]: /images/20220728/3703ba0f37a34303899b1c70125a139d.png
[Link 4]: http://xiazai.jb51.net/201307/yuanma/Android20130711_jb51net.rar
[Android MenuInflater]: http://www.jb51.net/article/35791.htm
[Android_UI]: http://www.jb51.net/article/36619.htm
[Android_UI 1]: http://www.jb51.net/article/36620.htm
[Android _UI]: http://www.jb51.net/article/37208.htm
[android UI_android_layout]: http://www.jb51.net/article/37402.htm
[android_ui]: http://www.jb51.net/article/45509.htm
[android_handler ui_ui]: http://www.jb51.net/article/45528.htm
[android _uinput]: http://www.jb51.net/article/45601.htm
[android_handler_ui]: http://www.jb51.net/article/46132.htm
[Android UI]: http://www.jb51.net/article/79811.htm