Android Fragment 真正的完全解析

合集下载

Android Fragment使用详解

Android   Fragment使用详解

Fragment(一)1. 继承关系ng.Object|__android.app.Fragment实现接口:ComponentCallbacks2 View.OnCreateContextMenuListener引入版本:API Level 11已知的子类:DialogFragment、ListFragment、PreferenceFragment、WebViewFragment2. 类概要一个Fragment是应用程序的用户界面或行为的一个片段,它能够被放置在一个Activity中。

通过FragmentManager对象来实现与Fragment对象的交互,能够通过Activity.getFragmentManager()方法和Fragment.getFragmentManager()方法来获取FragmentManager对象。

Fragment类有着广泛的应用,它的核心是代表了一个正在较大的Activity中运行的特俗的操作或界面。

Fragment对象跟它所依附的Activity对象是紧密相关的,并且不能被分开使用。

尽管Fragment对象定义了它们自己的生命周期,但是这个生命周期要依赖与它所在的Activity:如果该Activity被终止,那么它内部的Fragment是不能被启动的;当Activity被销毁时,它内部的所有Fragment对象都会被销毁。

所有的Fragment子类都必须包含一个公共的空的构造器。

在需要的时候,Framework 会经常重新实例化Fragment类,在特殊的状态恢复期间,需要能够找到这个构造器来实例化Fragment类。

如果空的构造器无效,那么在状态恢复期间会导致运行时异常发生。

较旧的平台尽管Fragment API是在HONEYCOMB版本中被引入的,但是通过FragmentActivity也能够在较旧的平台上使用该API。

声明周期尽管Fragment对象的生命周期要依附于它所在的Activity对象,但是它也有自己标准的活动周期,它包含了基本的活动周期方法,如onResume(),但是同时也包含了与Activity 和UI交互相关的重要方法。

FRAG详解

FRAG详解

自从Android 3.0中引入fragments 的概念,其上的是为了解决不同屏幕分辩率的动态和灵活UI设计。

fragments 的设计不需要你来亲自管理view hierarchy 的复杂变化,通过将Activity 的布局分散到frament 中,可以在运行时修改activity 的外观,并且由activity 管理的back stack 中保存些变化。

每一个fragments 都有自己的一套生命周期回调方法和处理自己的用户输入事件。

对应生命周期可参考下面流程:onAttach()->onCreate()->onCreateView()->onActivityCreated()->onStart( )->onResume()此时Fragment就开始运行了。

onPause()->onStop()->onDestoryView()->onDestory()->onDetach()此时Fragment就彻底销毁了。

Fragment生命周期图如下:其中onAttach()和onDetach()用的不是很多,而onCreateView()和onDestoryView()是Fragment生命周期和Activity生命周期不同的。

其他的可以按照Activity生命周期去理解。

下面补充一下Activity的生命周期。

三种系统内置的Fragments系统内置了三种Fragments ,这三种Fragments 分别有不同的应用场景分别为:DialogFragment对话框式的Fragments,可以将一个fragments 对话框并到activity 管理的fragments back stack 中,允许用户回到一个前曾摒弃fragments.ListFragments类似于ListActivity 的效果,并且还提供了ListActivity 类似的onListItemCLick和setListAdapter等功能。

fragement详解

fragement详解

fragement详解Fragment(片段)是编程中的一个概念,指的是在Android开发中可以独立存在的模块化组件。

相较于Activity(活动),Fragment有更好的灵活性、可重用性和扩展性。

本文将详细解释Fragment的定义、使用方法、生命周期、与Activity的关系等内容,以帮助读者深入了解Fragment的优点和实践。

第一部分:Fragment定义和使用方法一、Fragment定义Fragment是Android提供的一种用户界面组件,可以嵌入到Activity中进行布局和交互。

每个Fragment都有自己的生命周期,可以独立接收用户输入、响应事件、更新UI等。

Fragment可以看作是一种轻量级的Activity,但与Activity不同的是,Fragment必须依附于一个Activity才能使用。

二、Fragment使用方法要在项目中使用Fragment,首先需要确保你的项目使用了适当的版本和依赖库。

在Android Studio中,可以在build.gradle 文件中添加以下代码来引入Fragment支持:```implementation 'androidx.fragment:fragment:1.3.0'```然后,在XML布局文件中定义Fragment的容器。

在Activity 中可以添加一个`<FrameLayout>`元素作为容器,如下所示:```<FrameLayoutandroid:id="@+id/fragment_container"android:layout_width="match_parent"android:layout_height="match_parent" />```接着,在Activity中实例化一个Fragment对象,并将其添加到容器中。

android_fragment学习笔记2

android_fragment学习笔记2

Fragment 表现Activity 中用UI的一个行为或者一部分. 可以组合多个fragment 放在一个单独的activity中来创建一个多界面区域的UI,并可以在多个activity里重用某一个fragment.把fragment 想象成一个activity的模块化区域, 有它自己的生命周期, 接收属于它的输入事件, 并且可以在activity运行期间添加和删除.Fragment 必须总是被嵌入到一个activity中, 它们的生命周期直接被其所属的宿主activity的生命周期影响. 例如, 当activity被暂停,那么在其中的所有fragment 也被暂停; 当activity被销毁, 所有隶属于它的fragment也被销毁. 然而,当一个activity正在运行时(处于resumed状态), 我们可以独立地操作每一个fragment, 比如添加或删除它们. 当处理这样一个fragment事务时, 也可以将它添加到activity所管理的back stack -- 每一个activity中的back stack实体都是一个发生过的fragment事务的记录. back stack允许用户通过按下BACK 按键从一个fragment事务后退(往后导航).将一个fragment作为activity布局的一部分添加进来时, 它处在activity的view hierarchy中的ViewGroup中, 并且定义有它自己的view布局.通过在activity的布局文件中声明fragment来插入一个fragment到你的activity布局中, 或者可以写代码将它添加到一个已存在的ViewGroup.然而, fragment并不一定必须是activity 布局的一部分; 也可以将一个fragment作为activity的隐藏的后台工作者.本文档描述了如何使用fragment创建你的应用程序, 包括:当被添加到activity的back stack后, fragment如何维护他们的状态. 在activity中,与activity和其他fragment共享事件.构建到activity的action bar.以及更多内容.设计哲学Android在3.0中引入了fragments的概念,主要目的是用在大屏幕设备上--例如平板电脑上,支持更加动态和灵活的UI设计. 平板电脑的屏幕要比手机的大得多,有更多的空间来放更多的UI组件,并且这些组件之间会产生更多的交互.Fragment 允许这样的一种设计,而不需要你亲自来管理view hierarchy的复杂变化. 通过将activity的布局分散到fragment中, 你可以在运行时修改activity的外观, 并在由activity管理的back stack中保存那些变化.例如, 一个新闻应用可以在屏幕左侧使用一个fragment来展示一个文章的列表, 然后在屏幕右侧使用另一个fragment来展示一篇文章–2个fragment并排显示在相同的一个activity中, 并且每一个fragment拥有它自己的一套生命周期回调方法,并且处理它们自己的用户输入事件. 因此, 取代使用一个activity来选择一篇文章,而另一个activity来阅读文章的方式, 用户可以在相同的activity中选择一篇文章并且阅读, 如图所示:fragment在你的应用中应当是一个模块化和可重用的组件. 即,因为fragment定义了它自己的布局, 以及通过使用它自己的生命周期回调方法定义了它自己的行为, 你可以将fragment包含到多个activity中. 这点特别重要, 因为这允许你将你的用户体验适配到不同的屏幕尺寸.举个例子, 你可能会仅当在屏幕尺寸足够大时,在一个activity中包含多个fragment, 并且,当不属于这种情况时,会启动另一个单独的,使用不同fragment的activity.继续之前那个新闻的例子-- 当运行在一个特别大的屏幕时(例如平板电脑),app可以在Activity A中嵌入2个fragment. 然而,在一个正常尺寸的屏幕(例如手机)上,没有足够的空间同时供2个fragment用, 因此, Activity A 会仅包含文章列表的fragment, 而当用户选择一篇文章时, 它会启动Activity B,它包含阅读文章的fragment. 因此, 应用可以同时支持图1中的2种设计模式.创建Fragment要创建一个fragment, 必须创建一个Fragment 的子类(或者继承自一个已存在的它的子类). Fragment 类的代码看起来很像Activity .它包含了和activity类似的回调方法, 例如onCreate(), onStart(), onPause, 以及onStop(). 事实上, 如果你准备将一个现成的Android应用转换到使用fragment, 你可能只需简单的将代码从你的activity的回调函数分别移动到你的fragment的回调方法.通常, 应当至少实现如下的生命周期方法:onCreate()当创建fragment时, 系统调用此方法.在实现代码中, 应当初始化想要在fragment中保持的必要组件, 当fragment被暂停或者停止后可以恢复.onCreateView()fragment第一次绘制它的用户界面的时候, 系统会调用此方法. 为了绘制fragment的UI, 此方法必须返回一个View, 这个view是你的fragment布局的根view. 如果fragment不提供UI, 可以返回null.onPause()用户将要离开fragment时,系统调用这个方法作为第一个指示(然而它不总是意味着fragment将被销毁.) 在当前用户会话结束之前,通常应当在这里提交任何应该持久化的变化(因为用户有可能不会返回).大多数应用应当为每一个fragment实现至少这3个方法, 但是还有一些其他回调方法你也应当用来去处理fragment生命周期的各种阶段.全部的生命周期回调方法将会在后面章节Handling the Fragment Lifecycle 中讨论.除了继承基类Fragment , 还有一些子类你可能会继承:DialogFragment显示一个浮动的对话框.用这个类来创建一个对话框,是使用在Activity类的对话框工具方法之外的一个好的选择,因为你可以将一个fragment对话框合并到activity管理的fragment back stack中, 允许用户返回到一个之前曾被摒弃的fragment.ListFragment显示一个由一个adapter(例如SimpleCursorAdapter)管理的项目的列表, 类似于ListActivity.它提供一些方法来管理一个list view, 例如onListItemClick() 回调来处理点击事件.PreferenceFragment显示一个Preference对象的层次结构的列表, 类似于PreferenceActivity.这在为你的应用创建一个"设置"activity时有用处.添加一个用户界面fragment通常用来作为一个activity的用户界面的一部分, 并将它的layout提供给activity.为了给一个fragment提供一个layout,你必须实现onCreateView() 回调方法, 当到了fragment绘制它自己的layout的时候, Android系统调用它.你的此方法的实现代码必须返回一个你的fragment的layout的根view.注意: 如果你的fragment是ListFragment的子类, 它的默认实现是返回从onCreateView()返回一个ListView, 所以一般情况下不必实现它.从onCreateView()返回的View, 也可以从一个xml layout资源文件中读取并生成. 为了帮助你这么做, onCreateView() 提供了一个LayoutInflater 对象.举个例子, 这里有一个Fragment的子类, 从文件example_fragment.xml 加载了传入onCreateView() 的container 参数是你的fragment layout将被插入的父ViewGroup(来自activity的layout).savedInstanceState 参数是一个Bundle, 如果fragment是被恢复的,它提供关于fragment的之前的实例的数据,inflate() 方法有3个参数:想要加载的layout的resource ID.加载的layout的父ViewGroup.传入container是很重要的, 目的是为了让系统接受所要加载的layout的根view 的layout参数,由它将挂靠的父view指定.布尔值指示在加载期间, 展开的layout是否应当附着到ViewGroup (第二个参数). (在这个例子中, 指定了false, 因为系统已经把展开的layout插入到container –传入true会在最后的layout中创建一个多余的view group.)将fragment添加到activity通常地, fragment为宿主activity提供UI的一部分, 被作为activity的整个view hierarchy的一部分被嵌入. 有2种方法你可以添加一个fragment到activity layout:在activity的layout文件中声明fragment你可以像为View一样, 为fragment指定layout属性.例子是一个有2个fragment的activity:<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="/apk/res/android"android:orientation="horizontal"android:layout_width="match_parent"android:layout_height="match_parent"><fragment android:name="com.example.news.ArticleListFragment"android:id="@+id/list"android:layout_weight="1"android:layout_width="0dp"android:layout_height="match_parent" /><fragment android:name="com.example.news.ArticleReaderFragment"android:id="@+id/viewer"android:layout_weight="2"android:layout_width="0dp"android:layout_height="match_parent" /></LinearLayout><fragment> 中的android:name 属性指定了在layout中实例化的Fragment类.当系统创建这个activity layout时, 它实例化每一个在layout中指定的fragment,并调用每一个上的onCreateView()方法,来获取每一个fragment的layout. 系统将从fragment返回的View 直接插入到<fragment>元素所在的地方.注意: 每一个fragment都需要一个唯一的标识, 如果activity重启,系统可以用来恢复fragment(并且你也可以用来捕获fragment来处理事务,例如移除它.)有3种方法来为一个fragment提供一个标识:为android:id 属性提供一个唯一ID.为android:tag 属性提供一个唯一字符串.如果以上2个你都没有提供, 系统使用容器view的ID.撰写代码将fragment添加到一个已存在的ViewGroup.当activity运行的任何时候, 都可以将fragment添加到activity layout.只需简单的指定一个需要放置fragment的ViewGroup.为了在你的activity中操作fragment 事务(例如添加,移除,或代替一个fragment),必须使用来自FragmentTransaction 的API.可以按如下方法,从你的Activity取得一个FragmentTransaction 的实例: FragmentManager fragmentManager = getFragmentManager(); FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();然后你可以使用add() 方法添加一个fragment, 指定要添加的fragment, 和要插入的view.ExampleFragment fragment = new ExampleFragment(); fragmentTransaction.add(R.id.fragment_container, fragment); mit();add()的第一个参数是fragment要放入的ViewGroup, 由resource ID指定, 第二个参数是需要添加的fragment.一旦用FragmentTransaction做了改变,为了使改变生效,必须调用commit().添加一个无UI的fragment之前的例子展示了对UI的支持, 如何将一个fragment添加到activity. 然而, 也可以使用fragment来为activity提供后台行为而不用展现额外的UI.要添加一个无UI的fragment, 需要从activity使用add(Fragment, String) 来添加fragment (为fragment提供一个唯一的字符串"tag", 而不是一个view ID).这么做添加了fragment, 但因为它没有关联到一个activity layout中的一个view, 所以不会接收到onCreateView()调用. 因此不必实现此方法.为fragment提供一个字符串tag并不是专门针对无UI的fragment的–也可以提供字符串tag给有UI的fragment –但是如果fragment没有UI,那么这个tag是仅有的标识它的途径. 如果随后你想从activity获取这个fragment, 需要使用findFragmentByTag().管理Fragment要在activity中管理fragment, 需要使用FragmentManager. 通过调用activity的getFragmentManager()取得它的实例.可以通过FragmentManager做一些事情, 包括:使用findFragmentById() (用于在activity layout中提供一个UI的fragment)或findFragmentByTag() (适用于有或没有UI的fragment)获取activity中存在的fragment将fragment从后台堆栈中弹出, 使用popBackStack() (模拟用户按下BACK 命令). 使用addOnBackStackChangeListener()注册一个监听后台堆栈变化的listener.处理Fragment事务关于在activity中使用fragment的很强的一个特性是: 根据用户的交互情况,对fragment进行添加,移除,替换,以及执行其他动作.提交给activity的每一套变化被称为一个事务, 可以使用在FragmentTransaction 中的API 处理.我们也可以保存每一个事务到一个activity管理的back stack,允许用户经由fragment的变化往回导航(类似于通过activity往后导航).从FragmentManager 获得一个FragmentTransaction的实例:FragmentManager fragmentManager = getFragmentManager(); FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();每一个事务都是同时要执行的一套变化.可以在一个给定的事务中设置你想执行的所有变化,使用诸如add(), remove(), 和replace().然后, 要给activity应用事务, 必须调用commit().在调用commit()之前, 你可能想调用addToBackStack(),将事务添加到一个fragment事务的back stack. 这个back stack由activity管理, 并允许用户通过按下BACK 按键返回到前一个fragment状态.举个例子, 这里是如何将一个fragment替换为另一个, 并在后台堆栈中保留之前的状态:// Create new fragment and transactionFragment newFragment = new ExampleFragment();FragmentTransaction transaction = getFragmentManager().beginTransaction();// Replace whatever is in the fragment_container view with this fragment,// and add the transaction to the back stacktransaction.replace(R.id.fragment_container, newFragment);transaction.addToBackStack(null);// Commit the transactionmit();在这个例子中, newFragment 替换了当前layout容器中的由R.id.fragment_container标识的fragment.通过调用addToBackStack(), replace事务被保存到back stack, 因此用户可以回退事务,并通过按下BACK按键带回前一个fragment.如果添加多个变化到事务(例如add()或remove())并调用addToBackStack(), 然后在你调用commit()之前的所有应用的变化会被作为一个单个事务添加到后台堆栈, BACK按键会将它们一起回退.添加变化到FragmentTransaction的顺序不重要, 除以下例外:必须最后调用commit().如果添加多个fragment到同一个容器, 那么添加的顺序决定了它们在view hierarchy中显示的顺序.当执行一个移除fragment的事务时, 如果没有调用addToBackStack(), 那么当事务提交后, 那个fragment会被销毁,并且用户不能导航回到它. 有鉴于此, 当移除一个fragment时,如果调用了addToBackStack(), 那么fragment会被停止, 如果用户导航回来,它将会被恢复.提示: 对于每一个fragment事务, 你可以应用一个事务动画, 通过在提交事务之前调用setTransition()实现.调用commit() 并不立即执行事务.恰恰相反, 它将事务安排排期, 一旦准备好, 就在activity的UI线程上运行(主线程).如果有必要, 无论如何, 你可以从你的UI 线程调用executePendingTransactions() 来立即执行由commit()提交的事务. 但这么做通常不必要, 除非事务是其他线程中的job的一个从属.警告: 你只能在activity保存它的状态(当用户离开activity)之前使用commit()提交事务.如果你试图在那个点之后提交, 会抛出一个异常.这是因为如果activity需要被恢复, 提交之后的状态可能会丢失.对于你觉得可以丢失提交的状况, 使用commitAllowingStateLoss().与Activity通信尽管Fragment被实现为一个独立于Activity的对象,并且可以在多个activity中使用, 但一个给定的fragment实例是直接绑定到包含它的activity的. 特别的, fragment可以使用getActivity() 访问Activity实例, 并且容易地执行比如在activity layout中查找一个view的任务.View listView = getActivity().findViewById(R.id.list);同样地, activity可以通过从FragmentManager获得一个到Fragment的引用来调用fragment中的方法, 使用findFragmentById() 或findFragmentByTag().ExampleFragment fragment = (ExampleFragment) getFragmentManager().findFragmentById(R.id.example_fragment);为Activity创建事件回调方法在一些情况下, 你可能需要一个fragment与activity分享事件. 一个好的方法是在fragment中定义一个回调的interface, 并要求宿主activity实现它.当activity通过interface接收到一个回调, 必要时它可以和在layout中的其他fragment分享信息.例如, 如果一个新的应用在activity中有2个fragment –一个用来显示文章列表(framgent A), 另一个显示文章内容(fragment B) –然后framgent A必须告诉activity何时一个list item被选中,然后它可以告诉fragment B去显示文章.在这个例子中, OnArticleSelectedListener 接口在fragment A中声明:public static class FragmentA extends ListFragment {...// Container Activity must implement this interfacepublic interface OnArticleSelectedListener {public void onArticleSelected(Uri articleUri);}...}然后fragment的宿主activity实现OnArticleSelectedListener 接口, 并覆写onArticleSelected() 来通知fragment B,从fragment A到来的事件.为了确保宿主activity实现这个接口, fragment A的onAttach() 回调方法(当添加fragment到activity时由系统调用) 通过将作为参数传入onAttach()的Activity做类型转换来实例化一个OnArticleSelectedListener实例.public static class FragmentA extends ListFragment {OnArticleSelectedListener mListener;...@Overridepublic void onAttach(Activity activity) {super.onAttach(activity);try {mListener = (OnArticleSelectedListener) activity;} catch (ClassCastException e) {throw new ClassCastException(activity.toString() + " must implement OnArticleSelectedListener");}}...}如果activity没有实现接口, fragment会抛出ClassCastException 异常. 正常情形下, mListener成员会保持一个到activity的OnArticleSelectedListener实现的引用, 因此fragment A可以通过调用在OnArticleSelectedListener接口中定义的方法分享事件给activity.例如, 如果fragment A是一个ListFragment的子类, 每次用户点击一个列表项, 系统调用在fragment中的onListItemClick(),然后后者调用onArticleSelected() 来分配事件给activity.public static class FragmentA extends ListFragment {OnArticleSelectedListener mListener;...@Overridepublic void onListItemClick(ListView l, View v, int position, long id) {// Append the clicked item's row ID with the content provider UriUri noteUri = ContentUris.withAppendedId(ArticleColumns.CONTENT_URI, id); // Send the event and Uri to the host activitymListener.onArticleSelected(noteUri);}...}传给onListItemClick() 的id 参数是被点击的项的行ID, activity(或其他fragment)用来从应用的ContentProvider 获取文章.添加项目到Action Bar你的fragment可以通过实现onCreateOptionMenu() 提供菜单项给activity的选项菜单(以此类推, Action Bar也一样).为了使这个方法接收调用,无论如何, 你必须在onCreate() 期间调用setHasOptionsMenu() 来指出fragment愿意添加item 到选项菜单(否则, fragment将接收不到对onCreateOptionsMenu()的调用)随后从fragment添加到Option菜单的任何项,都会被追加到现有菜单项的后面.当一个菜单项被选择, fragment也会接收到对onOptionsItemSelected() 的回调.也可以在你的fragment layout中通过调用registerForContextMenu() 注册一个view来提供一个环境菜单.当用户打开环境菜单, fragment接收到一个对onCreateContextMenu() 的调用.当用户选择一个项目, fragment接收到一个对onContextItemSelected() 的调用.注意: 尽管你的fragment会接收到它所添加的每一个菜单项被选择后的回调, 但实际上当用户选择一个菜单项时, activity会首先接收到对应的回调.如果activity的on-item-selected回调函数实现并没有处理被选中的项目, 然后事件才会被传递到fragment的回调.这个规则适用于选项菜单和环境菜单.处理Fragment生命周期管理fragment的生命周期, 大多数地方和管理activity生命周期很像.和activity一样,fragment可以处于3种状态:Resumed在运行中的activity中fragment可见.Paused另一个activity处于前台并拥有焦点, 但是这个fragment所在的activity仍然可见(前台activity局部透明或者没有覆盖整个屏幕).Stopped要么是宿主activity已经被停止, 要么是fragment从activity被移除但被添加到后台堆栈中.停止状态的fragment仍然活着(所有状态和成员信息被系统保持着). 然而, 它对用户不再可见, 并且如果activity被干掉,他也会被干掉.仍然和activity一样,你可以使用Bundle保持fragment的状态,万一activity的进程被干掉,并且当activity被重新创建的时候, 你需要恢复fragment的状态时就可以用到. 你可以在fragment的onSaveInstanceState() 期间保存状态, 并可以在onCreate(), onCreateView() 或onActivityCreated() 期间恢复它.生命周期方面activity和fragment之间最重要的区别是各自如何在它的后台堆栈中储存. 默认地, activity在停止后, 它会被放到一个由系统管理的用于保存activity的后台堆栈.(因此用户可以使用BACK按键导航回退到它).然而, 仅当你在一个事务期间移除fragment时,显式调用addToBackStack()请求保存实例时,才被放到一个由宿主activity管理的后台堆栈.另外, 管理fragment的生命周期和管理activity生命周期非常类似.因此, "managing the activity lifecycle"中的相同实践也同样适用于fragment. 你需要理解的是, activity的生命如何影响fragment的生命.与activity生命周期的协调工作fragment所生存的activity的生命周期,直接影响fragment的生命周期, 每一个activity的生命周期的回调行为都会引起每一个fragment中类似的回调.例如, 当activity接收到onPause()时,activity中的每一个fragment都会接收到onPause().Fragment 有一些额外的生命周期回调方法, 那些是处理与activity的唯一的交互, 为了执行例如创建和销毁fragment的UI的动作. 这些额外的回调方法是: onAttach()当fragment被绑定到activity时被调用(Activity会被传入.).onCreateView()创建和fragment关联的view hierarchy时调用.onActivityCreated()当activity的onCreate()方法返回时被调用.onDestroyView()当和fragment关联的view hierarchy正在被移除时调用.onDetach()当fragment从activity解除关联时被调用.fragment生命周期的流程, 以及宿主activity对它的影响, 在图3中显示.在这个图中, 可以看到activity依次的每个状态是如何决定fragment可能接收到的回调方法.例如, 当activity接收到它的onCreate(), activity中的fragment接收到最多是onActivityCreated().一旦activity到达了resumed状态, 你可以自由地在activity添加和移除fragment.因此, 仅当activity处于resumed状态时, fragment的生命周期才可以独立变化. 无论如何, 当activity离开resumed状态, fragment再次被activity的推入它自己的生命周期过程。

详解Android开发中Fragment的使用

详解Android开发中Fragment的使用

详解Android开发中Fragment的使⽤前⾔学习Java和Android将近⼀年的时间了,期间的成果应该就是独⽴完成了⼀个Android客户端,并且保证了其在主线版本的稳定性。

期间遇到了很多坑,也跟着师兄学到了很多Android知识。

但是⼈总是要拥抱变化,不能让⾃⼰太安逸,虽然有不舍,但是我已经证明了⾃⼰的学习能⼒,下⼀步就是开始做Rom Porting了。

这⾥总结⼀下之前项⽬中⽤到最多的Fragment。

Fragment简介Fragment可以理解成Activity中⽤户界⾯的⼀个⾏为或者⼀部分,它必须被嵌套在Activity中。

但是⼀个Fragment有它⾃⼰独⽴的xml布局⽂件,并且具有良好的封装性,因此特殊情况下Fragment可以很容易⽤Activity来进⾏替换。

创建Fragment创建⼀个Fragment和创建Activity类似,需要实现XML布局⽂件和Java Class。

XML布局⽂件和其他布局⽂件都⼀样,例如如下所⽰的布局⽂件(fragment_layout.xml):<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="/apk/res/android"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical" ><TextViewandroid:id="@+id/textView"android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@string/testview" /><Buttonandroid:id="@+id/button"android:layout_width="wrap_content"android:layout_height="wrap_content"android:text="@string/button" /></LinearLayout>Java代码中,⼀般情况下可以根据需要实现Fragment以下⼏个⽣命周期⽅法:1. onAttach():当Fragment依附于activity时被调⽤,可以在该⽅法中获取activity句柄,从⽽实现Fragment和activity之间的通信。

Android成长日记-Fragment

Android成长日记-Fragment

Android成长日记-Fragment(一)Android在3.0中引入了Fragment的概念,主要目的是用在大屏幕设备上—例如平板电脑上,支持更加动态和灵活的UI设计。

平板电脑的屏幕要比手机大的多,有更多的空间放更多的UI组件,并且这些组件之间会产生更多的交互(二)Fragment在你的应用中应当是一个模块化和可重用的组件,因为Fragment定义了他自己的布局,以及通过使用他自己的生命周期回调方法定义了他自己的行为,你可以将Fragment包含到多个activity中(三)【Fragment知识概要】(1)Fragment可以作为Activity界面的一部分组成出现(2)可以在一个activity同时多个Fragment,并且一个Fragment 可以运行在多个activity中使用(3)在activity运行过程中,可以添加、移除、替换Fragment (4)Fragment可以响应自己的输入事件,并且有自己的生命周期,他们的生命周期会受宿主activity的生命周期的影响------------------------------------------------------------------- (四)Fragment的加载方式(1)静态加载在activity的layout文件中声明Fragment,需要特别注意的是<Fragment>中的Android:name属性指定了在layout中实例化的Fragment类--→标示Fragment的方法Android:id属性提供一个唯一的IDAndroid:tag属性提供一个唯一字符串Eg://实现布局文件中包含<fragment>,<fragment>的name为一个类,类中的将另外一个含有控件的布局转换成View对象,将View对象-→之前的布局文件中的操作(关键词:静态加载)1.在layout创建一个main,在main中存放Fragment.xml (ps:Fragment含有id,width,height,name)2.在layout创建一个fragment_kongjian.xml,含有组件(TextView,Button)3.创建fragment.java,创建方法:public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState)4.将Layout布局文件转换成View对象View view = inflater.inflate(yout.fragment_kongjian, container, false)Ps(resource:Fragment需要加载的布局文件root:加载layout的父ViewGroup;attactToRoot:false,不返回父ViewGroup)5.初始化fragment_kongjian.xml中的空间TextView text=(TextView) view.findViewById(R.id.text);Button button=(Button) view.findViewById(R.id.button)6.操作略7.在MainActivity.java中创建intent,当按钮点击后跳转到SecondActivity.java,SecondActivity.java含有一个onCreate 方法,为打开main布局—>1.main.xm8.Main.xml中的frame的布局的name:Fragment.java的具体位置------------------------------------------------------------------ (2)动态加载撰写代码将Fragment添加到一个Activity Layout中add():添加一个Fragment(指定要添加的Fragment和插入的View)与此类似的还有remove()/replace()*处理Fragment事务根据用户的交互情况,对Fragment进行添加、移除、替换、以及执行其他操作,提交给Activity的每一套变化被称作一个事务FragmentManager fragmentManager==getFragmentManager(); FragmentTransaction beginTransaction= fragmentManager.beginTransaction();Eg:实现步骤:1.Fragment fragment=new fragment();//这个Fragment为含有View对象的Fragment.java2.ps:以事务的方式进行操作FragmentManager fragmentManager==getFragmentManager(); FragmentTransaction beginTransaction= fragmentManager.beginTransaction(); beginTransaction.add(“R.id.frame”,frameManager);beginTransaction.addToBackStack(null);mit();//提交事务----------------------------------------------------------------------- PS:每一个事务都是同时执行一套变化,可以在一个事务中设置你所有想执行的变化,包括add(),remove(),replace(),然后提交给Activity,必须调用commit()方法- 与数据库的事务提交方法相同如果允许用户通过按下BACK按键返回到前一个Fragment状态,调用commit()之前可以加入addToBackStack()方法-----------------------------------------------------------------------。

fragment用法详解

fragment用法详解

fragment用法详解一、Fragment简介Fragment是Android开发中一个重要的组件,它提供了一种在Activity或Fragment之间共享用户界面的方式。

Fragment可以独立地加载和更新,而不需要重新创建整个Activity或Fragment。

这使得Fragment在处理复杂的用户界面和交互时非常有用。

二、Fragment生命周期Fragment的生命周期与Activity相似,但也存在一些特殊之处。

Fragment的生命周期包括以下阶段:1. 创建阶段:当Fragment被添加到Activity中时,会进入创建阶段。

这个阶段包括Fragment的实例被创建,以及相关数据被初始化。

2. 活动阶段:Fragment与Activity一起活动,包括用户交互和更新等。

3. 销毁阶段:当Activity或Fragment不再需要时,会进入销毁阶段。

这个阶段包括Fragment的内部状态被保存,以及相关的资源被释放。

Fragment还提供了自己的生命周期回调方法,如onCreateView()和onDestroyView(),用于控制Fragment与视图树的交互。

下面是一个简单的Fragment用法示例:1. 在布局文件中添加Fragment元素:在布局文件中,可以使用<fragment>元素将Fragment添加到Activity中。

2. 在Activity中获取Fragment实例:在Activity中,可以使用getSupportFragmentManager()方法获取FragmentManager实例,然后使用findFragmentById()方法获取指定ID的Fragment实例。

3. 更新Fragment内容:可以使用setRetainInstance(true)方法保留Fragment实例,以便在Activity重新创建时保留Fragment的状态。

andorid中的fragment详细介绍及应用

andorid中的fragment详细介绍及应用

android Fragments详解一:概述Fragment是activity的界面中的一部分或一种行为。

你可以把多个Fragment们组合到一个activity中来创建一个多面界面并且你可以在多个activity中重用一个Fragment。

你可以把Fragment认为模块化的一段activity,它具有自己的生命周期,接收它自己的事件,并可以在activity运行时被添加或删除。

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

例如:当activity暂停时,它拥有的所有的Fragment们都暂停了,当activity销毁时,它拥有的所有Fragment们都被销毁。

然而,当activity运行时(在onResume()之后,onPause()之前),你可以单独地操作每个Fragment,比如添加或删除它们。

当你在执行上述针对Fragment的事务时,你可以将事务添加到一个棧中,这个栈被activity管理,栈中的每一条都是一个Fragment的一次事务。

有了这个栈,就可以反向执行Fragment的事务,这样就可以在Fragment级支持“返回”键(向后导航)。

当向activity中添加一个Fragment时,它须置于ViewGroup控件中,并且需定义Fragment自己的界面。

你可以在layoutxml文件中声明Fragment,元素为:<fragment>;也可以在代码中创建Fragment,然后把它加入到ViewGroup控件中。

然而,Fragment 不一定非要放在activity的界面中,它可以隐藏在后台为actvitiy工作。

本章描述如何使用fragment,包括fragment在加入activity的后退棧中时如何保持自己的状态,如何与activity以及其它fragment们共享事件,如何显示在activity的动作栏,等等。

fragment基本概述

fragment基本概述

fragment基本概述Fragment是Android开发中一个重要的组件,它可以被认为是一个独立的模块,用于构建灵活而复杂的用户界面。

本文将对Fragment进行基本概述,介绍它的定义、特点以及使用场景。

Fragment是在Android 3.0引入的,在此之前,Android只有Activity作为界面的基本单元。

Fragment的出现使得开发者可以更灵活地管理界面和组件,实现更多样化的用户界面。

Fragment类似于Activity,但有一些关键的区别。

一个Activity可以包含多个Fragment,并且这些Fragment可以被动态添加、移除和替换。

与Activity不同,Fragment可以在不同的Activity之间共享和重用,使得界面的组织和复杂性得到了很大的增强。

Fragment可以看作是Activity的一部分,但它具有自己的生命周期和事件回调。

例如,Fragment可以接收和处理用户输入事件,与Activity进行通信等。

Fragment也有自己的布局和视图,可以独立管理和更新。

使用Fragment的主要优势之一是其适应不同屏幕尺寸和设备方向的能力。

通过动态管理Fragment,可以在一个Activity中根据屏幕大小和方向动态地添加或移除Fragment,以适应不同的设备和用户界面要求。

与Activity一样,Fragment也有自己的生命周期,包括onCreate、onStart、onResume、onPause、onStop、onDestroy等方法。

在Activity生命周期变化时,Fragment的生命周期也会相应地发生变化,因此可以在合适的时机执行逻辑或保存状态。

Fragment在Android开发中有广泛的应用场景,特别是在多面板布局和可复用组件方面。

它可以使得应用界面更加灵活、模块化和可扩展。

例如,可以使用Fragment实现一个界面同时显示地图和其他信息,或者在平板电脑上实现一个列表和详细信息的显示等。

Android入门之Fragment用法

Android入门之Fragment用法

Android入门之Fragment用法MicrosoftInternetExplorer402DocumentNotSpecified7.8 磅Normal0当我们需要动态的多界面切换的时候,就需要将UI元素和Activity融合成一个模块。

在2.3中我们一般通过各种Activity中进行跳转来实现多界面的跳转和单个界面动态改变。

在4.0或以上系统中就可以使用新的特性来方便的达到这个效果--Fragment类。

Fragment类似一个嵌套Activity,可以定义自己的layout和自己的生命周期。

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

下面将向您讲述如何创建通过Fragment向用户提供一个动态的体验,并且还可以针对不同的屏幕尺寸做优化,给用户提供更好的使用体验。

该特性可以运行在Android1.6上面(当然需要google库的支持)。

(all while continuing to support devices running versions as old as Android 1.6.这个真心没搞懂,E文好的同学指点下)使用Android库Android支持库是一个jar文件,使用这个支持库可以让我们在低版本上运行高版本的特性(比如Fragment并非1.6的特性,但是通过库的引入,我们可以将包含fragment的程序运行在1.6上面,保证程序兼容性)。

步骤:1. 通过SDK Manager下载Android Support Package。

2. 在项目代码顶层创建libs文件夹,并将你需要的jar库文件拷贝到libs里面去。

3. 更新manifest文件,设置如下<uses-sdk android:minSdkVersion="4" android:targetSdkVersion="15" />为了确保没有在旧的系统上面使用新的api特性,却要在使用Fragment的文件中包含如下内容:import android.support.v4.app.Fragment;import android.support.v4.app.FragmentManager;应该声明FragmentActivity(而不是Activity)来包含Fragments。

简述对fragment的认知

简述对fragment的认知

简述对fragment的认知摘要:一、Fragment的定义与作用二、Fragment的使用场景三、Fragment的优缺点四、如何优化Fragment性能五、实际案例分享正文:在我们的应用程序开发中,Fragment已经成为一种常见的组件,它可以帮助我们实现复杂的界面布局和功能模块。

本文将对Fragment进行简要概述,包括其定义、使用场景、优缺点以及在实际开发中的性能优化和案例分享。

一、Fragment的定义与作用Fragment,中文意为“片断”,是Android系统中的一种界面组件。

它允许我们在一个Activity中使用多个布局文件,实现多个ViewGroup的切换,从而提高界面的灵活性和丰富度。

Fragment可以独立于Activity存在,可以在Activity生命周期内进行添加、删除和替换,使得开发者可以更加灵活地组织和管理界面元素。

二、Fragment的使用场景1.复杂的界面布局:当我们需要在一个Activity中展示多个不同布局的界面时,可以使用Fragment来实现。

2.数据展示与操作:在某些场景下,我们需要在一个Activity中展示多种类型的数据,并且为每种数据提供不同的操作界面。

这时,使用Fragment可以轻松实现这一需求。

3.主题切换:在一些应用中,我们需要根据用户的不同需求切换界面主题。

通过使用Fragment,可以在不同主题之间轻松切换。

三、Fragment的优缺点优点:1.提高界面灵活性:Fragment使得开发者可以轻松地在Activity中切换不同的布局和功能模块。

2.代码复用:Fragment可以独立于Activity进行开发,方便在多个Activity之间共享代码和资源。

3.易于维护:通过将复杂的界面布局和功能模块封装到Fragment中,可以降低Activity的耦合度,提高应用的可维护性。

缺点:1.性能影响:过多的Fragment可能导致内存占用增加,从而影响应用的性能。

androidFragments详解六:处理fragement的生命周期

androidFragments详解六:处理fragement的生命周期

androidFragments详解六:处理fragement的⽣命周期把条⽬添加到动作栏你的fragment们可以向activity的菜单(按Manu键时出现的东西)添加项,同时也可向动作栏(界⾯中顶部的那个区域)添加条⽬,这都需通过实现⽅法onCreateOptionManu()来完成。

你从fragment添加到菜单的任何条⽬,都会出现在现有菜单项之后。

Fragment之后可以通过⽅法onOptionsItemSelected()来响应⾃⼰的菜单项被选择的事件。

你也可以在fragemnt中注册⼀个view来提供快捷菜单(上下⽂菜单)。

当⽤户要打开快捷菜单时,fragment的onCreateContextMenu()⽅法会被调⽤。

当⽤户选择其中⼀项时,fragemnt的onContextItemSelected()⽅法会被调⽤。

注:尽管你的fragment可以分别收到它所添加的菜单项的选中事件,但是activity才是第⼀个接收这些事件的家伙,只有当activity对某个事件置之不理时,fragment才能接收到这个事件,对于菜单和快捷菜单都是这样。

处理fragement的⽣命周期管理fragment的⽣命周期有些像管理activity的⽣命周期。

Fragment可以⽣存在三种状态:Resumed:Fragment在⼀个运⾏中的activity中并且可见。

Paused:另⼀个activity处于最顶层,但是fragment所在的activity并没有被完全覆盖(顶层的activity是半透明的或不占据整个屏幕)。

Stoped:Fragment不可见。

可能是它所在的activity处于stoped状态或是fragment被删除并添加到后退栈中了。

此状态的fragment仍然存在于内存中。

同样类似于activity,你可以把fragment的状态保存在⼀个Bundle中,在activity被recreated时就需⽤到这个东西。

安卓中Fragment详解篇

安卓中Fragment详解篇

FragmentAndroid中的fragment其实就类似于activity,在它上面可以做任何类似于activity的布局,但实质是fragment相当于一个位于activity上的view,因为activity中可以有多个view,所以一个activity中就能有多个fragment,这些fragment一般存放在viewgroup中便于管理。

1.要创建一个fragment必须创建一个Fragment的子类,也就是创建一个extends Fragment的类,fragment的类和activity也是十分的类似,具有很多相似的方法,如onCreate(),onStart()等,一般会实现以下几个生命周期方法:●onCreate():当创建fragment时,系统会调用此方法在实现代码时,应该初始化想要在Fragment保持的必要控件,例如fragment中要一个按钮,就可以在这里findviewbyid。

当Fragment被暂停或停止后可以恢复。

●onCreateView:Fragment第一次绘画他的用户界面时就会调用此方法,为了绘画fragment的UI,必须返回一个view。

●onPause:用户离开fragment时系统会调用此方法。

在用户会话结束之前,通常应在这里提交任何应该持久化的变化(因为用户可能不放回)2.建立一个用户界面的步骤:首先是在需要添加fragment的那个activity的xml布局文件中添加一个ViewGroup,这样就可以管理fragment,同时这个区域也是用来显示fragment 的,最简单的一个ViewGroup就是直接在xml文件中定义一块区域就行了,例如:有关ViewGroup: /linghu_java/article/details/9838873然后是新建一个xml的布局文件为你需要创建的fragment进行布局,这个布局文件中应该添加各种你自己需要加的控件以及你需要的布局样式:例如:最后就是建一个fragment子类,在这个子类中调用onCreateView方法就能将你的布局绘画出来。

详解Androidstudio动态fragment的用法

详解Androidstudio动态fragment的用法

详解Androidstudio动态fragment的⽤法fragment的使⽤时Android的基础,它有两种⽤法,第⼀个就是静态的fragment。

第⼆个则是动态的fragment。

静态fragment直接在layout创建你想要的fragment的XML的⽂件,然后在你的Java包⾥⾯创建对应fragment的class⽂件布局代码如下所⽰<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="/apk/res/android"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"><TextViewandroid:layout_width="match_parent"android:layout_height="wrap_content"android:text="欢迎来到⼴西!"/></LinearLayout><?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="/apk/res/android"xmlns:app="/apk/res-auto"xmlns:tools="/tools"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical"tools:context=".MainActivity"><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="去⼴西"android:id="@+id/bt_anjian1"/><Buttonandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:text="去⼴东"android:id="@+id/bt_anjian2"/><LinearLayoutandroid:layout_width="match_parent"android:layout_height="wrap_content"android:orientation="vertical"android:id="@+id/ll_rongqi"android:layout_weight="9"></LinearLayout><fragmentandroid:layout_width="wrap_content"android:layout_height="wrap_content"android:id="@+id/fragment_1"/></LinearLayout>*这⾥需要注意⼀下,如果你不给fragment加个id,那你运⾏app的时候将会发⽣闪退现象。

android fragment原理

android fragment原理

android fragment原理Fragment是Android开发中的一个重要概念,它可以让开发者以模块化的方式构建用户界面。

本文将深入探讨Fragment的原理,从创建到生命周期的每个阶段逐步解释。

一、什么是FragmentFragment是Android应用程序中一种可重用的UI组件。

它可以嵌入到Activity中,相当于Activity的子Activity,但比子Activity更灵活。

它允许开发者将一个大的界面拆分成多个小的、独立的部分进行管理和组装。

二、Fragment的创建1. 创建一个新的Fragment类:首先,我们需要创建一个新的Java类继承自Fragment类,并实现它的生命周期方法和其他必要的逻辑。

2. 在Activity中添加Fragment:在Activity布局中添加一个Fragment容器,即用于显示Fragment的ViewGroup。

在Activity的代码中获取FragmentManager,并使用beginTransaction()方法开启一个事务。

3. 创建Fragment的实例并添加到容器中:使用Fragment的构造函数创建一个新的Fragment实例,然后将它添加到容器中,并提交事务。

三、Fragment和Activity的交互Fragment和Activity之间有多种交互方式。

1. Fragment通过getActivity()方法获取它所依附的Activity的引用,从而可以访问Activity的方法和成员变量。

2. 通过Fragment的getArguments()方法获取传递给Fragment的参数。

Activity可以通过setArguments()方法将参数传递给该Fragment。

3. 通过定义接口在Fragment和Activity之间进行通信。

Activity实现接口,在Fragment中调用接口方法即可完成通信。

四、Fragment的生命周期Fragment有自己的生命周期,与Activity的生命周期不完全相同。

fragement详解

fragement详解

fragement详解Fragment详解Fragment是Android开发中的重要概念之一,它是一种可以嵌入到Activity中的可重用组件。

本文将详细解析Fragment的定义、使用方法以及常见应用场景。

一、Fragment的定义Fragment是Android中一种可重用的组件,它可以作为Activity界面的一部分进行使用。

与Activity一样,Fragment具有自己的生命周期和UI布局,可以接收用户输入事件。

二、Fragment的使用方法1. 创建Fragment:创建Fragment有两种方式:通过继承Fragment类创建和通过布局文件创建。

- 通过继承Fragment类创建:新建一个类,继承自Fragment类,并重写onCreateView()方法,在该方法中返回Fragment的布局。

- 通过布局文件创建:新建一个XML布局文件,定义Fragment的UI布局,然后在代码中通过LayoutInflater加载该布局。

2. 添加Fragment到Activity中:通过FragmentManager将Fragment添加到Activity中。

可以在Activity的XML布局中定义一个容器,通过FragmentTransaction将Fragment添加到该容器中。

3. Fragment的交互:Fragment可以通过getActivity()方法获取所在的Activity实例,并通过该实例进行数据交互。

也可以通过使用接口回调的方式,在Fragment和Activity之间进行交互。

4. Fragment回退栈:当多个Fragment同时存在时,可以将Fragment添加到回退栈中,通过按下返回键来回退到上一个Fragment。

可以使用addToBackStack()方法将Fragment添加到回退栈中。

三、Fragment的常见应用场景1. 多面板界面:通过将不同的Fragment添加到一个Activity中,可以实现多面板的界面效果。

Android Fragment 从源码的角度去解析(下)

Android Fragment 从源码的角度去解析(下)

Android Fragment 从源码的角度去解析(下)效果实现一般的思路我们会换实现方法,当然其他方式肯定也可以实现如ViewPager+Fragment但是我们需要预加载要不然也会出问题,一旦预加载就需要去访问网络,即使用户可能不切换Fragment就退出App了这个时候其实加载了所有Fragment的数据,而且主页一旦复杂有可能会崩溃或造成内存溢出的问题。

我的签名就是,忘记不了铭记,坚持不了放弃,但只要活着…既然这样我必须得看看源码:2.2 Fragment源码分析:把一个Fragment加到ViewGroup中就这么几行代码:add(@IdRes int containerViewId, Fragment fragment)和commit(),就这么两个方法:@Overrideprotected void initData() {FragmentManager fragmentManager = getSupportFragmentManager();FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();mHomeFragment = new HomeFragment();fragmentTransaction.add(R.id.main_tab_fl, mHomeFragment);mit();}我们点击add方法发现是个抽象方法:/*** Calls {@link #add(int, Fragment, String)} with a null tag.*/public abstract FragmentTransaction add(@IdRes int containerViewId, Fragment fragment);点击fragmentManager.beginTransaction()发现也是一个抽象方法:/*** Start a series of edit operations on the Fragments associated with* this FragmentManager.** <p>Note: A fragment transaction can only be created/committed prior* to an activity saving its state. If you try to commit a transaction* after {@link FragmentActivity#onSaveInstanceState FragmentActivity.onSaveInstanceState()}* (and prior to a following {@link FragmentActivity#onStart FragmentActivity.onStart}* or {@link FragmentActivity#onResume FragmentActivity.onResume()}, you will get an error.* This is because the framework takes care of saving your current fragments* in the state, and if changes are made after the state is saved then they* will be lost.</p>*/public abstract FragmentTransaction beginTransaction();所以只能点击getSupportFragmentManager()方法这个方法在FragmentActivity中:/*** Return the FragmentManager for interacting with fragments associated* with this activity.*/public FragmentManager getSupportFragmentManager() {return mFragments.getSupportFragmentManager();}一路摸索才找到这个add方法,发现并没有写注释这个google工程师有点打酱油节奏啊!只好自己来吧在需要的地方写一写。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

Android Fragment 真正的完全解析(上)转载请标明出处:/lmj623565791/article/details/37970961自从Fragment出现,曾经有段时间,感觉大家谈什么都能跟Fragment谈上关系,做什么都要问下Fragment能实现不~~~哈哈,是不是有点过~~~本篇博客力求为大家说明Fragment如何产生,什么是Fragment,Fragment生命周期,如何静态和动态的使用Fragment,Fragment回退栈,Fragment事务;以及Fragment的一些特殊用途,例如:没有布局的Fragment有何用处?Fragment如何与Activity交互?Fragment如何创建对话框?Fragment如何与ActionBar集成等等。

1、Fragment的产生与介绍Android运行在各种各样的设备中,有小屏幕的手机,超大屏的平板甚至电视。

针对屏幕尺寸的差距,很多情况下,都是先针对手机开发一套App,然后拷贝一份,修改布局以适应平板神马超级大屏的。

难道无法做到一个App可以同时适应手机和平板么,当然了,必须有啊。

Fragment的出现就是为了解决这样的问题。

你可以把Fragment当成Activity的一个界面的一个组成部分,甚至Activity的界面可以完全有不同的Fragment组成,更帅气的是Fragment拥有自己的生命周期和接收、处理用户的事件,这样就不必在Activity写一堆控件的事件处理的代码了。

更为重要的是,你可以动态的添加、替换和移除某个Fragment。

2、Fragment的生命周期Fragment必须是依存与Activity而存在的,因此Activity的生命周期会直接影响到Fragment 的生命周期。

官网这张图很好的说明了两者生命周期的关系:可以看到Fragment比Activity多了几个额外的生命周期回调方法:onAttach(Activity)当Fragment与Activity发生关联时调用。

onCreateView(LayoutInflater, ViewGroup,Bundle)创建该Fragment的视图onActivityCreated(Bundle)当Activity的onCreate方法返回时调用onDestoryView()与onCreateView想对应,当该Fragment的视图被移除时调用onDetach()与onAttach相对应,当Fragment与Activity关联被取消时调用注意:除了onCreateView,其他的所有方法如果你重写了,必须调用父类对于该方法的实现,3、静态的使用Fragment嘿嘿,终于到使用的时刻了~~这是使用Fragment最简单的一种方式,把Fragment当成普通的控件,直接写在Activity的布局文件中。

步骤:1、继承Fragment,重写onCreateView决定Fragemnt的布局2、在Activity中声明此Fragment,就当和普通的View一样下面展示一个例子(我使用2个Fragment作为Activity的布局,一个Fragment用于标题布局,一个Fragment用于内容布局):TitleFragment的布局文件:[html] view plaincopy<?xml version="1.0" encoding="utf-8"?><RelativeLayout xmlns:android="/apk/res/android"android:layout_width="match_parent"android:layout_height="45dp"android:background="@drawable/title_bar" ><ImageButtonandroid: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" /><TextViewandroid: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 plaincopypackage com.zhy.zhy_fragments;import android.app.Fragment;import android.os.Bundle;import youtInflater;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;@Overridepublic View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState){View view = inflater.inflate(yout.fragment_title, container, false);mLeftMenu = (ImageButton) view.findViewById(R.id.id_title_left_btn);mLeftMenu.setOnClickListener(new OnClickListener(){@Overridepublic void onClick(View v){Toast.makeText(getActivity(),"i am an ImageButton in TitleFragment ! ",Toast.LENGTH_SHORT).show();}});return view;}}同理还有ContentFragment的其布局文件:[html] view plaincopy<?xml version="1.0" encoding="utf-8"?><LinearLayout xmlns:android="/apk/res/android"android:layout_width="match_parent"android:layout_height="match_parent"android:orientation="vertical" ><TextViewandroid:layout_width="fill_parent"android:layout_height="fill_parent"android:gravity="center"android:text="使用Fragment做主面板"android:textSize="20sp"android:textStyle="bold" /></LinearLayout>[java] view plaincopypackage com.zhy.zhy_fragments;import android.app.Fragment;import android.os.Bundle;import youtInflater;import android.view.View;import android.view.ViewGroup;public class ContentFragment extends Fragment{@Overridepublic View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState){return inflater.inflate(yout.fragment_content, container, false);}}MainActivity[java] view plaincopypackage com.zhy.zhy_fragments;import android.app.Activity;import android.os.Bundle;import android.view.Window;public class MainActivity extends Activity{@Overrideprotected void onCreate(Bundle savedInstanceState){super.onCreate(savedInstanceState);requestWindowFeature(Window.FEATURE_NO_TITLE);setContentView(yout.activity_main);}}Activity的布局文件:[java] view plaincopy<RelativeLayout xmlns:android="/apk/res/android"xmlns:tools="/tools"android:layout_width="match_parent"android:layout_height="match_parent" ><fragmentandroid:id="@+id/id_fragment_title"android:name="com.zhy.zhy_fragments.TitleFragment"android:layout_width="fill_parent"android:layout_height="45dp" /><fragmentandroid:layout_below="@id/id_fragment_title"android:id="@+id/id_fragment_content"android:name="com.zhy.zhy_fragments.ContentFragment"android:layout_width="fill_parent"android:layout_height="fill_parent" /></RelativeLayout>是不是把Fragment当成普通的View一样声明在Activity的布局文件中,然后所有控件的事件处理等代码都由各自的Fragment去处理,瞬间觉得Activity好干净有木有~~代码的可读性、复用性以及可维护性是不是瞬间提升了~~~下面看下效果图:4、动态的使用Fragment上面已经演示了,最简单的使用Fragment的方式~下面介绍如何动态的添加、更新、以及删除Fragment为了动态使用Fragment,我们修改一下Actvity的布局文件,中间使用一个FrameLayout,下面添加四个按钮~~~嘿嘿~~不是微信的按钮- -![html] view plaincopy<RelativeLayout xmlns:android="/apk/res/android"xmlns:tools="/tools"android:layout_width="match_parent"android:layout_height="match_parent" ><fragmentandroid:id="@+id/id_fragment_title"android:name="com.zhy.zhy_fragments.TitleFragment"android:layout_width="fill_parent"android:layout_height="45dp" /><includeandroid:id="@+id/id_ly_bottombar"android:layout_width="fill_parent"android:layout_height="55dp"android:layout_alignParentBottom="true"layout="@layout/bottombar" /><FrameLayoutandroid:id="@+id/id_content"android:layout_width="fill_parent"android:layout_height="fill_parent"android:layout_above="@id/id_ly_bottombar"android:layout_below="@id/id_fragment_title" /></RelativeLayout>底部四个按钮的布局就不贴了,到时看效果图就明白了~~下面主Activity[java] view plaincopypackage 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;@Overrideprotected void onCreate(Bundle savedInstanceState){super.onCreate(savedInstanceState);requestWindowFeature(Window.FEATURE_NO_TITLE);setContentView(yout.activity_main);// 初始化控件和声明事件mTabWeixin = (LinearLayout) findViewById(R.id.tab_bottom_weixin);mTabFriend = (LinearLayout) findViewById(R.id.tab_bottom_friend);mTabWeixin.setOnClickListener(this);mTabFriend.setOnClickListener(this);// 设置默认的FragmentsetDefaultFragment();}private void setDefaultFragment(){FragmentManager fm = getFragmentManager();FragmentTransaction transaction = fm.beginTransaction();mWeixin = new ContentFragment();transaction.replace(R.id.id_content, mWeixin);mit();}@Overridepublic 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();// 事务提交mit();}}可以看到我们使用FragmentManager对Fragment进行了动态的加载,这里使用的是replace 方法~~下一节我会详细介绍FragmentManager的常用API。

相关文档
最新文档