fragment

可以考虑将控制显示Toolbar的逻辑写在你的外层Actvity中，外层布局里面顶部放Toolbar，底部放BottomNavigationView，然后监听他的切换回调，这个时候动态设置toolbar的标题等显示信息。

这是半句话，虽然从语法上来说是一个完整的句子，但是意思很诡异。原话全文是Now I know that I am the sphere, and all life in rhythmic fragments moves within me.是美籍黎巴嫩诗人Khalil Gibran的名言。下面分析后半个句子的成分：all life【主语】 in rhythmic fragments【介词短语作定语修饰life】 moves【谓语，三单】 within me【介词短语作状语】全句的翻译（因为不知道上下文，只能直译）：Now I know that I am the sphere, and all life in rhythmic fragments moves within me.现在我明白我就是那个球，而且所有节奏片断中的生命都在我身体内运动。

1、管理Fragment要在activity中管理fragment,需要使用FragmentManager. 通过调用activity的getFragmentManager()取得它的实例.u2022可以通过FragmentManager做一些事情, 包括: 使用findFragmentById()(用于在activity layout中提供一个UI的fragment)或findFragmentByTag()(适用于有或没有UI的fragment)获取activity中存在的fragment。u2022将fragment从后台堆栈中弹出, 使用 popBackStack() (模拟用户按下BACK 命令)。u2022使用addOnBackStackChangeListener()注册一个监听后台堆栈变化的listener。2、处理Fragment事务关于在activity中使用fragment的很强的一个特性是：根据用户的交互情况,对fragment进行添加、移除、替换以及执行其他动作。提交给activity的每一套变化被称为一个事务，可以使用在FragmentTransaction中的 API 处理。我们也可以保存每一个事务到一个activity管理的backstack，允许用户经由fragment的变化往回导航(类似于通过 activity往后导航)。从 FragmentManager 获得一个FragmentTransaction实例：复制代码代码如下:FragmentManager fragmentManager =getFragmentManager();FragmentTransaction fragmentTransaction =fragmentManager.beginTransaction();每一个事务都是同时要执行的一套变化。可以在一个给定的事务中设置你想执行的所有变化,使用诸如 add()、remove()和 replace()。然后, 要给activity应用事务，必须调用 commit()。在调用commit()之前，你可能想调用 addToBackStack()，将事务添加到一个fragment事务的backstack。这个back stack由activity管理， 并允许用户通过按下 BACK按键返回到前一个fragment状态。复制代码代码如下://创建修改实例Fragment newFragment = newExampleFragment();FragmentTransaction transaction =getFragmentManager().beginTransaction();// Replace whatever is in thefragment_container view with this fragment,// and add the transaction to the backstacktransaction.replace(R.id.fragment_container,newFragment);transaction.addToBackStack(null);//提交修改transaction.commit();上面是如何将一个fragment替换为另一个，并在后台堆栈中保留之前的状态。在这个例子中，newFragment替换了当前layout容器中的由R.id.fragment_container标识的fragment。通过调用 addToBackStack()， replace事务被保存到back stack，因此用户可以回退事务，并通过按下BACK按键带回前一个fragment。如果添加多个变化到事务(例如add()或remove())并调用addToBackStack()，然后在你调用commit()之前的所有应用的变化会被作为一个单个事务添加到后台堆栈，BACK按键会将它们一起回退。添加变化到 FragmentTransaction的顺序不重要, 除以下例外:u2022必须最后调用 commit()u2022如果添加多个fragment到同一个容器, 那么添加的顺序决定了它们在view hierarchy中显示的顺序当执行一个移除fragment的事务时， 如果没有调用 addToBackStack()， 那么当事务提交后，那个fragment会被销毁，并且用户不能导航回到它。有鉴于此，当移除一个fragment时，如果调用了addToBackStack()， 那么fragment会被停止，如果用户导航回来，它将会被恢复。另外，对于每一个fragment事务，你可以应用一个事务动画，通过在提交事务之前调用setTransition()实现。调用 commit() 并不立即执行事务。恰恰相反，它将事务安排排期， 一旦准备好，就在activity的UI线程上运行(主线程)。如果有必要， 无论如何，你可以从你的UI线程调用executePendingTransactions()来立即执行由commit()提交的事务。但这么做通常不必要，除非事务是其他线程中的任务的一个从属。警告:你只能在activity保存它的状态(当用户离开activity)之前使用commit()提交事务.3、与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);4、总结最后需要说一下Fragment的例子，Android官方已经提供了Fragment的各种使用的Demo例子，在我们SDK下面的API Demo里面就包含了Fragment的各种使用例子，需要看Demo的朋友，直接看API Demo那个程序就可以了，不用到处去找。里面分开不同功能，实现了不同的类。可以根据需要查看具体代码。

ViewPager中如何获取Fragment　　在做项目时，遇到Fragment与Fragment、Fragment与Activity需要相互通信、传递数据以及进行互　　操作的问题，查阅了官方文档，也实现了官方的例子，但实际项目是ViewPager+Fragment，按官方的例　　子，总是获取不到Fragment的引用，如：　　HeadLinesFragment headLinesFrag = (HeadLinesFragment)　　 getSupportFragmentManager().findFragmentById(R.id.headline_fragment);　　这是因为在ViewPager里Fragment是new出来动态加到ViewPager里的，上需的Id只是Fragment的布　　局文件的根Id，不是Fragment 的Id，故获取的Fragment为空　　查询相关资料后，终于找到如下解决方案：　　一般来讲，我们再使用viewpager的时候，是在代码中动态的添加fragment。此时，我们不能去指定　　fragment的id,也不能指定他的tag,如果你一定要去指定tag,运行时会提示，tag已经被指定。那么，在动　　态的添加了fragment之后，我们如何能获取到该fragment并修改其中的内容呢。两种方法：　　第一种方法实际上是一种hack方法，并没有官方文档说明支持。代码如下：　　SomeFragment someFragment = getSupportFragmentManager().FindFragmentByTag(“android:switcher:” + R.id.viewpager + “:0″);　　if (someFragment != null) //可能没有实例化　　{　　if (someFragment.getView() != null)　　{　　someFragment.updateView();//自定义方法更新　　}　　}　　这里要记住的就是”android:switcher:” + R.id.viewpager + “:0″ 这个字符窜表示的就是该　　fragment的tag，其中0 是fragment 在viewpager中的位置。　　第二种方法更正规，因为第一种方法对基于FragmentPagerAdapter的实现是有效的，但对于　　FragmentStatePagerAdapter就无效了。因为FragmentStatePagerAdapter不会对传给　　FragmentManager的Fragment设置tag.　　ViewPager pager = (ViewPager)findViewById(R.id.viewpager);　　FragmentStatePagerAdapter f = pager.getAdapter();　　SomeFragment someFragment = (SomeFragment)f.instantiateItem(pager,position);　　instantiateItem(pager,position)方法会返回在position位置的fragment的引用。如果该　　fragment 已经实例化了,再次调用instantiateItem(pager,position)的时候，该方法并不会调用　　getItem()来再次实例化fragment，而是直接返回引用。　　方法三更简单：　　Activity里的语句：　　mPagerAdapter = new DownloadSlidePagerAdapter(getSupportFragmentManager());　　LocalVideoListFragment fragment = ((LocalVideoListFragment)mPagerAdapter.getItem(mCurrItem));　　fragment.refresh();　　DownloadSlidePagerAdapter：　　public class DownloadSlidePagerAdapter extends FragmentPagerAdapter {　　Fragment[] fragments = {new DownloadListFragment(),new LocalVideoListFragment()};　　public DownloadSlidePagerAdapter(FragmentManager fm) {　　super(fm);　　}　　@Override　　public Fragment getItem(int position) {　　return fragments[position];　　}　　@Override　　public int getCount() {　　return fragments.length;　　}　　}　　直接获取new的实例对象应用

在onCreate 方法中先把第一个fragment先装进去,后面每次点相应的RadioButton就用transaction.replace方法来装另一个fragment,具体代码如下:public class MainActivity extends Activity {private FragmentTransaction transaction;//这是三个fragmentprivate Homefragment mHomeFragment;private Mintaofragment mMinTaoFragment;private Servicefragment mServicefragment;private RadioGroup mMainRadioGroup;public View mMainView;@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main1);mMainView = new View(this);transaction = getFragmentManager().beginTransaction();mHomeFragment = new Homefragment();transaction.add(android.R.id.tabcontent, mHomeFragment);transaction.commit();mMainRadioGroup = (RadioGroup) findViewById(R.id.radiogroup);mMainRadioGroup.setOnCheckedChangeListener(checkedChangeListener);}private OnCheckedChangeListener checkedChangeListener = new OnCheckedChangeListener() {@Overridepublic void onCheckedChanged(RadioGroup group, int checkedId) {switch (checkedId) {case R.id.radio_home:if (null == mHomeFragment) {mHomeFragment = new Homefragment();}replaceFragment(mHomeFragment);break;case R.id.radio_mintao:if (null == mMinTaoFragment) {mMinTaoFragment = new Mintaofragment();}replaceFragment(mMinTaoFragment);break;case R.id.radio_service:if (null == mServicefragment) {mServicefragment = new Servicefragment();}replaceFragment(mServicefragment);break;default:break;}}};public void replaceFragment(Fragment fragment) {transaction = getFragmentManager().beginTransaction();transaction.replace(android.R.id.tabcontent, fragment);// Commit the transactiontransaction.commit();}}

将旧的fragment从栈中移除并替换为新的fragment！

1. replace方式transaction.replace(R.id.content, IndexFragment);2. add－hide－show方式transaction.add(R.id.content, IndexFragment); transaction.hide(otherfragment); transaction.show(thisfragment);而上面按钮中出现bug的就是采用第二种方式。然后我们来分析下用add，hide，show为什么出现这种bug，我把每个操作都打印出了以下日志：复现bug的操作是：1.首先打开，默认选中的是第一个tab，如上面的一张图片正常那样。2.切换到tab2，并把tab1 hide掉；3.再切回到tab1，并不会触发tab1对应fragment的任何生命周期；4.然后home键进入后台，我在activity的onPause()中手动对IndexFragment赋空，模拟长时间后台，系统销毁了该引用。

就是正常的ip协议。根据mtu来决定分片与否

FRAGMENT ["fr??gm??nt] n. 碎片,破片,断片[计算机] 碎片词形变化:动词过去式:fragmented 过去分词:fragmented 现在分词:fragmenting 第三人称单数:fragments

防护级别设置到最高，把IP加入黑名单试试。

无领导者产业（Fragmented Industry） 无领导者产业是指在从事相同 产品 或服务生产的众多 公司 当中， 缺乏一个单一、有主导力的竞争者或 市场 （market）领先者。

就是ip协议的处理方式,对大的ip包分段指的不是IP 的分片,IP分片在wireshark 里用―Fragmented IP protocol‖来...(tcp 重传) 作为一个可靠的传输协议,传输控制协议(TCP)在发送主机需要从...

fragmented形容词（使）分裂fragmentation名词裂成碎片fragment的中文翻译fragment名词n.[C]1.碎片,破片;断片Theglassfelltothefloorandbrokeintofragments.玻璃杯落在地上碎成破片。2.(文艺作品等的)未完成部分及物动词vt.1.使成碎片不及物动词vi.1.成碎片Thebowlfellandfragmentedintobits.碗掉下,摔成碎片。

做事情没条理的

vlone与fragment design这两个品牌最近又推出了一系列联名服装，这个系列的衣服都设计的非常酷，以暗黑风格为主，上身非常好看。下面跟我一起来看看vlone与fragment design联名系列服装怎么样？VLONE x Fragment Design好看吗？VLONE x Fragment Design系列款式有哪些？ 联名系列服装 VLONE官网今日无再度无预警推出与藤原浩和 fragment design 的联名系列。当中包括分别采用皮革和帆布制作的 Parka、Bomber 外套、拉链衬衫、连身服以及 Tote Bag 等多款新上架或是再度补货的单品。而橙色的「V」字和「闪电」Logo 设计依旧是最大的亮点。A$AP ROCKY频频上身之后，还是犹如HBA、PYREX一样在潮流圈迅速蹿红，之后各大潮咖侃爷、Wiz Khalifa等等都在公开场合上身VLONE,ROCKY的死党好兄弟EDC也不例外，在他的3125C pop up store开业时上身的就是VLONE。VLONE是什么 由美国知名 Hip Hop 单位A$AP Mob 的成员 A$AP Rocky、A$AP Bari 所筹办的时尚街头品牌 VLONE，品牌口号“Live Vlone，DieVlone”，也是秉承A$AP精神,其设计上兼具街头与高端时装的轮廓及美学概念。在06年，A$AP Yams、A$AP Bari 和 A$AP Illz 一同创立了 A$AP Mob团体 ，之后随著 A$AP Rocky 与 A$AP Ferg 等人加入而越来越被人所熟知。音乐、毒品、潮流、金钱这几个名词充斥着每一个A$AP MOB成员的生活，他们中有毒贩，有滑板手，有DJ,有Rapper，他们在音乐领域和时尚潮流领域绝对是所向披靡，而这其中名气最大的就属 A$AP Rocky 了!A$AP Rocky给我们的第一印象肯定是说唱，毕竟他是A$AP Mob的头牌，也是如今说唱界最炙手可热的人物!8岁就开始尝试着说唱，各种BEAT!在2011年， A$AP Rocky的“Peso”MV走红，之后便一发不可收拾! A$AP Mob也随着Rocky的爆发有了更高的知名度!FD品牌介绍 Fragment Design由日本潮流教父藤原浩(Hiroshi Fujiwara)创办。虽然Fragment Design双闪电的名气非常之大，但是相关背景资料也是相当稀缺。只知道FragmentDesign运作在一个小型工作室当中，却运营着庞大的国际事务在当中。Fragment Design除了藤原浩(Hiroshi Fujiwara)，还有仓石一树(Kazuki Kuraishi)也是其成员之一。Fragment Design作为一间顶尖设计公司，其设计的范围相当广泛，由产品小饰物到家居用品乃至艺术创作均可见到Fragment Design的踪影。其Fragment Design在街头潮流里面的地位最为引人注目。藤原搅作多多, 不时现身于大小杂志, 做专访, 当 Model, 或撰稿. 在 Men"s Nonno 便有每期必看的《a little knowledge》。 藤原浩潮流教父地位多年屹立不倒，由他设计的Fragment design 、Head Porter、Burton iDiom等品牌人气更不断上升。

the program is a fragment该程序是一个片段

最近公司项目里面有一些弹出的页面，采用了DialogFragment的方式，但是经常在调用Dismiss的时候会报错 Can not perform this action after onSaveInstanceState 网上找了很多都是说把commit()方法替换成 commitAllowingStateLoss() 还有说用反射重写show()方法，目的也是为了把show()方法中的commit()方法替换成 commitAllowingStateLoss() 具体如下： @Override public void show(FragmentManager manager, String tag) { // super.show(manager, tag); try { Class c = Class.forName("android.support.v4.app.DialogFragment"); Constructor con = c.getConstructor(); Object obj = con.newInstance(); Field dismissed = c.getDeclaredField("mDismissed"); dismissed.setAccessible(true); dismissed.set(obj, false); Field shownByMe = c.getDeclaredField("mShownByMe"); shownByMe.setAccessible(true); shownByMe.set(obj, false); } catch (Exception e) { e.printStackTrace(); } FragmentTransaction ft = manager.beginTransaction(); ft.add(this, tag); ft.commitAllowingStateLoss(); } 但是还是不行，这时候我发现弄错了问题所在，这里是在dissmiss()时报错的，我改show()方法有啥用。 然后翻看dissmiss()的源码发现，它其实调用的是this.dismissInternal(false); void dismissInternal(boolean allowStateLoss) { if (!this.mDismissed) { this.mDismissed = true; this.mShownByMe = false; if (this.mDialog != null) { this.mDialog.dismiss(); } 在这里看到了熟悉的commitAllowingStateLoss()和commit()，是通过allowStateLoss来判断调用哪个，很显然，问题的关键就再allowStateLoss这个参数。 然后又找到了领一个方法dismissAllowingStateLoss()，把用到dissmiss的地方，换成它就好了

Explore: travel in or through (an unfamiliar country or area) in order to learn about or familiarize oneself with it.Ancient: belonging to the very distant past and no longer in existence.Prosperous: successful in material terms; flourishing financially.Storey: floor, levelBeneath: extending or directly underneath, typically with close contact.;at a lower level or layer than.Fragment: a small part broken or separated off something.Remains: the parts left over after other parts have been removed, used, or destroyed.资料来源：字典

　　最近开发的一个应用，使用SlidingMenu作为侧边菜单，主要内容全部使用Fragment，并且使用FragmentManager管理。　　我在其中一个Fragment中使用了一个ViewPager，每个ViewPager中亦是一个Fragment。形成一个嵌套。　　今天碰到一个问题，我要给ViewPager所在的Fragment应用一个主题theme，因为这个Fragment使用了ViewpagerIndicator，我要给其中的TabPageIndicator定制我想要的外观。而看了Demo之后，发现最简单的定制外观的方式就是通过Theme。但是Fragment不是Activity，无法直接在AndroidManifest.xml中写theme，于是在网上苦找Fragment应用Theme的方法，最后终于让我找到了，关键代码是这样的：　　Java　　　　//使用ContextThemeWrapper通过目标Theme生成一个新的Context　　Context ctxWithTheme = new ContextThemeWrapper(　　getActivity().getApplicationContext(),　　R.style.Theme_PageIndicatorDefaults);　　　　//通过生成的Context创建一个LayoutInflater　　LayoutInflater localLayoutInflater = inflater.cloneInContext(ctxWithTheme);　　　　//使用生成的LayoutInflater创建View　　ViewGroup rootView = (ViewGroup)localLayoutInflater.inflate(　　R.layout.fragment_programs_center, null, false);　　　　得到的rootView就是所需要的View了，这段代码放在onCreateView中就可以了。

fragment voltage片段电压

我觉得这是有点奇怪的说法。关键不在Vertex Shader到底在做什麼，而是要搞清楚他处理的对象是甚麼。如果你要操作的是每个顶点的东西，那要用Vertex Shader，一旦经过光栅化後，位置固定而且变成片元(不一定是最终像素，所以叫做Fragment)，你在Fragment Shader就是操作这些东西。(虽然後者是可以改变片元的深度值)不然你也可以在Fragment Shader里面变换法向量的，只是在Vertex Shader里面就先变换好法向量後，再利用硬体去插值会比较快。所以话再说回来，我认为你应该要重新看下绘图管线。从Programmable Pipeline重新认知下，或许才可以真正解决你的问题。

fragment标签,是告诉Activity,这里放一个fragment(Activity就会去实例化这个Fragemtn)include是告诉编译器,这里导入一个布局(相当于把目标文件复制到这里来)

fragmentn.碎片；片段v.使破碎；分裂fragmentize（只可以当v。）vt. 使 ... 裂成碎片； 使 ... 分裂

在activity中开启fragment时，FragmentTransaction在add（）或replace（）之前，调用setCustomAnimations（）来实现fragment转场动画； setCustomAnimations()方法还有一个两个参数的重载方法可以使用； 该方法需要在资源文件res/anim下添加转场动画，如下： 注意:1.该方法一定要在add或replace之前调用，否则无效；2.setCustomAnimations方法有一个很大的bug，就是在内存重启后所有设置的动画都将失效。 setTranseion是FragmentTransaction的方法，而onCreateAnimation是Fragment的方法，一般两个方法需要配合使用。而且它们不会像setCustomAnimations一样，即使是内存重启也不会失效，因为他们是动态调用的。 先来看一下setTranseion方法： 很明显，要实现动画，我们只能传TRANSIT_FRAGMENT_OPEN和TRANSIT_FRAGMENT_CLOSE，他们分别表示进场和退场，首先使用FragmentTransaction设置Transeion： 单独使用setTranseion的话，FragmentManager会生成默认的动画；源码如下： setTranseion和和Fragment的onCreateAnimation配合使用： transit对应FragmentTransaction设置的动作，onCreateAnimation在Fragment的每个操作动作中都会被回调，最好是配合FragmentTransaction的setTranseion方法使用，才能更加灵活的实现各种动画，不然onCreateAnimation方法的transit参数永远是0，而nextAnim与setCustomAnimations有关，而一般不推荐使用setCustomAnimations。

你的Activity里面注册过fragment吗？像这样========》private void InitViewPager() { mPager = (ViewPager) findViewById(R.id.vPager); fragmentsList = new ArrayList<Fragment>(); Fragment activityfragment = TestFragment.newInstance("Hello Activity."); Fragment groupFragment = TestFragment.newInstance("Hello Group."); Fragment friendsFragment=TestFragment.newInstance("Hello Friends."); Fragment chatFragment=TestFragment.newInstance("Hello Chat."); fragmentsList.add(activityfragment); fragmentsList.add(groupFragment); fragmentsList.add(friendsFragment); fragmentsList.add(chatFragment); mPager.setAdapter(new MyFragmentPagerAdapter(getSupportFragmentManager(), fragmentsList)); mPager.setCurrentItem(0); mPager.setOnPageChangeListener(new MyOnPageChangeListener()); }

TabLayout+ViewPager+Fragment是我们开发常用的组合。ViewPager的默认机制就是把全部的Fragment都加载出来，而为了保障一些用户体验，我们使用懒加载的Fragment，就是让我们再用户可见这个Fragment之后才处理业务逻辑。 而我们在一些设备或版本中可能就出现懒加载失效的问题。其实谷歌早就把一些懒加载的方案都标记弃用了，我们一直都用的老的随时会失效的Api。万一哪天彻底失效了就会导致线上事故。 接下来我们就看看Fragment的懒加载是如何演变的。谷歌又是推荐我们如何使用的。 在AndroidX还没出来的时候，大家的懒加载应该都是这样。判断setUserVisibleHint的方法，当用户可见的时候才回调方法去加载逻辑。 例如的我封装： 使用的示例： 扩展方法： Fragment: 到此就实现了onLazyInitData的回调，只有出现Fragment显示在前台的时候才会调用方法，执行逻辑。 每次判断 setUserVisibleHint 和 onHiddenChanged 也麻烦，并且他们并不稳定，我也遇到过不回调的时候。 Android出来之后，给 FragmentStatePagerAdapter 添加了一个 @Behavior int behavior 的参数。 其本质就是内部帮你处理和切换MaxLifecycle： 如何使用呢： 之前的扩展方法以及预留了 behavior 参数，当为1的时候就不会回调 setUserVisibleHint 方法了，我们直接监听 OnResume 即可。 注意这个页面继承的就不是我们自定义的懒加载Fragment了。普通的Fragment 回调 onResume 即可。 ViewPager2出来之后。我们的 FragmentStatePagerAdapter 退出历史舞台。 即便能用，即便效果还是和ViewPage2的效果一样，但是还是标记废弃了。具体原因我也不知道，据说是因为老版本会出现问题导致数据丢失，页面空白。 ViewPage2我们都知道内部是通过RV实现的。但是对于Fragment的处理有单独的Adapter实现。 扩展方法： 使用： 使用的方式和ViewPager差不多，这里的Fragment也是使用普通的Fragment即可。 内存占用分别取三组数据 ViewPager数据 ViewPager2数据 结论 ViewPager2基于RV实现的效果还是比老版ViewPager要骚好一点。 并且老版本标记废弃，大家如果是用ViewPager2的话，还是推荐使用ViewPager2实现。如果大家还是用的老版本的ViewPager也推荐使用behavor参数。使用 onResume 实现懒加载的实现。以后再换到ViewPager2的话，可以无缝切换过来。 说明一下，测试数据仅供参考，毕竟我也不是专业测试，测试数据源也不不多。如有不对的地方，也望大家指正。

1. 为什么要引入Fragment？ u2003u2003引入Fragment是出于大屏幕的平板电脑的需要，使用Fragment可以在同一个activity中显示两个或多个Fragment，这些Fragment都属于一个Activity。Fragment必须被“嵌入”到activity中使用，因此Fragment虽然有自己的生命周期，但它的生命周期会受到所在的Activity的限制。 2. Activity与Fragment生命周期的关系？ Activity的OnCreate() | Fragment的onAttach(Activityactivity)，其中Activity就是它所依附的Activity | Fragment的onCreate() | Fragment的onCreateView(LayoutInflaterinflater, ViewGroup container, BundlesavedInstanceState) | Fragment的onActivityCreated() | Activity的onResume() | Fragment的onResume() | Fragment的onPause() | Activity的onPause() | Fragment的onDestroy() | Fragment的onDetach() | Activity的onDestroy() 3. 在Activity如何中使用Fragment？ 直接在Activity的layout布局文件中定义： res/layout/activity_main.xml 4. Fragment如何向Activity传递数据？ u2003u2003一般是先在Fragment中定义一个接口，用于回调。然后让他所在的Activity实现这个接口。举个例子： MainActivity.java 5. 那么这个叫FragmentDemos的framgent如何去获取参数呢？ 是在onCreate()中使用getArguments()获取bundle参数。 FragmentDemos.java

使用 MVPArms 开发也有一段时间了，首先感谢 作者 的无私奉献和分享！在此记录一下 Fragment 使用过程中遇到的问题和解决方案。 Activity 和 Fragment 的生命周期如下： <div align=center> <div align=center> </div> <div align=center> </div> MVPArms 框架对 Activity 和 Fragment 的生命周期进行了很好的封装。 通过 ActivityDelegate 代理 Activity 的生命周期(具体实现为 ActivityDelegateImpl )，通过 FragmentDelegate 代理 Fragment 的生命周期(具体实现为 FragmentDelegateImpl )； 然后在 ActivityLifecycle 实现了 Application.ActivityLifecycleCallbacks 接口，内部类 FragmentLifecycle 实现了 FragmentManager.FragmentLifecycleCallbacks 抽象类； 并将 ActivityLifecycle 注入到 BaseApplication 中，注入过程是通过 AppDelegate 来代理 Application 的生命周期完成的。 为此作者还专门通过 一篇文章 介绍思想，收获颇多。 Application.ActivityLifecycleCallbacks 接口定义如下： FragmentManager.FragmentLifecycleCallbacks 抽象类定义如下： MainActivity 有三个 Fragment，分别是 HomeFragment ， DashboardFragment ， NotificationsFragment 。 MainActivity 控制 Fragment 的切换，其中 HomeFragment 是主页。 使用 ARouter 控制 Fragment 的切换。 设置 MainActivity 的启动模式为 singleTask ，在 AndroidManifest.xml 中为 MainActivity 添加以下属性： MainActivity 的布局文件包含了一个 FramLayout，用来动态添加 Fragment；还包含了一个 BottomNavigationView，在 Activity 中控制 Fragment 的切换。 MainActivity 中有一个 List 用来存储 Fragment，根据每个 Fragment 在 List 中的索引切换 Fragment。此处的切换方式使用的是 hide/show 的方式，当 Fragment 需要频繁切换的时候，这样做比 replace 的方式更有效率。 每个 Fragment 的布局文件都有两个 Button，用来在一个 Fragment 切换至其他的 Fragment。 具体实现方式是由 ARouter 先跳转到 Activity，然后由 Activity 控制 Fragment 的切换。 在 Fragment 通过 ARouter 跳转到 Activity，会触发 Activity 的 onNewIntent(Intent intent) 方法回调，所以在 onNewIntent 处理ARouter 携带的要切换的目标 Fragment 的索引，然后通过 BottomNavigationView 的 OnNavigationItemSelectedListener 控制切换 Fragment，同时设置 Toolbar 的 Title。从而完成从一个 Fragment 切换至其他的 Fragment。 由于同一个 Activity 与三个 Fragment 的生命周期同步，所以当 Activity 在 onResume 状态下，三个 Fragment 也在同时 onResume，使用 hide/show 的方式切换 Fragment 无法刷新 Fragment 的状态。这时候 onHiddenChanged(boolean hidden) 方法就派上用场了，可以在 Fragment 中重写此方法来处理刷新等逻辑。 当设备旋转或者 Activity 长期处于后台而被系统回收，Activity 的会经历销毁->重建的过程。但是我们可以保存 Fragment，当 Activity 重建时继续使用已经存在的 Fragment 实例，避免浪费系统资源。 利用系统 API 提供的 Fragment#setRetainInstance(boolean retain) 方法来保存 Fragment 实例，在 GlobalConfiguration 的 FragmentLifecycleCallbacks 回调方法里设为 true。 因为 FargmentManager 在 Activity 重建时会自动恢复，所以可以在添加 Fragment 时设置 tag，然后通过 FragmentManager#findFragmentByTag(String tag) 获取 FragmentManager 中已存在的 Fragment 实例。 这里使用了 FragmentUtils 工具类处理 Fragment。 在 Activity 的 onSaveInstanceState(Bundle outState) 保存当前 Fragment 索引： 在 Activity 的 initData(Bundle savedInstanceState) 恢复原来 Fragment 索引： 在 Activity 中持有 各个 Fragment 实例，MVPArms 的 IFragment 接口提供一个 setData(Object data) 方法，可以将通信数据传递给目标 Fragment： 然后在 Fragment 中重写 setData() 方法接收消息，根据消息做一些事情： 使用 ARouter 将 通信数据携带发送给 Activity，然后在 Activity 的 onNewIntent(Intent intent) 接收处理。 Fragment 之间的通信可以通过 Fragment 先与 Activity 通信，然后由 Activity 传递给目标 Fragment。例如上面的通过按钮切换 Fragment 就是一个例子。通过 ARouter 来实现。 Activity 也可以在布局文件里直接使用 <fragment> 标签来静态加载 Fragment。 <fragment> 中的 android:name 属性指定要在布局中实例化的 Fragment 类。 当系统创建此 Activity 布局时，会实例化在布局中指定的每个片段，并为每个片段调用 onCreateView() 方法，以检索每个片段的布局。系统会直接插入片段返回的 View 来替代 <fragment> 元素。 用法如下： 欢迎 star 和 issue： 我是 xiaobailong24 ，您可以通过以下平台找到我：

fragment是运行在Activity中的,加载布局需要用到Context的API。 1.Fragment是android3.0引入的新控件，果应用使用在3.0以下、1.6及以上的版本，需要引入v4包。 2.Fragment支持在不同的Activity中使用并且可以处理自己的输入事件以及生命周期方

话说 。。。这种问题你不知道查字典啊 有道词典神马的查起来都很方便啊。。。例句也有很多

在使用fragment时首先要知道fragment的生命周期，我们能在生命周期方法中做什么操作onAttch（Activity activity）:这个方法是在fragment与activity关联之后调用，我们能在这个方法中获取这个关联的activity的实例。但是当你的sdk更新到android6.0（api-23）是就会显示这个方法是过时的，使用onAttach（Context context）这个方法代替，但在看fragment的生命周期时，这个方法好像不调用，所以你获取的Context是nullonCreate:这个方法是在fragment初始化的时候调用，我们通常在这个方法中使用getArgument获取activity传来的初始化fragment的参数。 注意：在 这个方法中我们不能获取activity中的控件，下面的这段代码是在fragment的onCreate中的，你发现activity不是空，但是text是null。因为，这是activity的onCreate还没有执行完，即activity还没有创建完，要想获取activity相关的资源应该在onActivityCreated中获取。[java] view plain copyMainActivity activity=(MainActivity) getActivity();//activity不是null TextView text=activity.findViewById(R.id.textview);//text是null onCreateView：这个方法中我们主要是通过布局填充器获取fragment布局。我们在这个方法中通过view.findViewById初始化fragment中的控件，[java] view plain copy@Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { view=inflater.inflate(R.layout.text_content, null);//获取布局 text=(TextView) view.findViewById(R.id.textview);//初始化fragment的控件 return view; } onActivityCreated：这个方法是在activity的onCreate方法执行完执行这个方法，通知fragment，关联的activity的onCreate方法执行完了，即activity创建完了，可以在这个方法中获取activity中的资源。例如下面，可以获取activity布局中的TextView控件[java] view plain copy@Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); TextView text=getActivity().findViewById(R.id.textview);//获取activity布局中的TextView控件 } onStart：这个是在activity的onstart执行完立即执行，这个方法执行完fragment界面就显示出来了，但是现在还没有获取焦点，用户是不能操作。onResume：这个方法是在activity的onResume方法执行完立即执行，此时fragment的获取了界面，用户可以操作。onPause:fragment失去焦点，此时用户是不能操作的，执行完立即执行activity的onPause方法。onStop:fragment不可见，执行完立即执行activity的onStop方法。onDestroyView:在onCreateView中创建的fragment视图会被销毁。Fragment的视图被回收。onDestroy：当这个fragment不再使用时调用。需要注意的是，它即使经过了onDestroy()阶段，但仍然能从Activity中找到，因为它还没有DetachonDetach:fragment与activity解除关联，fragment的所有的资源都被回收。

一、第一种方法：(1)Fragment的第一种使用方法是使用fragment加载单独的布局文件：(也就是xml的方式实现)activity_main.xml主要是在一个线性布局中添加两个线性布局< "http://www.codingke.com" target="_blank" class="keylink">vcD4KPHA+PHByZSBjbGFzcz0="brush:java;">right.xml是等会使用fragment的时候，加载的一个布局文件：(由于主要是在界面中加载、所以不作特殊要求)MyFragment.java就是加载fragment的类，要继承Fragment类：(要重载父类的下边三个方法)二、第二种方法项目结构和上图中的差不多:只是在布局文件中，直接使用fragment控件。在myfragment.java文件中，只需找到fragment所容纳的布局文件即可，不进行业务上的操作。MainActivity.java文件：进行fragment的业务处理，想了解更多请关注扣丁学堂。

Fragment是到Android3.0+ 以后，Android新增了Fragments，在没有 Fragment 之前，一个屏幕只能放一个 Activity。这是一个起源时间大家要知道是什么时候开始引入的。.Activity 代表了一个屏幕的主体,而Fragment可以作为Activity的一个组成元素。一个Activity可以有若干个（0或n）Fragment构成。你可以把Fragment想象成Activity中的一个控件，只不过相对于一般控件，Fragment与Activity联系更为紧密，随着Activity的生命周期变化，Fragment也随之相应不同的生命周期函数。Fragment 从功能上讲相当于一个子活动（Activity），它可以让多个活动放到同一个屏幕上，也就是对用户界面和功能的重用，因为对于大屏设备来说，纯粹的 Activity 有些力不从心。Fragment 像是一个子活动，但是 Fragment 不是 Activity 的扩展，因为 Fragment 扩展自 android.app 中的 Object，而 Activity 是 Context 的子类。Fragment 有自己的视图层级结构，有自己的活动周期，还可以像活动一样响应后退按钮，Fragment 还有一个用作其初始化参数的包（Bundle），类似 Activity，Fragment 也可由系统自动保存并在以后还原。当系统还原 Fragment 时，它调用默认的构造函数（没有参数），然后将此Bundle还原到新创建的 Fragment 中，所以无论新建还是还原 Fragment，都要经过两个步骤：(1)调用默认构造函数(2)传入新的或者保存起来的Bundle。一个Activity可以运行多个 Fragment，Fragment 切换时，由 FragmentTransaction 执行，切换时，上一个 Fragment 可以保存在后退栈中（Back Stack），这里的后退栈由 FragmentManager 来管理，注意 Fragment 和 Activity 的后退栈是有区别的：Activity 的后退栈由系统管理，而 Fragment 的后退栈由所在的Activity 管理。Fragment不能脱离Activity而存在，只有Activity才能作为接收intent的载体。其实两者基本上是载体和组成元素的关系。

1、首先，新建 FragmentTest.java 类继承 fragment 2、创建fragment中的布局 fragment_test.xml 3、创建activity中的布局 activity_main.xml 注意，这里的fragment控件一定要加 android:id="@+id/fragment_test" 不然会报异常 android.view.InflateException: Binary XML file line #13: Binary XML file line #13: Error inflating class fragment 4、创建MainActivity.java 动态加载fragment的静态加载fragment的一、二步相同。从第三步开始。 3、创建activity_main.xml Framelayout 是一个用来存放 Fragment 的容器 3、创建MainActivity.java类

同义词：shardsherdan incomplete piece"fragments of a play"v.break or cause to break into pieces"The plate fragmented"同义词：break upfragmentizefragmentise

名词，碎片的意思。比如玻璃杯打碎为碎片。

是Activity底层的方法去调用的，用户只需要知道Activity的生命同期即可，不需要去了解底层的机制。以下是activity的生命周期：1.启动Activity：系统会先调用onCreate方法，然后调用onStart方法，最后调用onResume，Activity进入运行状态。2.当前Activity被其他Activity覆盖其上或被锁屏：系统会调用onPause方法，暂停当前Activity的执行。3.当前Activity由被覆盖状态回到前台或解锁屏：系统会调用onResume方法，再次进入运行状态。4.当前Activity转到新的Activity界面或按Home键回到主屏，自身退居后台：系统会先调用onPause方法，然后调用onStop方法，进入停滞状态。5.用户后退回到此Activity：系统会先调用onRestart方法，然后调用onStart方法，最后调用onResume方法，再次进入运行状态。6.当前Activity处于被覆盖状态或者后台不可见状态，即第2步和第4步，系统内存不足，杀死当前Activity，而后用户退回当前Activity：再次调用onCreate方法、onStart方法、onResume方法，进入运行状态。7.用户退出当前Activity：系统先调用onPause方法，然后调用onStop方法，最后调用onDestory方法，结束当前Activity。

Fragment都是运行在某个Activity中的例如你的MainActivity new 了三个Fragment在Fragment中调用getActivity() 就返回了这个Activity你可以强转成你的MainActivity之后调用MainActivity中的方法去设置转跳就好了不明白就留下Q,

1.Fragment是android3.0引入的新控件，果应用使用在3.0以下、1.6及以上的版本，需要引入v4包。2.Fragment支持在不同的Activity中使用并且可以处理自己的输入事件以及生命周期方法等。3.Fr期方法依赖于Activity的生命周期，例如一个Activity的onPause()的生命周期方法被调用的时候这个Activity中的所有的Fragment的onPause()方法也将被调用。4.FragmentManager提供了对Activity运行时的Fragment的添加、删除、替换的操作。在Activity运行期间可以添加Fragment而不是在XML布局文件中进行定义。如果打算在Activity中改变Fragment的生命过程。如果要执行添加、删除、修改的操作，必须通过FragmentManager的对象获得一个FragmentTransaction对象，通过它的API来执行这些操作。5.两个单独的Fragment之间是不应该进行通信的。应该使用他们所存在的Activity作为沟通的纽带。

使用Fragment的ActivityMainActivity类要继承FragmentActivity，因为在下面getSupportFragmentManager要用到public class MainActivity extends FragmentActivity { public Button btn_search; Fragment_Search dialogFragment; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); btn_search = (Button) findViewById(R.id.btn_search); btn_search.setOnClickListener(new OnClickListener() { @Override public void onClick(View arg0) { showSearchDialog(); } }); } protected void showSearchDialog() { // Create and show the dialog. if(dialogFragment == null) dialogFragment = new Fragment_Search(); dialogFragment.setStyle(DialogFragment.STYLE_NO_TITLE, 0); dialogFragment.show(getSupportFragmentManager(), "dialog"); }}

TabActivity或ActivityGroup的每一个子Activity可是都应该有一个独立的后退栈的哦，然后每一个子Activity可以在管理一系列的Fragment。比如楼主说的ABC三个碎片就可以放到第一个子Activity的后退栈保存。遇到了同样的问题，也可以在中间部分的Fragment中把最后的Fragment结束掉。

歌曲名:Fragment歌手:theatre of tragedy专辑:MusiqueFragmentTheatre of TragedyBroken framesShattered glassLike a monochrome filmThe replaceable backgroundFlickers and dissolvesOut of controlThere"s no sense, it"s all Volta, Ampre and OhmEarth to Moon, it"s the same as London-RomeThere"s no sense, it"s all Volta, Ampre and OhmEarth to Moon, it"s the same as London-RomeOut of focus, blurred imageAs solid as a liquid monumentA second of lifeThe time-frame of "69Technology, machinery, humanityIt"s all the sameThere"s no sense, it"s all Volta, Ampre and OhmEarth to Moon, it"s the same as London-RomeThere"s no sense, it"s all Volta, Ampre and OhmEarth to Moon, it"s the same as London-RomeTime and age, what"s the differenceBased upon the same referenceTouch-and-go, who"s to know the random orderContorted, distorted it doesn"t make any sense at allA fragment, a segment - bits and pieces, bits and HzAngular, circularIt"s all the sameThere"s no sense, it"s all Volta, Ampre and OhmEarth to Moon, it"s the same as London-Romehttp://music.baidu.com/song/18503996

1.fragment嵌套fragment时出现getActivity()为nullactivity A嵌套fragment B,B嵌套fragment C,C跳转到activity D,当activity D被finish掉之后,C中容易爆出getActivity为空.如果你的activity被回收了,那你需要在bundle中保存一下fragment信息,我的解决方法:fragment实例化之后会到activity的fragmentManager中注册一下,这个动作封装在fragment中的onAttach(Activity activity)方法中,可以直接在onAttach(Activity activity)方法中去赋值2.fragment嵌套fragment时没有执行子fragment的onActivityResult方法activity A嵌套fragment B,B嵌套fragment C,C通过startActivityForResult跳转到activity D,当activity D被finish掉之后,没有执行C的onActivityResult其实这个问题也不是每个人都会遇到,当activity A和Fragment B不重写onActivityResult方法,可能就不会出现这个问题,但是我的activity A重写了onActivityResult方法,所以当activity D被销毁的时候,直接去执行activity 的onActivityResult,其实这个问题也很简单,只是遇到的时候可能想不到,解决方案就是在Activity中的onActivityResult方法中加入super.onActivityResult(requestCode, resultCode, data);一切都ok了Activity的onActivityResult方法:protected void onActivityResult(int requestCode, int resultCode, Intent data) {super.onActivityResult(requestCode, resultCode, data);fragment的onActivityResult方法:public void onActivityResult(int requestCode, int resultCode, Intent data) {

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一样

你把参数传递到另一个Activity，在intent中指明要传给哪几个Fragment，由Activity再将参数传给你指定的Fragment

可以通过getActivity()来得到FragmentActivity对象，但是建议不要在Fragment中去操作FragmentActivity的东西，建议在FragmentActivity中封装一些方法。1.Fragment是android3.0引入的新控件，果应用使用在3.0以下、1.6及以上的版本，需要引入v4包。2.Fragment支持在不同的Activity中使用并且可以处理自己的输入事件以及生命周期方法等。3.Fr期方法依赖于Activity的生命周期，例如一个Activity的onPause()的生命周期方法被调用的时候这个Activity中的所有的Fragment的onPause()方法也将被调用。4.FragmentManager提供了对Activity运行时的Fragment的添加、删除、替换的操作。在Activity运行期间可以添加Fragment而不是在XML布局文件中进行定义。如果打算在Activity中改变Fragment的生命过程。如果要执行添加、删除、修改的操作，必须通过FragmentManager的对象获得一个FragmentTransaction对象，通过它的API来执行这些操作。5.两个单独的Fragment之间是不应该进行通信的。应该使用他们所存在的Activity作为沟通的纽带。

1. Fragment是android3.0引入的新控件，果应用使用在3.0以下、1.6及以上的版本，需要引入v4包。 2. Fragment支持在不同的Activity中使用并且可以处理自己的输入事件以及生命周期方法等。 3. Fragment的生命周期方法依赖于Activity的生命周期，例如一个Activity的onPause()的生命周期方法被调用的时候这个Activity中的所有的Fragment的onPause()方法也将被调用。 4. FragmentManager提供了对Activity运行时的Fragment的添加、删除、替换的操作。在Activity运行期间可以添加Fragment而不是在XML布局文件中进行定义。如果打算在Activity中改变Fragment的生命过程。如果要执行添加、删除、修改的操作，必须通过FragmentManager的对象获得一个FragmentTransaction对象，通过它的API来执行这些操作。

最近据后台同事反馈说，某些接口调用的频率有点高，而这块业务还没完全开放，照理说很少会用到，于是让我查查怎么回事。 我看了下日志，把网络请求日志过滤出来，发现的确有问题，每次打开首页后都有许多那块业务相关的网络请求。于是马上联想到可能是因为首页改版之后嵌套使用了 ViewPager，业务未完全开放的那个 fragment 里嵌套了一个 ViewPager，里面有多个 fragment，这样每次打开首页都会去加载该 page，然后是一连串的 fragment 初始化以及网络请求，所以为了解决该问题就不得不使用懒加载。 最终想要实现的效果是：1) 当 fragment 不可见的时候不加载数据；2) 当数据已经加载过之后，除非手动刷新否则不重新请求数据。 首先，默认情况下，由于 ViewPager 会预加载左右两边相邻的 至少 1 个 fragment，通过 setOffscreenPageLimit() 设置预加载 page 数为 0 并不会起作用，这点从 ViewPager 的源码中可以看到： 从以上源码可以看出相邻 fragment 的加载是必然的，但是我们如果可以得知 fragment 可见性，那么就可以在 fragment 可见时才去加载数据。这样虽然不是完全的懒加载，只是数据懒加载，但是同样也可以满足我们的需求了。 那么 fragment 中有没有可以获取当前 fragment 是否可见的方法呢，当然是有的，它就是 setUserVisibleHint(boolean isVisibleToUser) 。 无论你使用的是 FragmentPagerAdapter 还是 FragmentStatePagerAdapter，当它们初始化 fragment 的时候，该方法都会被调用两次。 一次是在实例化的时候，也就是在 instantioateItem() 方法中： 一次是在用户滑动到当前 fragment 的时候，在 setPrimaryItem() 方法中： 另外，当用户从当前 fragment 滑出的时候，setPrimaryItem() 方法也会被调用。 来看下 setUserVisibleHint() 的注释： 系统正是通过该方法来判断当前 fragment 的 UI 是否对用户可见，而该方法被暴露出来的主要目的也是让我们可以提醒系统当前 fragment 已经不可见了，是时候重新更新 fragment 的生命周期了。 不过如果只是实现数据懒加载，我们不需要直接去调用该方法，只要覆写它并实现控制数据加载的逻辑就可以了。 这里我参考了一种比较简便的做法，原文来自 尹star 的 ViewPager+Fragment LazyLoad 最优解 。 实现效果： lazy_load_fragment_demo 项目地址： aJIEw/DemoUI-LazyLoadFragment 可以看到只有第一次进入 fragment 的时候才会加载数据，而且也不会主动加载相邻的 fragment 或者已经加载过的数据了。 首先，由于 setUserVisibleHint() 会在 fragment 实例化时就先被调用 (在 onAttach() 之前)，所以我们最好在 view 创建完毕之后加载数据，因此需要设置一个 view 是否初始化完毕的标志位。另外，当然也需要一个 view 是否可见的标志位，只有等到 view 可见才允许加载。然后还可以选择保存数据的初始化状态，这样可以控制在 fragment 生命周期中的合适时机重新加载数据。所以，我们需要以下 3 个标志位： 然后接下来分为两种情况，一种是 view 初始化完毕但是此时还不可见的情况。很显然，我们只要判断 setUserVisibleHint() 中参数的值就可以了： 还有一种情况是，如果当前 fragment 是整个 ViewPager 的第一个 fragment，那么 setUserVisibleHint(true) 会在 view 初始化之前就在 setPrimaryItem() 中被调用，此时 view 已经可见了，但是我们要等到 view 初始化才加载数据，所以我们要在某个地方判断 view 是否已经初始化并且去加载数据。 最好的地方是在 onActivityCreated() 中。根据 fragment 生命周期我们知道，onActivityCreated() 会在 onCreateView() 之后调用，此时 view 已经初始化完毕，我们可以在这里将 isViewInitiated 标记为 true，同时在这里为第一个显示的 fragment 加载数据： 最后，我们还需要判断下数据是否已经加载过，避免重复加载。 我们将以上所有判断逻辑写在 prepareFetchData() 中，判断条件为 view 已经初始化、可见且数据未加载： 最后再定义一个抽象方法 fetchData()，让子类去实现： 这样一个完整的数据懒加载就实现完毕了。 我们可以看下以上操作的日志来验证下我们的想法。 第一次打开，FirstFragment 作为第一个可见的 fragment 立马被初始化： 此时 isVisibleToUser 会在 isViewInitiated 之前设为 true，所以 FirstFragment 会在 onActivityCreated() 中真正开始获取数据。 另外，由于预加载的存在，SecondFragment 也会被创建，但是此时还不可见： 当滑动到 SecondFragment 的时候，SecondFragment 状态变为可见，setUserVisibleHint(true) 被调用，所以开始获取数据： 而此时 FirstFragment 由可见变为不可见： ThirdFragment 则开始第一次被创建，同样此时并不可见： 当滑动到 ThirdFragment 的时候，状态变为可见，所以也就开始获取数据： 此时 SecondFragment 由可见变为不可见： 而 FirstFragment 由于超出了 ViewPager 可以保存的 Fragment 的数量，所以被销毁： 此时 SecondFragment 重新变得可见： 而 FirstFragment 也开始重新被创建： 此时 FirstFragment 重新变得可见，虽然 FirstFragment 之前被销毁了，但是由于之前获取的数据会被恢复，所以现在不会重新去获取数据： 当然我们也可以选择在 onDestroy() 中将 isDataInitiated 置为 false，这样每次 fragment 重新创建都会重新获取数据。当然前提是你使用的是 FragmentStatePagerAdapter ，因为如果使用 FragmentPagerAdapter ，不会每次都调用 onDestroy()，fragment 实例会被保存。而 SecondFragment 再次变得不可见，ThirdFragment 被销毁，过程与 3 中移动到 ThirdFragment 类似，这里就不截图了。 通过以上日志，验证了我们的想法是对的。 另外，如果是 ViewPager 嵌套 ViewPager 其实效果也是一样的，如果不做特殊处理，相邻的 fragment 的会被加载，导致该 fragment 中的 ViewPager 会去加载其中的 fragment。

到的问题：通过FragmentTransaction的replace方法会导致，每次都会重新调用fragment的onCreateView()方法，浪费时间。解决方法：通过FragmentTransaction的hide和show方法来实现fragment的显示和隐藏，这样就不会重复调用onCreateView函数了。FragmentTransactioin 可以用来添加，删除fragment，也可以控制fragment的显示和隐藏。这是如果调用addToBackStack(null)，此时的状态就会被保存在回退栈，按返回键的时候就会显示出栈顶的getSupportFragmentManager().popBackStack() 这个方法可以让栈顶的fragment出栈。只有在程序运行时被动态添加的fragment才会被添加到后退栈。 getSupportFragmentManager().beginTransaction() .add(R.id.fragment_container, newFragment,"testa") .addToBackStack(null) .commit(); 程序跑起来之后，通过这个方法后退栈数才会加一，如果在代码中一口气添加多个，再运行程序，getSupportFragmentManager().getBackStackEntryCount()得到的后退栈数值为零。

Fragment中没有getIntent方法,需要通过Activity来。可以这样实现：Intent intent = getActivity().getIntent();这样就可以在fragment中获取Activity的Intent

凝望蓝色星星张开手的你 温情的笼着我喂~，听到了吧那遥远夏日的企盼 温柔的片段多少次清晨 你都是在我身旁 羞涩的眯起了眼睛这双手中能拥住的只是一点点可永远都感觉 是那么纯真无邪内心深处又不一样啊啊 我能够好好守护你么不安又害怕 可又满怀爱恋我们的声音绽放出比星星还耀眼的光辉喂~，听到了吧那遥远夏日的企盼 温柔的片段雨声中你低下了头泪也流不出来的 咬着嘴唇乞求一样的眼神 一句谎言“我不在乎”颤抖着眼睑背过身不再回头的背影如果能再给些勇气就能相依相偎 紧紧拥抱。。 低声地哭泣天空中万千次眨眼闪烁 编织着小小的希望喂~收到了么 那个遥远夏日企盼的温暖片段我们的声音依然不变绽放出耀眼的光辉喂~ 看得见吧那遥远夏日的企盼 温柔的片段凝望蓝色星星张开手的你 温情的笼着我喂~ 听得到吧那遥远夏日的企盼 温柔的残片此刻 你也在奏响

两个按钮，1和2不要放到fragment里面，放到activity布局中，这样2个按钮都和fragment没关系。这样这2个按钮只有切换的功能了。

当我们在一个viewpager放一个fragment，当切换viewpager当中的viewpager时，fragment的打印输出如下：1.D:Userszhongxw>adb logcat -s debug--------- beginning of /dev/log/main--------- beginning of /dev/log/systemV/debug (17567): onAttachV/debug (17567): onCreateV/debug (17567): oncreateviewV/debug (17567): onActivityCreatedV/debug (17567): onResume切换到别fragment的时打印出：V/debug (17567): onPauseV/debug (17567): onDestroyView注意执行了onDestroyView进行了销毁，而下面的onCreateView也是进行对应的重新愀复时执行：V/debug (17567): oncreateviewV/debug (17567): onActivityCreatedV/debug (17567): onResume再退出：V/debug (17567): onPauseV/debug (17567): onDestroyViewV/debug (17567): onDestroyV/debug (17567): onDetach2.如果是打开退出两种状态的切换：打开：V/debug (17567): onCreateV/debug (17567): oncreateviewV/debug (17567): onActivityCreatedV/debug (17567): onResume退出是：V/debug (17567): onPauseV/debug (17567): onDestroyViewV/debug (17567): onDestroyV/debug (17567): onDetach3.**我们看到都没有执行onPause函数，onPause()多长发生如果点击fragment中的内容时或者这时弹出别的app或者说是activity，跳转到一个新界面，把当前的fragment盖住了，生命周期通常是这样的：D:Userszhongxw>adb logcat -s debug--------- beginning of /dev/log/system--------- beginning of /dev/log/mainV/debug (17567): onPauseV/debug (17567): onResume跳进入是onPause()，恢复时是onResume()4.如果我们fragment已经展示了，我们按home键进入后台，再进入前台，则执行：A。进入后台V/debug (22269): onPauseB,恢复前台V/debug (22269): onResume我们看到这里前没有执行onDestroy()，没有销毁，所以也没有执行onCreateView()进行重绘。跟前面3中所描述的切换到别的activity中是一样的效果。这里我没有打印onStart()跟onStop()函数，，因为onResume以前一定会执行onStart(),在onPause后也会执行onStop()这个函数

　　自从Android 3.0中引入fragments 的概念，根据词海的翻译可以译为:碎片、片段。其目的是为了解决不同屏幕分辩率的动态和灵活UI设计。大屏幕如平板小屏幕如手机，平板电脑的设计使得其有更多的空间来放更多的UI组件，而多出来的空间存放UI使其会产生更多的交互，从而诞生了fragments 。　　fragments 的设计不需要你来亲自管理view hierarchy 的复杂变化，通过将Activity 的布局分散到frament 中，可以在运行时修改activity 的外观，并且由activity 管理的back stack 中保存些变化。当一个片段指定了自身的布局时，它能和其他片段配置成不同的组合，在活动中为不同的屏幕尺寸修改布局配置（小屏幕可能每次显示一个片段，而大屏幕则可以显示两个或更多）。　　Fragment必须被写成可重用的模块。因为fragment有自己的layout，自己进行事件响应，拥有自己的生命周期和行为，所以你可以在多个activity中包含同一个Fragment的不同实例。这对于让你的界面在不同的屏幕尺寸下都能给用户完美的体验尤其重要。　　Fragment优点　　Fragment可以使你能够将activity分离成多个可重用的组件，每个都有它自己的生命周期和UI。　　Fragment可以轻松得创建动态灵活的UI设计，可以适应于不同的屏幕尺寸。从手机到平板电脑。　　Fragment是一个独立的模块,紧紧地与activity绑定在一起。可以运行中动态地移除、加入、交换等。　　Fragment提供一个新的方式让你在不同的安卓设备上统一你的UI。　　Fragment 解决Activity间的切换不流畅，轻量切换。　　Fragment 替代TabActivity做导航，性能更好。　　Fragment 在4.2.版本中新增嵌套fragment使用方法，能够生成更好的界面效果。　　Fragment做局部内容更新更方便，原来为了到达这一点要把多个布局放到一个activity里面，现在可以用多Fragment来代替，只有在需要的时候才加载Fragment，提高性能。　　可以从startActivityForResult中接收到返回结果,但是View不能。　　　　Fragment的生命周期　　你可以把fragment看作是activity的模块化组件，它拥有自己的生命周期　　　　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级支持“返回”键（向后导航）。　　　　显示Fragment时（跟用户交互）要调用的核心的生命周期方法如下：　　1. 把Fragment对象跟Activity关联时，调用onAttach(Activity)方法；　　2. Fragment对象的初始创建时，调用onCreate(Bundle)方法；　　3. onCreateView(LayoutInflater, ViewGroup, Bundle)方法用于创建和返回跟Fragment关联的View对象；　　4. onActivityCreate(Bundle)方法会告诉Fragment对象，它所依附的Activity对象已经完成了Activity.onCreate()方法的执行；　　5. onStart()方法会让Fragment对象显示给用户（在包含该Fragment对象的Activity被启动后）；　　6. onResume()会让Fragment对象跟用户交互（在包含该Fragment对象的Activity被启恢复后）。　　　　Fragment对象不再使用时，要反向回调的方法：　　1. 因为Fragment对象所依附的Activity对象被挂起，或者在Activity中正在执行一个修改Fragment对象的操作，而导致Fragment对象不再跟用户交互时，系统会调用Fragment对象的onPause()方法；　　2. 因为Fragment对象所依附的Activity对象被终止，或者再Activity中正在执行一个修改Fragment对象的操作，而导致Fragment对象不再显示给用户时，系统会调用Fragment对象的onStop()方法。　　3. onDestroyView()方法用于清除跟Fragment中的View对象关联的资源；　　4. Fragment对象的状态被最终清理完成之后，要调用onDestroy()方法；　　5. 在Fragment对象不再跟它依附的Activity关联的时候，onDetach()方法会立即被调用

1.自定义一个类FragmentLeft继承系统的Fragment FragmentLeft的布局 2.再自定义一个FragmentRight继承系统Fragment FragmentRight的布局 3.MainActivity MainActivity布局 在main_activity中注册fragment标签 ==注意：它不是一个控件，它是一个引用型的标签== 1.自定义类FragmentLeft继承Fragment FragmentLeft布局 2.自定义FragmentRight继承Fragment FragmentRight布局 3.MainActivity 在activity_main布局里面添加两个LinearLayout用于放Fragment

Caused by: java.lang.IllegalArgumentException: Binary XML file line #6: Must specify unique android:id, android:tag, or have a parent with an id for com.example.daojie.sample.fragment.LifeCycleFragment这句话意思就是是说你这个必须要有ID或者tag，或者要有一个有ID的父容器吧。

　　使用fragment加载百度地图的方法直接在Fragment中定义BaiduMap即可。1.Fragment是android3.0引入的新控件，果应用使用在3.0以下、1.6及以上的版本，需要引入v4包。2.Fragment支持在不同的Activity中使用并且可以处理自己的输入事件以及生命周期方法等。3.Fr期方法依赖于Activity的生命周期，例如一个Activity的onPause()的生命周期方法被调用的时候这个Activity中的所有的Fragment的onPause()方法也将被调用。4.FragmentManager提供了对Activity运行时的Fragment的添加、删除、替换的操作。在Activity运行期间可以添加Fragment而不是在XML布局文件中进行定义。如果打算在Activity中改变Fragment的生命过程。如果要执行添加、删除、修改的操作，必须通过FragmentManager的对象获得一个FragmentTransaction对象，通过它的API来执行这些操作。5.两个单独的Fragment之间是不应该进行通信的。应该使用他们所存在的Activity作为沟通的纽带。

下列关于Fragment的描述，哪一项是错误的？ A.Fragment拥有完整的生命周期，可以脱离Activity单独运行B.Activity运行时可以动态添加或删除FragmentC.Fragment可以应用多个Activity中D.Fragment可以被用作为非UI交互型的组件正确答案：Fragment拥有完整的生命周期，可以脱离Activity单独运行

自从Android 3.0中引入fragments 的概念，根据词海的翻译可以译为:碎片、片段。其目的是为了解决不同屏幕分辩率的动态和灵活UI设计。大屏幕如平板小屏幕如手机，平板电脑的设计使得其有更多的空间来放更多的UI组件，而多出来的空间存放UI使其会产生更多的交互，从而诞生了fragments 。fragments 的设计不需要你来亲自管理view hierarchy 的复杂变化，通过将Activity 的布局分散到frament 中，可以在运行时修改activity 的外观，并且由activity 管理的back stack 中保存些变化。当一个片段指定了自身的布局时，它能和其他片段配置成不同的组合，在活动中为不同的屏幕尺寸修改布局配置（小屏幕可能每次显示一个片段，而大屏幕则可以显示两个或更多）。Fragment必须被写成可重用的模块。因为fragment有自己的layout，自己进行事件响应，拥有自己的生命周期和行为，所以你可以在多个activity中包含同一个Fragment的不同实例。这对于让你的界面在不同的屏幕尺寸下都能给用户完美的体验尤其重要。Fragment优点Fragment可以使你能够将activity分离成多个可重用的组件，每个都有它自己的生命周期和UI。Fragment可以轻松得创建动态灵活的UI设计，可以适应于不同的屏幕尺寸。从手机到平板电脑。Fragment是一个独立的模块,紧紧地与activity绑定在一起。可以运行中动态地移除、加入、交换等。Fragment提供一个新的方式让你在不同的安卓设备上统一你的UI。Fragment 解决Activity间的切换不流畅，轻量切换。Fragment 替代TabActivity做导航，性能更好。Fragment 在4.2.版本中新增嵌套fragment使用方法，能够生成更好的界面效果。Fragment做局部内容更新更方便，原来为了到达这一点要把多个布局放到一个activity里面，现在可以用多Fragment来代替，只有在需要的时候才加载Fragment，提高性能。可以从startActivityForResult中接收到返回结果,但是View不能。Fragment的生命周期你可以把fragment看作是activity的模块化组件，它拥有自己的生命周期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级支持“返回”键（向后导航）。显示Fragment时（跟用户交互）要调用的核心的生命周期方法如下：1. 把Fragment对象跟Activity关联时，调用onAttach(Activity)方法；2. Fragment对象的初始创建时，调用onCreate(Bundle)方法；3. onCreateView(LayoutInflater, ViewGroup, Bundle)方法用于创建和返回跟Fragment关联的View对象；4. onActivityCreate(Bundle)方法会告诉Fragment对象，它所依附的Activity对象已经完成了Activity.onCreate()方法的执行；5. onStart()方法会让Fragment对象显示给用户（在包含该Fragment对象的Activity被启动后）；6. onResume()会让Fragment对象跟用户交互（在包含该Fragment对象的Activity被启恢复后）。Fragment对象不再使用时，要反向回调的方法：1. 因为Fragment对象所依附的Activity对象被挂起，或者在Activity中正在执行一个修改Fragment对象的操作，而导致Fragment对象不再跟用户交互时，系统会调用Fragment对象的onPause()方法；2. 因为Fragment对象所依附的Activity对象被终止，或者再Activity中正在执行一个修改Fragment对象的操作，而导致Fragment对象不再显示给用户时，系统会调用Fragment对象的onStop()方法。3. onDestroyView()方法用于清除跟Fragment中的View对象关联的资源；4. Fragment对象的状态被最终清理完成之后，要调用onDestroy()方法；5. 在Fragment对象不再跟它依附的Activity关联的时候，onDetach()方法会立即被调用

二、Fragment优点1.Fragment可以使你能够将activity分离成多个可重用的组件，每个都有它自己的生命周期和UI。2.Fragment可以轻松得创建动态灵活的UI设计，可以适应于不同的屏幕尺寸。从手机到平板电脑。3.Fragment是一个独立的模块,紧紧地与activity绑定在一起。可以运行中动态地移除、加入、交换等。4.Fragment提供一个新的方式让你在不同的安卓设备上统一你的UI。5.Fragment 切换流畅，轻量切换。6.Fragment 替代TabActivity做导航，性能更好。7.Fragment 在4.2.版本中新增嵌套fragment使用方法，能够生成更好的界面效果。Fragment做局部内容更新更方便，原来为了到达这一点要把多个布局放到一个activity里面，现在可以用多Fragment来代替，只有在需要的时候才加载Fragment，提高性能。可以从startActivityForResult中接收到返回结果,但是View不能。

碎片是可数名词复数直接加s

没有遇到这种情况，你是在中文官网下载的吗？

fragment 译为碎片，中文谐音 弗瑞艾格门特

　1.fragment嵌套fragment时出现getActivity()为null　　activity A嵌套fragment B,B嵌套fragment C,C跳转到activity D,当activity D被finish掉之后,C中容易爆出getActivity为空.如果你的activity被回收了,那你需要在bundle中保存一下fragment信息,我的解决方法:fragment实例化之后会到activity的fragmentManager中注册一下,这个动作封装在fragment中的onAttach(Activity activity)方法中,可以直接在onAttach(Activity activity)方法中去赋值　　2.fragment嵌套fragment时没有执行子fragment的onActivityResult方法　　activity A嵌套fragment B,B嵌套fragment C,C通过startActivityForResult跳转到activity D,当activity D被finish掉之后,没有执行C的onActivityResult　　其实这个问题也不是每个人都会遇到,当activity A和Fragment B不重写onActivityResult方法,可能就不会出现这个问题,但是我的activity A重写了onActivityResult方法,所以当activity D被销毁的时候,直接去执行activity 的onActivityResult,其实这个问题也很简单,只是遇到的时候可能想不到,解决方案就是在Activity中的onActivityResult方法中加入super.onActivityResult(requestCode, resultCode, data);一切都ok了　　Activity的onActivityResult方法:　　protected void onActivityResult(int requestCode, int resultCode, Intent data) {　　super.onActivityResult(requestCode, resultCode, data);　　　fragment的onActivityResult方法:　　public void onActivityResult(int requestCode, int resultCode, Intent data) {

通过onAttach(Activity activity) 这个参数，强转成当前activity,然后调用对应的方法，replace或是add fragmentB, 也可以让当前activity,实现个切换的接口，强转成接口调用切换函数。

主activity是这样[mw_shl_code=java,true]public class MainTabHostActivity extends FragmentActivity{ private FragmentTabHost mTabHost; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main_layout); mTabHost = (FragmentTabHost)findViewById(android.R.id.tabhost); mTabHost.setup(this, getSupportFragmentManager(), R.id.realtabcontent); mTabHost.addTab(mTabHost.newTabSpec("tab1").setIndicator("软件"),SoftwareFragment.class,null); mTabHost.addTab(mTabHost.newTabSpec("tab2").setIndicator("日志"),SoftwareFragment.class,null); mTabHost.addTab(mTabHost.newTabSpec("tab3").setIndicator("权限"),SoftwareFragment.class,null); mTabHost.addTab(mTabHost.newTabSpec("tab3").setIndicator("设置"),SoftwareFragment.class,null); }}[/mw_shl_code] 在onCreateView里面少了句：softwareListView.setOnItemClickListener(this);吧亲

fragment是在3.0版本引入的，但是也可以在以前的版本中使用，需要引入android-support-v4.jar支持包，当然调用的方法也不一样，下面介绍的方法兼容了3.0以前的版本，主要介绍fragment的切换需要做的准备新建一个android项目，主Activity命名为MainActivity创建三个Fragment1 Fragment2 Fragment3为三个Fragment创建三个布局文fragment1.xml、fragment2.xml、fragment3.xml布局 activity_main.xmfragment1.xml样例Fragment1样例另外的可以根据样例进行修改activity_main.xml内容activity打开时我们需要显示一个fragment，也就是需要先向容器中添加一个fragment这是就能显示第二个fragment了，那么如何切换不同的fragment呢，切换的过程如下开启事务调用事务的replace方法，将当前容器的fragment替换为新的fragment提交事务注意上图红框中的addToBackStack方法，很多人都不是很清楚这个方法的实际作用，说一下程序运行时候的现象你就明白了初始化时显示的是 fragment2实践1 :fragment2------点击按钮frag1-----按返回键--------退出应用实践2: fragment2-----点击按钮frag3 -----按返回键--------返回到fragment2为啥会出现上面的情况，原因就是切换到fragment3时，调用了addToBackStack方法，这时会将fragment2先入栈，然后再切换到fragment3，按返回键的时候fragment3销毁，fragment2出栈显示，而切换到fragme1时没有将fragme2入栈，所以fragment2就直接销毁了，再按返回键就直接退出应用了

Android运行在各种各样的设备中，有小屏幕的手机，超大屏的平板甚至电视。针对屏幕尺寸的差距，很多情况下，都是先针对手机开发一套App，然后拷贝一份，修改布局以适应平板神马超级大屏的。难道无法做到一个App可以同时适应手机和平板么，当然了，必须有啊。Fragment的出现就是为了解决这样的问题。你可以把Fragment当成Activity的一个界面的一个组成部分，甚至Activity的界面可以完全有不同的Fragment组成，更帅气的是Fragment拥有自己的生命周期和接收、处理用户的事件，这样就不必在Activity写一堆控件的事件处理的代码了。更为重要的是，你可以动态的添加、替换和移除某个Fragment。在秒秒学的网站中有专门的课程来介绍Frament。

两个Fragment使用上是没有区别的fragment是安卓3.0以上才引入的新东西如果你想兼容3.0以下的版本,那么你就要使用v4包的如果你的app本身不是 minSDK >14的,你可以直接用android.app包下面的

一样用,但是fragment里嵌套的fragment不能用getsupportFragmentManager而是要用getChildXXXXXManager才行

1 如何在acitivty中执行fragment中的方法：首先获得这个Fragment的对象xxxFragment fragmentObject = (xxxFragment) getFragmentManager.findFragmentByTag("xx");2 如何在Fragment中执行activity中的方法：第一种：让acitivity继承接口第二种：在fragment中使用getActivity()但是要加上acitivity的名字，即：((MainActivity)getActivity()).xxx();3 如果在fragment中要操作一个fragment,首要要得到这个对象，如何得到？使用getActivity中的FragmentMnager的getFragmentByTag,然后就可以使用这个fragment的对象来操作他的方法了。当然获得这个Fragment的时候要转成这个Fragment的一个对象eg:FragmentManager fm = getActivity.getSupportFragmentManager();xxxFragment = (xxxFragment)fm.findFragmentByTag("xxx")4 如何在任意类中操作一个fragment,首先要得到环境参数，如何得到？在activity中：private static WeakReference<ActionButtonActivity> actionButtonActivty = null;actionButtonActivty = new WeakReference<ActionButtonActivity>(this);从activity中将这个actionButtonActivity对象传递到这个任意类中asyncTask.setActivity(actionButtonActivty);在任意类中：private static WeakReference<ActionButtonActivity> actionButtonActivty;public void setActivity(WeakReference<ActionButtonActivity> actionButtonActivty) {this.actionButtonActivty = actionButtonActivty;}/*** this method is invoked on the UI thread after the background computation* finishes. The result of the background computation is passed to this step* as a parameter.*/@Overrideprotected void onPostExecute(Bitmap result) {super.onPostExecute(result);FragmentManager fm = actionButtonActivty.get().getFragmentManager();FragmentTransaction ft = fm.beginTransaction();BFragmentTab_one_event_details bt_det = (BFragmentTab_one_event_details) fm.findFragmentByTag("2_det");bt_det.setEvidenceImage(result);bt_det.setButtonClickable();ft.addToBackStack(null).commit();}

fragment是3.0以后的东西，为了在低版本中使用fragment就要用到android-support-v4.jar兼容包,而fragmentActivity就是这个兼容包里面的，它提供了操作fragment的一些方法，其功能跟3.0及以后的版本的Activity的功能一样。

需要做的准备新建一个android项目，主Activity命名为MainActivity创建三个Fragment1 Fragment2 Fragment3为三个Fragment创建三个布局文fragment1.xml、fragment2.xml、fragment3.xml布局 activity_main.xmfragment1.xml样例Fragment1样例另外的可以根据样例进行修改activity_main.xml内容activity打开时需要显示一个fragment，也就是需要先向容器中添加一个fragment这是就能显示第二个fragment了，那么如何切换不同的fragment呢，切换的过程如下开启事务调用事务的replace方法，将当前容器的fragment替换为新的fragment提交事务注意上图红框中的addToBackStack方法，很多人都不是很清楚这个方法的实际作用，说一下程序运行时候的现象你就明白了初始化时显示的是 fragment2实践1 :fragment2------点击按钮frag1-----按返回键--------退出应用实践2: fragment2-----点击按钮frag3 -----按返回键--------返回到fragment2为啥会出现上面的情况，原因就是切换到fragment3时，调用了addToBackStack方法，这时会将fragment2先入栈，然后再切换到fragment3，按返回键的时候fragment3销毁，fragment2出栈显示，而切换到fragme1时没有将fragme2入栈，所以fragment2就直接销毁了，再按返回键就直接退出应用了

Fragment中的onCreateView的时候 要求返回一个创建好的视图View,你只需要将你的LinearLayout,定义在这个view中即可关于Fragment介绍及生命同期: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，其他的所有方法如果你重写了，必须先调用父类的该方法

判断Fragment是否对用户可见的方法是通过setUserVisibleHint来实现的。1、通过重写setUserVisibleHint来动态设定Fragment是否可见 @Overridepublic void setUserVisibleHint(boolean isVisibleToUser) { super.setUserVisibleHint(isVisibleToUser); isVisible = isVisibleToUser; // Make sure that fragment is currently visible if (!isVisible && isResumed()) { // 调用Fragment隐藏的代码段 } else if (isVisible && isResumed()) { // 调用Fragment显示的代码段 }}2、setUserVisibleHint这个方法默认是true，确实是需要用户手动调用的，如果你使用fragment配合FragmentPagerAdapter使用的话,adapter会在内部控制setUserVisibleHintFragment() 这个方法(请看FragmentPagerAdapter源码) ,如果是自己控制fragment的话，就需要手动调用setUserVisibleHintFragment() 这个方法了。

请参阅Android: 不能替换另一个的一个片段如何显示一个选项卡内的一个新片段？这里是解决方案。在 home_activity.xml，你应该离开空你 tabcontent。<FrameLayoutandroid:id="@+id/tabcontent"android:layout_width="match_parent"android:layout_height="0dp"android:layout_weight="1" />您的 Home_Activityprivate FragmentTabHost mHost;public void changeFragment() {FragmentTransaction ft = getSupportFragmentManager().beginTransaction();EntertainmentFragment enFragment = new EntertainmentFragment();ft.replace(R.id.tabcontent, enFragment);ft.commit();}@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);mHost = (FragmentTabHost) findViewById(android.R.id.tabhost);mHost.setup(this, getSupportFragmentManager(), R.id.tabcontent);mHost.addTab(mHost.newTabSpec("School").setIndicator("School"), SchoolFragment.class, null);mHost.addTab(mHost.newTabSpec("Sport").setIndicator("Sport"), SportsFragment.class, null);}在您的 onIemClick (Sports_Fragment)，添加这MainActivity mainAct = (MainActivity)getActivity();mainAct.changeFragment();我充分的项目，基于您的代码，是在这里。我还没有机会真的检查 TabHost 为什么不工作时我测试您的代码。但FragmentTabHost的作品对我很好。编辑: 若要修复重叠问题，您可以设置 OnTabChangeListener：mHost.setOnTabChangedListener(new TabHost.OnTabChangeListener() {@Overridepublic void onTabChanged(String tabId) {// TODO Auto-generated method stubif (tabId.equalsIgnoreCase("School")) {Log.v(TAG, "school");FragmentTransaction ft = getSupportFragmentManager().beginTransaction();schoolFrag = new SchoolFragment();ft.replace(R.id.tabcontent, schoolFrag);ft.commit();}if (tabId.equalsIgnoreCase("Sport")) {Log.v(TAG, "Sport");FragmentTransaction ft = getSupportFragmentManager().beginTransaction();SportsFragment sportFrag = new SportsFragment();ft.replace(R.id.tabcontent, sportFrag);ft.commit();}}});关于 backpress，您可以尝试ft.addToBackStack(null);

需要做的准备新建一个android项目，主Activity命名为MainActivity创建三个Fragment1 Fragment2 Fragment3为三个Fragment创建三个布局文fragment1.xml、fragment2.xml、fragment3.xml布局 activity_main.xmfragment1.xml样例Fragment1样例另外的可以根据样例进行修改activity_main.xml内容activity打开时我们需要显示一个fragment，也就是需要先向容器中添加一个fragment这是就能显示第二个fragment了，那么如何切换不同的fragment呢，切换的过程如下开启事务调用事务的replace方法，将当前容器的fragment替换为新的fragment提交事务初始化时显示的是 fragment2实践1 :fragment2------点击按钮frag1-----按返回键--------退出应用实践2: fragment2-----点击按钮frag3 -----按返回键--------返回到fragment2为啥会出现上面的情况，原因就是切换到fragment3时，调用了addToBackStack方法，这时会将fragment2先入栈，然后再切换到fragment3，按返回键的时候fragment3销毁，fragment2出栈显示，而切换到fragme1时没有将fragme2入栈，所以fragment2就直接销毁了，再按返回键就直接退出应用了。

1.Fragment是android3.0引入的新控件，果应用使用在3.0以下、1.6及以上的版本，需要引入v4包。2.Fragment支持在不同的Activity中使用并且可以处理自己的输入事件以及生命周期方法等。3.Fr期方法依赖于Activity的生命周期，例如一个Activity的onPause()的生命周期方法被调用的时候这个Activity中的所有的Fragment的onPause()方法也将被调用。4.FragmentManager提供了对Activity运行时的Fragment的添加、删除、替换的操作。在Activity运行期间可以添加Fragment而不是在XML布局文件中进行定义。如果打算在Activity中改变Fragment的生命过程。如果要执行添加、删除、修改的操作，必须通过FragmentManager的对象获得一个FragmentTransaction对象，通过它的API来执行这些操作。5.两个单独的Fragment之间是不应该进行通信的。应该使用他们所存在的Activity作为沟通的纽带。

需求： app首页多个tab的情况下，刷新消息tab Fragment的消息列表，为避免重复刷新，有两种情况下需要刷新： 1.从其他tab切换至消息tab时，刷新消息列表； 2.消息tab选中时，在此fragment跳转消息详情页后再次返回，刷新消息列表； 就这两种情况，如何实现以上两种情况下的消息刷新，此时就涉及到fragment 的可见性。 可见性： 关于Fragment的可见与不可见，两种情况下的调用方法不一样： 1.使用ViewPager+Fragment实现多tab页切换，此时可通过setUserVisibleHint(boolean isVisibleToUser)这个方法获取当前fragment的可见与否 2.使用Tablayout+Fragment实现多tab页切换，此时可通过onHiddenChanged(boolean hidden)这个方法获取当前fragment的可见性 举个栗子： 使用情况：使用Tablayout+Fragment

React 中的一个常见模式是一个组件返回多个元素。Fragments 允许你将子列表分组，而无需向 DOM 添加额外节点。 假设我们要使用 React 组件渲染以下这段真实 DOM 节点。 要怎么做呢？很简单，谁都知道... React.Fragment 是在 React 16.2 新增的新特性，旧版本并不支持。下面我们从几个方面，说明 Fragment 的好处。 在低于 React 16.0 的版本，类组件或函数组件有很多限制。 比如，它们必须返回 React 元素 或 null 。其中 React 元素包括类似 <MyComponent /> 等自定义组件、类似 <div /> 等 DOM 节点元素。 正确示例： 错误示例： 类组件同理。当不正确使用时，将会报错： 这种方案的缺点也是显而易见的，在组件的返回值上，总需要一层 <div>、<span> 或其他 DOM 节点包装起来。当 React 渲染成真实 DOM 时，这个包装节点总是会存在的。 很多时候，往往这个包装节点对我们的 UI 层是没有意义的，反而加深了 DOM 树的层次。但很无奈，谁让我们要用 React 呢，人家语法限制就那样... 除了原来的 React 元素和 null 之外，新增了几种类型： 例如： 相比 React 15.x 及更早版本，这种方式实在是太棒了。除了支持更多类型，最重要的是不会增加额外的节点。 前面提到，React 15.x 里的 React 组件总是避免不了需要一层可能是“无谓”的节点节点进行包装，那么 React 16.0 的改进，可以解决如下场景： 问题示例： 根据 W3C 的要求，一个合法的 <table> ， <tr> 的子元素必须是 <td> 。而 React 这种组件的写法直接破坏了 <table> 结构，最终也得不到我们的预期结果。 如果按照 React 16.x 提供的新特性，可以轻松解决... 自 React 16.2 起，开始支持 React.Fragment 语法。前面提到该特性是对数组形式的一种增强用法。 它的语法非常简单，把它是 React 内置的一个 React 组件。 key 是唯一可以传递给 Fragment 的属性。将来可能会添加对其他属性的支持，例如事件处理程序。 也可以使用它的简写语法 <></> ，但这种写法不接受任意属性，包括 key 。 回到文章开头的示例，要渲染这样一段真实 DOM 节点。 前面提到，可以有几种解决方案，各有利弊。 解决方法一 低于 React 16.0 版本，由于不支持 Fragment 和数组形式，唯一的方法是将它们包装在一个额外的元素中，通常是 div 或 span 。如下： 但上述这种方法有个缺点，在渲染成真实 DOM 的时候，会增加一个节点，比如上述的 <div /> 。 解决方法二 自 React 16.0 起，支持数组形式。因此可以这么做： 这种方式有点麻烦，我们对比一下 Fragment 形式。 解决方法三（推荐） 自 React 16.2 起，支持 React.Fragment 语法，因此我们可以这样使用。 仔细对比数组和 Fragment 形式，可以发现数组形式有以下缺点： 以上这些限制 Fragment 统统都没有，我们就按正常的思维去编写 DOM 节点就好了。