fragment 订阅
《Fragment》是花想创作的网络小说,发表于晋江文学网。 展开全文
《Fragment》是花想创作的网络小说,发表于晋江文学网。
信息
作    者
花想
中文名称
Fragment
主    角
亞瑟.柯克蘭,伊莉莎白。女王 [1]
连载平台
晋江文学网
连载状态
连载中 [1]
DevExpress控件应用
作品简介玫瑰枯零了,我会为你栽种新的。婚戒失去了,我会为你亲手戴上专属的。悔懊和骄傲埋在四百年前的土壤下,由泪水疯狂哀恨灌溉至死--或是我以为我会因此而死。然而,四百年後的陵墓破裂了,阳光从冬季复醒,而我看见了爱意与思念的花藤蔓生而出--CP为亚瑟与女王,女王的鬼魂(?)穿越来到现代再续前缘,架空历史向的一篇。有Doctor Who神奇串场、阿尔大发醋劲。原为一年前的即兴短文,结果後面越写越认真了到现在还未完结…… [1] 
收起全文
精华内容
下载资源
问答
  • Fragment

    千次阅读 2016-05-17 15:58:04
    Fragment   一、Fragment的概念和用法: (一)、概念:  Fragment是在Android 3.0 (API level 11)开始引入新的API技术。  为了提高代码重用性和改善用户体验,我们将Activity中的UI组件进行...
    Fragment
     
    一、Fragment的概念和用法:
    (一)、概念:
            Fragment是在Android 3.0 (API level 11)开始引入新的API技术。
            为了提高代码重用性和改善用户体验,我们将Activity中的UI组件进行分组和模块化管理。这些分组后的UI组件就是Fragment。
            一个Activity页面中可以包含多个Fragment模块,而同一个Fragment模块也可以被多个Activity使用。每个Fragment有自己的布局,有自己的生命周期。虽然Fragment拥有自己的生命周期,但因为Fragment必须被嵌入到Activity中使用,因此Fragment的生命周期是受其Activity宿主的生命周期所控制的。当Activity暂停时,该Activtiy内的所有Fragment都会暂停;当Activity被销毁时,该Activity内的所有Fragment都会被销毁。


    (二)、Fragment为什么能改善用户体验,另外Fragment能用于平板电脑,那么普通的手机屏幕适用吗?

    下图是一个“AndroidManual学习手册浏览界面”的效果图:

          
      如上图所示,“平板电脑”中,在一个Activity布局中放了两个Fragment:左侧是文章标题列表Fragment,右侧是文章内容展示的Fragment。左侧的标题列表不变,点击每条列表项,右侧的文章内容发生变化。点击和浏览内容都在同一个页面中发生,避免了页面切换和点击“返回键”返回的操作。用户感觉自然方便和快捷。
            那么Fragment组件适用于普通屏幕的手机吗?答案是肯定的。Fragment本身是可复用的组件。是否在一个Activity页面中放置多个Fragment取决了屏幕的大小,如果屏幕大小不够,那么就可以在Activity A中只包含Fragment A,在Activity B中只包含Fragment B,点击A中的item跳转到B就可以。


    (三)、Fragment要点:【重点
        1、Fragment作为Activity界面的一部分组成出现;
        2、可以在一个Activity中同时出现多个Fragment,并且,一个Fragment亦可在多个Activity中使用;
        3、在Activity运行过程中,可以添加移除替换、隐藏、显示Fragment(add()、remove()、replace()、hide()、show());
        4、Fragment可以响应自己的输入事件,并且有自己的生命周期,当然,它们的生命周期直接受其所属的宿主Activity的生命周期控制。

        5、FragmenetTransaction的方法:

    • 使用add()加入fragment时将触发onAttach(),使用attach()不会触发onAttach()
    • 使用replace()替换后会将之前的fragment的view从viewtree中删除
    • 触发顺序:
    • detach()->onPause()->onStop()->onDestroyView()
    • attach()->onCreateView()->onActivityCreated()->onStart()->onResume()
    • 使用hide()方法只是隐藏了fragment的view并没有将view从viewtree中删除,随后可用show()方法将view设置为显示
    • 而使用detach()会将view从viewtree中删除,和remove()不同,此时fragment的状态依然保持着,在使用 attach()时会再次调用onCreateView()来重绘视图,注意使用detach()后fragment.isAdded()方法将返回  false,在使用attach()还原fragment后isAdded()会依然返回false(需要再次确认)
    • 执行detach()和replace()后要还原视图的话, 可以在相应的fragment中保持相应的view,并在onCreateView()方法中通过view的parent的removeView()方法将view和parent的关联删除后返回



    (四)、Fragment家族常用的API
    1、Fragment常用的三个类:
    • android.app.Fragment 主要用于定义Fragment 
    • android.app.FragmentManager 主要用于在Activity中操作Fragment 
    • android.app.FragmentTransaction  

    2、获取FragmentManage的方式:
    getFragmentManager() // v4中,getSupportFragmentManager

    3、主要的操作都是FragmentTransaction的方法
        FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务
    • transaction.add()      往Activity中添加一个Fragment 
    • transaction.remove()    从Activity中移除一个Fragment,如果被移除的Fragment没有添加到回退栈,这个Fragment实例将会被销毁。
    • transaction.replace()    使用另一个Fragment替换当前的,实际上就是remove()+add()的合体 
    • transaction.hide()    隐藏当前的Fragment,仅仅是设为不可见,并不会销毁 
    • transaction.show()   显示之前隐藏的Fragment 
    • transaction.detach()    会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护
    • transaction.attach()     重建view视图,附加到UI上并显示 
    • transatcion.commit()    提交一个事务
    • fragment.isAdded()  判断一个Fragment是否已经被添加到事务中 

    二、Fragment生命周期:
    (一)、Fragment基本状态:
        1、活动状态:Resumed   当前Fragment位于前台,用户可见,可以获得焦点;
        2、暂停状态:  Paused   另一个Activity处于前台并拥有焦点, 但是该Fragment所在的Activity仍然可见(前台Activity局部透明或者没有覆盖整个屏幕),不过不能获得焦点;
        3、停止状态:Stopped
    要么是宿主Activity已经被停止, 要么是Fragment从Activity被移除但被添加到回退栈中;
    停止状态的Fragment仍然活着(所有状态和成员信息被系统保持着)。 然而, 它对用户不再可见, 并且如果Activity被销毁,它也会被销毁;
        4、销毁状态:Destroyed  只能等待被回收。

    (二)、Fragment生命周期:【重点

    方法 描述
    onAttach(Activity)

    当前Fragment与Activity关联,调用!

    onCreate()

    完成fragment的初始化创建


    onCreateView()

    创建并返回与当前fragment相关联的层次视图view


    onActivityCreated()

    主activity的onCreate()执行完后,该方法才执行


    onStart()

    fragment可见,当主activity处于started状态后执行



    onResume()

    fragment能与用户交互,当主activity处于resumed状态后执行



    onPause()

    fragment不在与用户交互,可能在主activity将要处于paused前执行,可能该fragment被修改


    onStop()

    fragment不在可见,可能在主activity将要处于stopped前执行,可能该fragment被修改


    onDestroyView()

    允许该fragment清理视图相关资源

    onDestroy()

    清理掉视图state信息

    onDetach()

    该fragment不在于activity关联


    1、onAttach(): 当该Fragment被添加到Activity时被回调。该方法只会被调用一次;
    2、onCreate():  当创建Fragment时被回调。该方法只会被调用一次;
    3、onCreateView():每次创建、绘制该Fragment的View组件时回调该方法,Fragment将会显示该方法返回的View 组件;
    4、onActivityCreated(): 当Fragment的宿主Activity被启动完成后回调该方法;
    5、onStart(): 启动Fragment时被回调;
    6、onResume():  onStart()方法后一定会回调onResume()方法;
    7、onPause(): 暂停Fragment时被回调;
    8、onStop(): 停止Fragment时被回调;
    9、onDestroyView():  销毁该Fragment所包含的View组件时调用;
    10、onDestroy():  销毁Fragment时被回调。该方法只会被调用一次;
    11、onDetach():  将Fragment从Activity中删除、替换完成时调用该方法。onDestroy()方法后一定会回调onDetach()方法。该方法只会被调用一次。
    12、onInflate():  
    13、onViewCreated(): 

    【备注:】其中大多数程序必须实现Fragment的三个回调方法分别为: 
    onCreate :系统创建Fragments 时调用,可做执行初始化工作或者当程序被暂停或停止时用来恢复状态,跟Activity 中的onCreate相当。  
    onCreateView :用于首次绘制用户界面的回调方法,必须返回要创建的Fragment 视图UI。假如你不希望提供Fragment用户界面则可以返回NULL。  
    onPause : 当用户离开这个Fragment的时候调用,这时你要提交任何应该持久的变化,因为用户可能不会回来。

    (三)、示例代码:
    1、Fragment的布局文件:



    <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical">




    <TextView

    android:id="@+id/text_leftfragment_info"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:text="这是leftFragment中的textview"/>


    </LinearLayout>


    2、MainActivity的布局文件:



    <RelativeLayoutxmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent">

    <fragment

    android:id="@+id/fragment_left_newstitle"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:name="com.steven.android24_fragmentlifecycle.LeftFragment"/>

    </RelativeLayout>


    3、Fragment文件中的java代码:

    publicclass LeftFragment extends Fragment {

    privatestaticfinal String TAG = "LeftFragment";

    @Override

    publicvoid onInflate(Activity activity, AttributeSet attrs,

    Bundle savedInstanceState) {

    Log.i(TAG"==onInflate()执行了");

    super.onInflate(activity, attrs, savedInstanceState);

    }




    @Override

    publicvoid onAttach(Activity activity) {

    Log.i(TAG"==onAttach()执行了");

    super.onAttach(activity);

    }




    @Override

    publicvoid onCreate(Bundle savedInstanceState) {

    Log.i(TAG"==onCreate()执行了");

    super.onCreate(savedInstanceState);

    }




    @Override

    public View onCreateView(LayoutInflater inflater, ViewGroup container,

    Bundle savedInstanceState) {

    Log.i(TAG"==onCreateView()执行了");

    // inflater.inflate(resource, null);

    return inflater.inflate(R.layout.fragment_left, container, false);

    }




    @Override

    publicvoid onViewCreated(View view, Bundle savedInstanceState) {

    Log.i(TAG"==onViewCreated()执行了");

    super.onViewCreated(view, savedInstanceState);

    }




    @Override

    publicvoid onActivityCreated(Bundle savedInstanceState) {

    Log.i(TAG"==onActivityCreated()执行了");

    super.onActivityCreated(savedInstanceState);

    }




    @Override

    publicvoid onStart() {

    Log.i(TAG"==onStart()执行了");

    super.onStart();

    }




    @Override

    publicvoid onResume() {

    Log.i(TAG"==onResume()执行了");

    super.onResume();

    }




    @Override

    publicvoid onPause() {

    Log.i(TAG"==onPause()执行了");

    super.onPause();

    }




    @Override

    publicvoid onStop() {

    Log.i(TAG"==onStop()执行了");

    super.onStop();

    }




    @Override

    publicvoid onDestroyView() {

    Log.i(TAG"==onDestroyView()执行了");

    super.onDestroyView();

    }




    @Override

    publicvoid onDestroy() {

    Log.i(TAG"==onDestroy()执行了");

    super.onDestroy();

    }




    @Override

    publicvoid onDetach() {

    Log.i(TAG"==onDetach()执行了");

    super.onDetach();

    }




    @Override

    publicvoid onCreateOptionsMenu(Menu menu, MenuInflater inflater) {

    super.onCreateOptionsMenu(menu, inflater);

    }




    @Override

    publicvoid onCreateContextMenu(ContextMenu menu, View v,

    ContextMenuInfo menuInfo) {

    super.onCreateContextMenu(menu, v, menuInfo);

    }
    }



    (四)、运行结果观察:
        1、第一次加载Fragment:

        2、在MainActivity中,点击“返回键”退出程序:

        3、在MainActivity中,点击“HOME键”退出程序:
    【备注:】请注意第二种和第三种情况的区别。如果点HOME键退出,则少调用了onDestroyView()、onDestroy()、onDetach()三个回调方法。

        4、点击“下一页”,进入NextActivity页面:

        5、在NextActivity页面中,点击“HOME键”退出程序:

        6、上次HOME键退出后,重新进入程序:【因为上次是从NextActivity页面按HOME退出,所以此时直接进入 NextActivity页面 】


    (五)、跟Fragment生命周期相关的其他方法:
    1、onInflate():在onCreate()方法之前调用,这时窗体上的控件都没有被创建,所以不能通过getActivity().findViewById(),因为此时getActivity()返回null。
    2、onViewCreated():在onCreateView()方法后会立刻调用onViewCreated()方法。通常在该方法中完成创建Fragment的最后工作,然后系统就开始调用onCreate()方法对窗体初始化。



    (六)、如果Activity生命周期和Fragment生命周期的Log都开启,那么依次会如何输出信息呢?

    1、第一次加载MainActivity页面:

    2、在MainActivity页面中,点击“返回键”退出程序:

       3、在MainActivity中,点击“HOME键”退出程序:

    【备注:】请同学们注意观察Activity回调方法和Fragment回调方法执行的顺序。请设想各种操作步骤,写出生命周期回调方法执行的顺序。

    特别强调:】
    当Activity的onCreate()方法中,如果将Log的位置放在setContentView(R.layout.activity_main)之前,那么Activity的onCreate()方法就会在最先执行,如果将日志写在setContentView(R.layout.activity_main)之后,那么Activity的onCreate()方法就会在Fragment的onViewCreated()之后执行。


    4、分析生命周期执行过程的案例:
    开启一个包含有Fragment的Activity页面,然后点击“返回键”退出,然后再次启动该Activity页面,请描述完整的生命周期回调方法。
    参考答案:

    04:36:31.282: MainActivity: ==onCreate()
    04:36:31.502: LeftFragment: ==onInflate()执行了
    04:36:31.502: LeftFragment: ==onAttach()执行了
    04:36:31.513: LeftFragment: ==onCreate()执行了
    04:36:31.513: LeftFragment: ==onCreateView()执行了
    04:36:31.533: LeftFragment: ==onViewCreated()执行了
    04:36:31.542: LeftFragment: ==onActivityCreated()执行了
    04:36:31.542: MainActivity: ==onStart()
    04:36:31.552: LeftFragment: ==onStart()执行了
    04:36:31.563: MainActivity: ==onResume()
    04:36:31.563: LeftFragment: ==onResume()执行了
    04:37:20.133: LeftFragment: ==onPause()执行了
    04:37:20.142: MainActivity: ==onPause()
    04:37:21.932: LeftFragment: ==onStop()执行了
    04:37:21.932: MainActivity: ==onStop()
    04:37:21.942: LeftFragment: ==onDestroyView()执行了
    04:37:21.952: LeftFragment: ==onDestroy()执行了
    04:37:21.952: LeftFragment: ==onDetach()执行了
    04:37:21.952: MainActivity: ==onDestroy()
    04:39:20.763: MainActivity: ==onCreate()
    04:39:21.552: LeftFragment: ==onInflate()执行了
    04:39:21.635: LeftFragment: ==onAttach()执行了
    04:39:21.635: LeftFragment: ==onCreate()执行了
    04:39:21.652: LeftFragment: ==onCreateView()执行了
    04:39:21.652: LeftFragment: ==onViewCreated()执行了
    04:39:21.842: LeftFragment: ==onActivityCreated()执行了
    04:39:21.842: MainActivity: ==onStart()
    04:39:21.908: LeftFragment: ==onStart()执行了
    04:39:21.912: MainActivity: ==onResume()
    04:39:21.932: LeftFragment: ==onResume()执行了
    三、创建Fragment:
    (一)、创建Fragment的步骤:【只需要两步
    1、创建一个Fragment,必须继承Fragment 这个基类或其子类;
            【备注:】除了继承基类 Fragment , 还有一些子类你可能会继承,是哪些子类呢?
    DialogFragment

    • 显示一个浮动的对话框.  用这个类来创建一个对话框,是使用在Activity类的对话框工具方法之外的一个好的选择,因为你可以将一个fragment对话框合并到activity管理的fragment back stack中,允许用户返回到一个之前曾被摒弃的fragment.
    ListFragment
    • 显示一个由一个adapter(例如 SimpleCursorAdapter)管理的项目的列表, 类似于ListActivity。它提供一些方法来管理一个list view, 例如 onListItemClick()回调来处理点击事件.
    PreferenceFragment
    • 显示一个 Preference对象的层次结构的列表, 类似于PreferenceActivity。这在为你的应用创建一个"设置"activity时有用处.
    2、实现回调方法:
            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而言,通常实现三个回调方法即可。但是实际开发中可以根据需要重写Fragment生命周期中的任意回调方法。    


    (二)、Fragment实例:
    1、描述:以“ 影视介绍 ”为例,无需页面切换,点击左侧影视名称,在右侧区域显示影视内容介绍。
    2、主页面布局及Fragment布局文件代码:

    //activity_main.xml布局文件:
    <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent">


    <fragment

    android:id="@+id/fragment_left_title"

    android:layout_width="0dp"

    android:layout_height="fill_parent"

    android:layout_weight="1"

    class="com.steven.android24_fragmentmovie.LeftFragment"/>

    <fragment

    android:id="@+id/fragment_right_detail"

    android:layout_width="0dp"

    android:layout_height="fill_parent"

    android:layout_weight="3"

    class="com.steven.android24_fragmentmovie.RightFragment"/>

    </LinearLayout>




    //LeftFragment的布局文件:


    <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical">

    <ListView

    android:id="@+id/listView_fragment_left"

    android:layout_width="match_parent"

    android:layout_height="wrap_content">

    </ListView>

    </LinearLayout>




    //RightFragment的布局文件:

    <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical">

    <TextView

    android:id="@+id/text_fragment_right"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:text="请点击左侧列表"/>

    </LinearLayout>


    【备注:】
    <fragment>标签的android:id 和 android:tag属性必须至少有一个,同一个xml文件中id或tag必须唯一;
    <fragment>标签的class 和 android:name属性功能完全相同,使用其中任何一个即可。

    3、LeftFragment核心代码:

    publicclass LeftFragment extends Fragment {

    private ListView listView_fragment_left;

    private String[] arr_data = new String[] { "扫毒", " 功夫战斗机", "顶楼的大象", "狂爱恶徒",

    "兽性窥视", "新金瓶梅" };

    private TextView text_fragment_right;



    @Override

    public View onCreateView(LayoutInflater inflater, ViewGroup container,

    Bundle savedInstanceState) {

    View view = inflater.inflate(R.layout.fragment_left, null);


    listView_fragment_left = (ListView) view

    .findViewById(R.id.listView_fragment_left);




    ArrayAdapter<String> adapter = new ArrayAdapter<String>(getActivity(),

    android.R.layout.simple_list_item_1, arr_data);

    listView_fragment_left.setAdapter(adapter);




    listView_fragment_left

    .setOnItemClickListener(new OnItemClickListener() {




    @Override

    publicvoid onItemClick(AdapterView<?> parent, View view,

    int position, long id) {

    InputStream is;

    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    String data = "";

    try {

    is = getActivity().getResources().getAssets()

    .open("movie" + position + ".txt");

    byte[] buffer = newbyte[1024];

    int c = 0;

    while ((c = is.read(buffer)) != -1) {

    baos.write(buffer, 0, c);

    baos.flush();

    }

    data = new String(baos.toByteArray(), "utf-8");

    } catch (IOException e) {

    e.printStackTrace();

    }




    TextView text_fragment_right = (TextView) getActivity()

    .findViewById(R.id.text_fragment_right);

    if (text_fragment_right != null) {

    text_fragment_right.setText(data);




    } else {

    Intent intent = new Intent(getActivity(),

    DetailActivity.class);

    intent.putExtra("detail", data);

    startActivity(intent);

    }

    }

    });




    return view;

    }

    }

    【备注:】本例子中的数据源是assets目录下的文本文件。通过本例,也复习了assets资产文件的访问方式。

    4、平板和手机适配:
    如果想在平板和手机中显示不同的效果。则可以新建布局目录:layout-sw600dp.


    三、动态创建Fragment
    (一)、概念:
    如果将Fragment写在布局文件中,那么就是静态创建fragment;如果没有在布局文件中写<fragment>标签,而是在java文件中通过实例化Fragment创建Fragment的方式就是动态创建Fragment。

    (二)、动态创建Fragment的步骤:
    1、步骤:


    2、Activity布局文件代码:

    <LinearLayoutxmlns:android="http://schemas.android.com/apk/res/android"

    android:layout_width="fill_parent"

    android:layout_height="fill_parent"

    android:orientation="vertical">




    <Button

    android:id="@+id/button_main_submit"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:onClick="clickButton"

    android:text="点击发送消息"/>

    <!-- fragment

    android:id="@+id/fragment_content"

    android:layout_width="wrap_content"

    android:layout_height="wrap_content"

    android:name="com.steven.android24_fragmentarguments.DetailFragment" /-->



    <LinearLayout

    android:id="@+id/layout_container_fragment"

    android:layout_width="match_parent"

    android:layout_height="wrap_content"

    android:orientation="horizontal">

    </LinearLayout>


    </LinearLayout>


    3、MainActivity文件代码:

    FragmentManager manager = getFragmentManager();
    DetailFragment fragment = new DetailFragment();

    FragmentTransaction transaction = manager.beginTransaction();
    transaction.add(R.id.layout_container_fragment, fragment, "content_fragment");
    transaction.commit();


    四、Activity与Fragment之间的数据交互:
    (一)、Activity向Fragment传递数据:Arguments
    1、做法:
            可以通过Fragment.setArguments()方法向Fragment传递数据,并且通过getArguments()方法获取传递的数据。

    2、MainActivity文件代码:

    publicclass MainActivity extends Activity {

    privatestaticfinal String TAG = "MainActivity";




    @Override

    protectedvoid onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);




    Log.i(TAG, "==onCreate()执行");

    FragmentManager manager = getFragmentManager();




    DetailFragment fragment = new DetailFragment();

    Bundle bundle = new Bundle();

    bundle.putString("msg", "Hello Fragment!!!");

    fragment.setArguments(bundle);




    FragmentTransaction transaction = manager.beginTransaction();

    transaction.add(R.id.layout_container_fragment, fragment,

    "content_fragment");

    transaction.commit();

    }

    }


    3、DetailFragment文件代码:

    publicclass DetailFragment extends Fragment {

    private TextView text_fragment_detail;
    private Button button_fragment_get;


    @Override

    publicvoid onAttach(Activity activity) {

    super.onAttach(activity);

    Log.i("DetailFragment", "==onAttach()");
    }



    @Override

    publicvoid onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    }



    @Override

    public View onCreateView(LayoutInflater inflater, ViewGroup container,

    Bundle savedInstanceState) {

    View view = inflater

    .inflate(R.layout.fragment_detail, container, false);

    text_fragment_detail = (TextView) view

    .findViewById(R.id.text_fragment_detail);



    button_fragment_get = (Button) view
    .findViewById(R.id.button_fragment_get);



    Bundle bundle = getArguments();

    if (bundle != null) {

    text_fragment_detail.setText(bundle.getString("msg"));

    } else {

    text_fragment_detail.setText("没有收到信息!");
    }

    return view;

    }

    }



    4、注意事项:
    Supply the construction arguments for this fragment. This can only be called before the fragment has been attached to its activity; that is, you should call it immediately after constructing the fragment. The arguments supplied here will be retained across fragment destroy and creation.
    翻译:setArguments(bundle)为fragment提供构造的参数。它只能在fragment回调onAttach()方法之前调用。就是说,你应该在构造完fragment之后立刻调用它。提供的这些参数将在Fragment被销毁前一直保留。
    在布局文件中使用<fragment>标签声明的Fragment(也就是静态生成的Fragment),都不能使用setArguments方法设置Bundle对象。

    (二)、Fragment向宿主Activity回传信息:(Fragment回调机制
    1、原则:
    Fragment类要尽量保证其独立性,Fragment类中不应该有访问其他Fragment和Activity中资源的代码,否则这个Fragment就不能在不改动代码的情况下用在其他地方。
    如何让多个Fragment之间可以独立多次使用,而不是紧密地绑定到一起?通常的做法就是在Fragment类中编写一个接口,然后在该Fragment的宿主窗口类中实现该接口。这样Fragment与其宿主就实现了信息交互。


    2、Fragment接口回调的步骤:(五步曲)
    在Fragment文件中定义接口:OnItemClickedListener,定义抽象方法onClick(String info);
    在Fragment文件中定义属性:private OnItemClickedListener mylistener;
    在Fragment文件中的onAttach()方法中执行:mylistener = (OnItemClickedListener) getActivity();
    在Fragment文件中,给某个控件增加监听器,在监听器中执行:mylistener.onClick(“需要传递的数据”);
    将MainActivity实现OnItemClickedListener,重写onClick(String info)方法。参数就是Fragment传递的数据信息,在该方法中执行希望的逻辑操作。

    3、DetailFragment的核心代码:



    publicclass DetailFragment extends Fragment {

    private TextView text_fragment_detail;

    private Button button_fragment_get;

    private Button button_fragment_send;

    private OnItemClickedListener mylistener;




    publicinterface OnItemClickedListener {

    publicvoid onClick(String info);

    }




    @Override

    publicvoid onAttach(Activity activity) {

    super.onAttach(activity);

    Log.i("DetailFragment""==onAttach()");

    if (getActivity() instanceof OnItemClickedListener) {

    mylistener = (OnItemClickedListener) getActivity();

    }

    }




    @Override

    publicvoid onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    }




    @Override

    public View onCreateView(LayoutInflater inflater, ViewGroup container,

    Bundle savedInstanceState) {

    View view = inflater

    .inflate(R.layout.fragment_detail, container, false);

    text_fragment_detail = (TextView) view

    .findViewById(R.id.text_fragment_detail);




    button_fragment_get = (Button) view

    .findViewById(R.id.button_fragment_get);

    button_fragment_send = (Button) view

    .findViewById(R.id.button_fragment_send);




    button_fragment_get.setOnClickListener(new OnClickListener() {




    @Override

    publicvoid onClick(View v) {

    Bundle bundle = getArguments();

    if (bundle != null) {

    text_fragment_detail.setText(bundle.getString("msg"));

    else {

    text_fragment_detail.setText("没有收到信息!");

    }

    }

    });




    button_fragment_send.setOnClickListener(new OnClickListener() {




    @Override

    publicvoid onClick(View v) {

    mylistener.onClick(“我是fragment传递给宿主的信息!");

    }

    });




    return view;

    }

    }


    4、MainActivity的核心代码:



    publicclass MainActivity extends Activity implements OnItemClickedListener {

    privatestaticfinal String TAG = "MainActivity";




    @Override

    protectedvoid onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);




    Log.i(TAG"==onCreate()执行");

    FragmentManager manager = getFragmentManager();




    DetailFragment fragment = new DetailFragment();

    Bundle bundle = new Bundle();

    bundle.putString("msg""Hello Fragment!!!");

    fragment.setArguments(bundle);




    FragmentTransaction transaction = manager.beginTransaction();

    transaction.add(R.id.layout_container_fragment, fragment,

    "content_fragment");

    transaction.commit();

    }




    @Override

    publicvoid onClick(String info) {

    // 拿到Fragment传递过来的数据,显示在Title上。
    // 实际项目中,我们是将Fragment_A传给宿主的信息拿到后,再通过setArguments()传递给Fragment_B。这样就实现了两个Fragment之间的数据传递。

    setTitle(info);

    }

    }



    五、FragmentManager与Fragment事务:  【重要】
    (一)、概念:
            Activity管理Fragment主要依靠FragmentManager。FragmentManager可以完成以下几方面的功能:

    使用findFragmentById()或findFragmentByTag()方法来获取指定Fragment;
    调用popBackStack()方法将Fragment从回退栈中弹出(如同用户按下“返回键”的效果);
    调用addOnBackStackChangeListener()注册一个监听器,用于监听回退栈的变化情况。
            在Activity中使用Fragment,一个很明显的特性是:根据用户的交互情况,可以对Fragment进行添加、移除、替换,以及执行其他动作,提交给Activity的每一套变化被称为一个事务。Fragment事务代表了Activity对Fragment执行的多个改变操作。实现事务借助于FragmentTransaction对象。我们可以保存每一个事务到一个Activity管理的backstack,这样用户就能由Fragment的变化返回导航。

    (二)、Fragment与回退栈(导航):
    1、回退栈的概念:BackStack
    在Activity中已经探讨过回退栈,这种数据结构用来存放创建的窗口对象,并根据一定的规则决定哪些窗口对象应该出栈,凡是出栈的窗口对象将被销毁,也就是说窗口对象从入栈到出栈完成了窗口的整个生命周期。回退栈不仅能存储窗口对象,还可以存储Fragment对象。


    (三)、FragmentManager与FragmentTransaction示例代码:
    Fragment的布局文件:
    // 构建Bundle对象,将文章id放在其中。
    Bundle bundle = new Bundle();
    bundle.putString("titleId", id);
    // 构建文章内容的Fragment
    RightFragment fragment = new RightFragment();
    // 通过fragment对象的setArguments(bundle)方法将数据传输给其他Fragment。
    fragment.setArguments(bundle);

    // 通过getFragmentManager()方法构建FragmentManager对象
    FragmentManager fragManager = getFragmentManager();
    // 通过FragmentManager对象的beginTransaction()方法构建FragmentTransaction对象
    FragmentTransaction trans = fragManager.beginTransaction();
    // 将主页面布局文件中的ViewGroup容器替换成文章内容Fragment
    trans.replace(R.id.fragment_content, fragment);
    trans.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
    // 将事务添加到回退栈,这样用户就可以通过“返回键”回到替换Fragment的上一个状态
    trans.addToBackStack(null);
    // 提交事务
    trans.commit();



    六、 FragmentTransaction中的replace方法与add、hide、show方法的区别:【重要】

    示例代码如下:

    1. private void initData() {
    2.  fragmentManager = getSupportFragmentManager();
    3.  // 初始化碎片集合
    4.  listFragments = new ArrayList<Fragment>();
    5.  listFragments.add(new FragmentOne());
    6.  listFragments.add(new FragmentTwo());
    7.  listFragments.add(new FragmentThree());
    8.  // 在指定位置默认加载第一个碎片
    9.  transaction = fragmentManager.beginTransaction();
    10.  transaction.add(R.id.layout_container, listFragments.get(0));
    11.  transaction.commit();
    12. }
    13. // 点击选项TAB按钮,执行碎片切换
    14. public void clickButton(View view) {
    15.  switch (view.getId()) {
    16.  case R.id.button_one:
    17.   switchFragment(0);
    18.   break;
    19.  case R.id.button_two:
    20.   switchFragment(1);
    21.   break;
    22.  case R.id.button_three:
    23.   switchFragment(2);
    24.   break;
    25.  }
    26. }
    27. /*
    28.  * 使用replace()方法实现。 每次replace都会将当前的碎片进行销毁,新创建一个碎片将原有的进行替换
    29.  * 当TAB菜单切换到之前的选项时,虽然对应的碎片已经被创建过,但是因为销毁了而需要重新创建一次,因此会造成性能浪费
    30.  */
    31. private void replaceFragment(int tabindex) {
    32.  if (currentTabIndex != tabindex) {
    33.   transaction = fragmentManager.beginTransaction();
    34.   transaction.replace(R.id.layout_container,
    35.     listFragments.get(tabindex));
    36.   transaction.addToBackStack(null);
    37.   transaction.commit();
    38.   currentTabIndex = tabindex;
    39.  }
    40. }
    41. /*
    42.  * 使用add()、hide()、show()方法实现。被加载出来的碎片在导航切换过程中不会被销毁,只是在隐藏和显示两个状态切换而已。
    43.  * 因为切换过的碎片不被销毁,自然会有内存占用上的开销,但是因为不用重新加载碎片而在性能上是优于replace的。
    44.  */
    45. private void switchFragment(int tabindex) {
    46.  if (currentTabIndex != tabindex) {
    47.   transaction = fragmentManager.beginTransaction();
    48.   // 定义当前碎片与即将加载的碎片
    49.   Fragment fromFragment = listFragments.get(currentTabIndex);
    50.   Fragment toFragment = listFragments.get(tabindex);
    51.   if (!toFragment.isAdded()) {
    52.    // 如果该碎片还没有被添加到事务中,则新添加到事务
    53.    transaction.hide(fromFragment).add(R.id.layout_container,
    54.      toFragment);
    55.   } else {
    56.    // 如果该碎片已经被添加到事务中,则从事务中取出该碎片进行显示即可。无需销毁再重新创建。
    57.    transaction.hide(fromFragment).show(toFragment);
    58.   }
    59.   // 提交执行过的事务
    60.   transaction.addToBackStack(null);
    61.   transaction.commit();
    62.   currentTabIndex = tabindex;
    63.  }
    64. }



















    展开全文
  • Android Fragment 真正的完全解析(上)

    万次阅读 多人点赞 2014-07-20 11:22:09
    本篇博客力求为大家说明Fragment如何产生,什么是FragmentFragment生命周期,如何静态和动态的使用FragmentFragment回退栈,Fragment事务;以及Fragment的一些特殊用途,例如:没有布局的Frag

    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/37970961

    自从Fragment出现,曾经有段时间,感觉大家谈什么都能跟Fragment谈上关系,做什么都要问下Fragment能实现不~~~哈哈,是不是有点过~~~

    本篇博客力求为大家说明Fragment如何产生,什么是Fragment,Fragment生命周期,如何静态和动态的使用Fragment,Fragment回退栈,Fragment事务;以及Fragment的一些特殊用途,例如:没有布局的Fragment有何用处?Fragment如何与Activity交互?Fragment如何创建对话框?Fragment如何与ActionBar集成等等。

    1、Fragment的产生与介绍

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

    2、Fragment的生命周期

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


    可以看到Fragment比Activity多了几个额外的生命周期回调方法:
    onAttach(Activity)
    当Fragment与Activity发生关联时调用。
    onCreateView(LayoutInflater, ViewGroup,Bundle)
    创建该Fragment的视图
    onActivityCreated(Bundle)
    当Activity的onCreate方法返回时调用
    onDestoryView()
    与onCreateView想对应,当该Fragment的视图被移除时调用
    onDetach()
    与onAttach相对应,当Fragment与Activity关联被取消时调用
    注意:除了onCreateView,其他的所有方法如果你重写了,必须调用父类对于该方法的实现,
    3、静态的使用Fragment

    嘿嘿,终于到使用的时刻了~~

    这是使用Fragment最简单的一种方式,把Fragment当成普通的控件,直接写在Activity的布局文件中。步骤:

    1、继承Fragment,重写onCreateView决定Fragemnt的布局

    2、在Activity中声明此Fragment,就当和普通的View一样

    下面展示一个例子(我使用2个Fragment作为Activity的布局,一个Fragment用于标题布局,一个Fragment用于内容布局):

    TitleFragment的布局文件:

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="45dp"
        android:background="@drawable/title_bar" >
    
        <ImageButton
            android:id="@+id/id_title_left_btn"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_centerVertical="true"
            android:layout_marginLeft="3dp"
            android:background="@drawable/showleft_selector" />
    
        <TextView
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:gravity="center"
            android:text="我不是微信"
            android:textColor="#fff"
            android:textSize="20sp"
            android:textStyle="bold" />
    
    </RelativeLayout>

    TitleFragment

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.view.ViewGroup;
    import android.widget.ImageButton;
    import android.widget.Toast;
    
    public class TitleFragment extends Fragment
    {
    
    	private ImageButton mLeftMenu;
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		View view = inflater.inflate(R.layout.fragment_title, container, false);
    		mLeftMenu = (ImageButton) view.findViewById(R.id.id_title_left_btn);
    		mLeftMenu.setOnClickListener(new OnClickListener()
    		{
    			@Override
    			public void onClick(View v)
    			{
    				Toast.makeText(getActivity(),
    						"i am an ImageButton in TitleFragment ! ",
    						Toast.LENGTH_SHORT).show();
    			}
    		});
    		return view;
    	}
    }
    

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

    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical" >
    
        <TextView
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:gravity="center"
            android:text="使用Fragment做主面板"
            android:textSize="20sp"
            android:textStyle="bold" />
    
    </LinearLayout>

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    
    public class ContentFragment extends Fragment
    {
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		return inflater.inflate(R.layout.fragment_content, container, false);
    	}
    
    }
    

    MainActivity

    package com.zhy.zhy_fragments;
    
    import android.app.Activity;
    import android.os.Bundle;
    import android.view.Window;
    
    public class MainActivity extends Activity
    {
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState)
    	{
    		super.onCreate(savedInstanceState);
    		requestWindowFeature(Window.FEATURE_NO_TITLE);
    		setContentView(R.layout.activity_main);
    	}
    
    }
    

    Activity的布局文件:

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >
    
        <fragment
            android:id="@+id/id_fragment_title"
            android:name="com.zhy.zhy_fragments.TitleFragment"
            android:layout_width="fill_parent"
            android:layout_height="45dp" />
    
        <fragment
            android:layout_below="@id/id_fragment_title"
            android:id="@+id/id_fragment_content"
            android:name="com.zhy.zhy_fragments.ContentFragment"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent" />
    
    </RelativeLayout>

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


    4、动态的使用Fragment

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

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

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >
    
        <fragment
            android:id="@+id/id_fragment_title"
            android:name="com.zhy.zhy_fragments.TitleFragment"
            android:layout_width="fill_parent"
            android:layout_height="45dp" />
    
        <include
            android:id="@+id/id_ly_bottombar"
            android:layout_width="fill_parent"
            android:layout_height="55dp"
            android:layout_alignParentBottom="true"
            layout="@layout/bottombar" />
    
        <FrameLayout
            android:id="@+id/id_content"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent"
            android:layout_above="@id/id_ly_bottombar"
            android:layout_below="@id/id_fragment_title" />
    
    </RelativeLayout>

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

    下面主Activity

    package com.zhy.zhy_fragments;
    
    import android.app.Activity;
    import android.app.FragmentManager;
    import android.app.FragmentTransaction;
    import android.os.Bundle;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.view.Window;
    import android.widget.LinearLayout;
    
    public class MainActivity extends Activity implements OnClickListener
    {
    	private LinearLayout mTabWeixin;
    	private LinearLayout mTabFriend;
    
    	private ContentFragment mWeixin;
    	private FriendFragment mFriend;
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState)
    	{
    		super.onCreate(savedInstanceState);
    		requestWindowFeature(Window.FEATURE_NO_TITLE);
    		setContentView(R.layout.activity_main);
    
    		// 初始化控件和声明事件
    		mTabWeixin = (LinearLayout) findViewById(R.id.tab_bottom_weixin);
    		mTabFriend = (LinearLayout) findViewById(R.id.tab_bottom_friend);
    		mTabWeixin.setOnClickListener(this);
    		mTabFriend.setOnClickListener(this);
    
    		// 设置默认的Fragment
    		setDefaultFragment();
    	}
    
    	private void setDefaultFragment()
    	{
    		FragmentManager fm = getFragmentManager();
    		FragmentTransaction transaction = fm.beginTransaction();
    		mWeixin = new ContentFragment();
    		transaction.replace(R.id.id_content, mWeixin);
    		transaction.commit();
    	}
    
    	@Override
    	public void onClick(View v)
    	{
    		FragmentManager fm = getFragmentManager();
    		// 开启Fragment事务
    		FragmentTransaction transaction = fm.beginTransaction();
    
    		switch (v.getId())
    		{
    		case R.id.tab_bottom_weixin:
    			if (mWeixin == null)
    			{
    				mWeixin = new ContentFragment();
    			}
    			// 使用当前Fragment的布局替代id_content的控件
    			transaction.replace(R.id.id_content, mWeixin);
    			break;
    		case R.id.tab_bottom_friend:
    			if (mFriend == null)
    			{
    				mFriend = new FriendFragment();
    			}
    			transaction.replace(R.id.id_content, mFriend);
    			break;
    		}
    		// transaction.addToBackStack();
    		// 事务提交
    		transaction.commit();
    	}
    
    }
    

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

    注:如果使用Android3.0以下的版本,需要引入v4的包,然后Activity继承FragmentActivity,然后通过getSupportFragmentManager获得FragmentManager。不过还是建议版Menifest文件的uses-sdk的minSdkVersion和targetSdkVersion都改为11以上,这样就不必引入v4包了。

    代码中间还有两个Fragment的子类,ContentFragment上面已经见过,FriendFragment其实类似:

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    
    public class FriendFragment extends Fragment
    {
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		return inflater.inflate(R.layout.fragment_friend, container, false);
    	}
    
    }
    

    效果图:


    可以看到很好的实现了效果,其实这个效果以前的博客中也出现过,在博客:Android项目Tab类型主界面大总结 Fragment+TabPageIndicator+ViewPager,有兴趣可以看看。ps:为了代码的简洁,就不添加按钮的点击变化什么的了,主要讲解功能了~~~

    5、Fragment家族常用的API

    Fragment常用的三个类:

    android.app.Fragment 主要用于定义Fragment

    android.app.FragmentManager 主要用于在Activity中操作Fragment

    android.app.FragmentTransaction 保证一些列Fragment操作的原子性,熟悉事务这个词,一定能明白~

    a、获取FragmentManage的方式:

    getFragmentManager() // v4中,getSupportFragmentManager

    b、主要的操作都是FragmentTransaction的方法

    FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务

    transaction.add() 

    往Activity中添加一个Fragment

    transaction.remove()

    从Activity中移除一个Fragment,如果被移除的Fragment没有添加到回退栈(回退栈后面会详细说),这个Fragment实例将会被销毁。

    transaction.replace()

    使用另一个Fragment替换当前的,实际上就是remove()然后add()的合体~

    transaction.hide()

    隐藏当前的Fragment,仅仅是设为不可见,并不会销毁

    transaction.show()

    显示之前隐藏的Fragment

    detach()

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

    attach()

    重建view视图,附加到UI上并显示。

    transatcion.commit()//提交一个事务

    注意:常用Fragment的哥们,可能会经常遇到这样Activity状态不一致:State loss这样的错误。主要是因为:commit方法一定要在Activity.onSaveInstance()之前调用。

    上述,基本是操作Fragment的所有的方式了,在一个事务开启到提交可以进行多个的添加、移除、替换等操作。

    值得注意的是:如果你喜欢使用Fragment,一定要清楚这些方法,哪个会销毁视图,哪个会销毁实例,哪个仅仅只是隐藏,这样才能更好的使用它们。

    a、比如:我在FragmentA中的EditText填了一些数据,当切换到FragmentB时,如果希望会到A还能看到数据,则适合你的就是hide和show;也就是说,希望保留用户操作的面板,你可以使用hide和show,当然了不要使劲在那new实例,进行下非null判断。

    b、再比如:我不希望保留用户操作,你可以使用remove(),然后add();或者使用replace()这个和remove,add是相同的效果。

    c、remove和detach有一点细微的区别,在不考虑回退栈的情况下,remove会销毁整个Fragment实例,而detach则只是销毁其视图结构,实例并不会被销毁。那么二者怎么取舍使用呢?如果你的当前Activity一直存在,那么在不希望保留用户操作的时候,你可以优先使用detach。


    上述已经介绍完成了Fragment常用的一些方法,相信看完,大家一定清楚了Fragment的产生理由,以及如何使用Fragment,再根据API的讲解,也能明白,曾经为何觉得Fragment会出现一些列乱七八槽的问题,终究是因为没有弄清楚其生命周期。

    由于篇幅原因,剩下的内容留到下一篇了。在下一篇,会介绍:

    1、如何管理Fragment回退栈

    2、Fragment如何与Activity交互

    3、Fragment与Activity交互的最佳实践

    4、没有视图的Fragment的用处

    5、使用Fragment创建对话框

    6、如何与ActionBar,MenuItem集成等~~


    下一篇:Android Fragment 真正的完全解析(下)


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





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



    展开全文
  • Fragment详解之三——管理Fragment(1)

    万次阅读 多人点赞 2015-04-07 23:00:47
    前言:follow your heart,be your own king 相关文章: 1、《Fragment详解之一——概述》 2、《Fragment详解之二——基本使用方法》 ...5、《Fragment详解之五——Fragment间参数传递》6、《Frag...

    前言:follow your heart,be your own king

     

     

    相关文章:

    1、《Fragment详解之一——概述》
    2、《Fragment详解之二——基本使用方法》
    3、《Fragment详解之三——管理Fragment(1)》
    4、《Fragment详解之四——管理Fragment(2)》
    5、《Fragment详解之五——Fragment间参数传递》
    6、《Fragment详解之六——如何监听fragment中的回退事件与怎样保存fragment状态》

     

    前面给大家稍微看了要怎么使用fragment,在上篇中,我们也初步接触到了add,replace这些fragment操作的函数,下面就再详细讲讲如何管理Fragment页面吧。

     

    一、概述

     1、FragmentManager

    要管理activity中的fragments,你就需要使用FragmentManager。通过getFragmentManager()或getSupportFragmentManager()获得
    常用的方法有:

     

    manager.findFragmentById();  //根据ID来找到对应的Fragment实例,主要用在静态添加fragment的布局中,因为静态添加的fragment才会有ID
    manager.findFragmentByTag();//根据TAG找到对应的Fragment实例,主要用于在动态添加的fragment中,根据TAG来找到fragment实例
    manager.getFragments();//获取所有被ADD进Activity中的Fragment

    2、FragmentTransaction

     

    一般用来对当前的Fragment进行管理,包括add,replace,remove;
    常用的针对Fragment的方法有:

     

     

     

    //将一个fragment实例添加到Activity的最上层
    add(int containerViewId, Fragment fragment, String tag);
    //将一个fragment实例从Activity的fragment队列中删除
    remove(Fragment fragment);
    //替换containerViewId中的fragment实例,注意,它首先把containerViewId中所有fragment删除,然后再add进去当前的fragment
    replace(int containerViewId, Fragment fragment);

    还有hide()、show()、detach()、attach()这些函数,我们下篇再讲,这节先对Fragment的用法有一个初步了解;

    二、add()、replace()、remove()使用方法示例

     

    下面就通过例子来看看以上几个函数的使用方法吧。
    效果图如下:

    • 点击“ADD Fragment1”,在将Fragment1添加到Activity的container中;
    • 点击“ADD Fragment2”,将Fragment2添加到Activity的container中;
    • 点击“Remove Fragment2”,将Fragment2的实例从container中移除,移除之后,就显示出其下方的fragment1的视图出来了。
    • 再点击”replace Fragment1”,将container中的视图移除,然后添加上fragment2的视图。 

     

    那现在我们从头开始构建这个工程:

     

    1、新建两个fragment1.xml 和 fragment2.xml:

     

    从效果图中也可以看出,这两个XML什么都没有,只是通过背景色和文字来区别当前是哪个Fragment的XML布局文件而已,他们的布局代码如下:

    fragment1.xml:

     

     

     

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#ff00f0"
        android:orientation="vertical" >
        
        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="This is fragment 1"
            android:textColor="#000000"
            android:textSize="25sp" />
    
    </LinearLayout>

    fragment2.xml:

     

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:background="#ffff00"
        android:orientation="vertical" >
        
        <TextView
            android:id="@+id/fragment2_tv"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="This is fragment 2"
            android:textColor="#000000"
            android:textSize="25sp" />
        
    </LinearLayout>

    2、建立对应的Fragment类:Fragment1和Fragment2

     

    Fragment1:

     

     

     

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

    与上一篇一样,也只是在onCreateView()时返回对应的布局。同样,Fragment2的定义如下:

    import android.os.Bundle;
    import android.support.v4.app.Fragment;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    
    public class Fragment2 extends Fragment {
        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                                 Bundle savedInstanceState) {
            return inflater.inflate(R.layout.fragment2, container, false);
        }
    }

    3、MainActivity的布局

     

    从上面的的效果图中也可以看出大概的布局,首先是三个Button,最下方是一个FrameLayout布局,它是用来做为container动态盛装fragment的;它就像是一个占位符,你设置多大,它其中的fragment就最大能有多大。记住,fragment也是Activity中的一个普通控件而已,只不过它可以像Activity一样用于显示的同时还能用来盛装其它控件!作为fragment的容器,即可以用FrameLayout也可以用LinearLayout或者RelativeLayout,都是一样的。activity_main.xml的布局代码如下:

     

     

     

    <LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:orientation="vertical">
    
        <Button
            android:id="@+id/btn_add_frag1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="ADD  Fragment1" />
    
        <Button
            android:id="@+id/btn_add_frag2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="ADD  Fragment2" />
    
        <Button
            android:id="@+id/btn_remove_frag2"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="Remove  Fragment2" />
    
        <Button
            android:id="@+id/btn_repalce_frag1"
            android:layout_width="match_parent"
            android:layout_height="wrap_content"
            android:text="replace  Fragment1" />
    
        <FrameLayout
            android:id="@+id/fragment_container"
            android:layout_width="match_parent"
            android:layout_height="match_parent"/>
    
    </LinearLayout>

    4、MainActivity的实现:

    (1)首先,先写一个添加fragment到Activity中的函数:

     

     

    private void addFragment(Fragment fragment, String tag) {
        FragmentManager manager = getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.add(R.id.fragment_container, fragment, tag);
        transaction.commit();
    }
    • 先是传进来两个参数,一个是要添加的fragment实例,另一个是一个TAG
    • 至于FragmentManager、FragmentTransaction就没什么好讲的,这是这么个流程,要获取它们的实例就得调用这些函数。
    • 然后是add(R.id.fragment_container, fragment, tag)函数:第一个参数是要将fragment盛装的container,即我们上面的FrameLayout!第三个参数是tag,当传进去这个TAG,它就会跟这个fragment关联起来,当我们通过findFragmentByTag()时,根据这个TAG就能找到这个Fragment实例。进而对它进行操作,比如,我们下面的remove();
    • 在通过transaction对Fragment操作完以后,一定要记得调用transaction.commit(),这样才会将操作提交到系统中,这里的代码才会最终起作用。

     

    有没有觉得这个流程挺像数据库的回滚操作!对,其实就是这样的,这里其实就是一个针对Fragment的回滚操作,首先通过beginTransaction()来定义回滚的开始,然后通过transaction对Fragment进行一系列操作(我们这里只是进行了ADD,其实可以做一串操作),等操作完了利用commit()提交。这里就先初步讲到这,下节会细讲有关transaction的回滚过程。
    (2)添加Fragment1和Fragment2:
    好了,上面我们写好了一个函数addFragment(Fragment fragment, String tag),下面我们就要通过这个函数来添加Fragment1和Fragment2的实例了。
    当点击“ADD Fragment1”按钮时:

     

    Fragment1 fragment1 = new Fragment1();
    addFragment(fragment1, "fragment1");

    当点击“ADD Fragment2”按钮时:

    Fragment2 fragment2 = new Fragment2();
    addFragment(fragment2, "fragment2");

    这里需要注意的是,当我们添加每个Fragment实例时,都传进去一个对应的TAG,fragment1对应的是“fragment1”,fragment2对应的是“fragment2”,通过这些TAG,我们就可以通过findFragmentByTag()来获取它们了。
    (3)RemoveFragment2:
    下面就是当点击“RemoveFragment2”按钮时的代码操作了:

    private void removeFragment2() {
        FragmentManager manager = getSupportFragmentManager();
        Fragment fragment = manager.findFragmentByTag("fragment2");
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.remove(fragment);
        transaction.commit();
    }

    首先是通过

    Fragment fragment = manager.findFragmentByTag("fragment2");

    找到我们当时ADD进Activity的fragment2实例,然后通过transaction.remove(fragment);将它删除;从效果图中可以看到,由于我们移除了fragment2的实例,而又由于fragment2是在界面最上方的,所以把它删除了之后,自然就剩下了fragment1在最上方了,所以我们就看到了fragment1的界面。那如果我们移除的是fragment1呢?答案是界面没有任何变化!因为fragment1的实例是在fragment2的下方的,我们是根本看不到它的。
    (4)ReplaceFragment1:

    最后一个操作:ReplaceFragment1:

    咱们先回到上面的RemoveFragment2操作,在RemoveFragment2之后,要知道我们的Activity的ADD队列中,就只有fragment1了。知道这一点之后,咱们看下面ReplaceFragment1的代码:

    private void replaceFragment1() {
        FragmentManager manager = getSupportFragmentManager();
        Fragment2 fragment2 = new Fragment2();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.replace(R.id.fragment_container, fragment2);
        transaction.commit();
    }

    这里有个注意的问题:

    transaction.replace(R.id.fragment_container, fragment2);

    这里replace传进去的第一个参数是容器ID,第二个参数是要新增的fragment。既然要replace(),那它是针对哪个fragment进行replace()呢?怎么没有指定要替换的fragment!为什么这里的第一个参数是盛装Activity中所有Fragment的container的ID呢?没错,这里的replace操作会把这个cotainer中所有fragment清空!!!!然后再把fragment2添加进去!
    从上面的的讲解,大家可能也已经觉查到FragmentTransaction的Add()操作是维持着一个队列的,在这个队列中,根据ADD进去的先后顺序形成了一个链表,我们上面的操作在这个列表中的形式变化如下图所示:

    源码在文章最底部给出

    到这里add,replace,remove的使用方法就讲完了,但这里有个问题,必须根大家讲一下:我们上面说过replace操作会把container中的所有fragment全部删除,然后再将指定的fragment添加进去!但Android在实现时出现了BUG!在replace()时,并不能把以前所有Fragment清空,就因为这个系统工程产了BUG就会导致add()和Replace()不能共用!关于add()和Replace()不能共用的问题,我们会在下篇再讲。下面先给大家说说有关回滚的问题。

    三、有关回滚——FragmentTransaction

    1、FragmentTransaction事务回滚使用方法:

     

    上部分,我们讲了有关添加、删除Fragment的操作,想将上一次commit的操作返回时,要怎么做呢。这就需要FragmentTransaction的回滚功能了。
    要使用回滚功能,只需要要使用下面两个代码:
    在transaction.commit()之前,使用addToBackStack()将其添加到回退栈中。

     

     

     

    transaction.addToBackStack(String tag);

    在需要回退时,使用popBackStack()将最上层的操作弹出回退栈。

    manager.popBackStack();

    这里的popBackStack()是弹出默认的最上层的栈顶内容。
    当栈中有多层时,我们可以根据id或TAG标识来指定弹出到的操作所在层。函数如下:

    void popBackStack(int id, int flags);
    void popBackStack(String name, int flags);

    其中

    • 参数int id是当提交变更时transaction.commit()的返回值。
    • 参数string name是transaction.addToBackStack(String tag)中的tag值;
    • 至于int flags有两个取值:0或FragmentManager.POP_BACK_STACK_INCLUSIVE;
    • 当取值0时,表示除了参数一指定这一层之上的所有层都退出栈,指定的这一层为栈顶层; 
    • 当取值POP_BACK_STACK_INCLUSIVE时,表示连着参数一指定的这一层一起退出栈; 
    • 除了这几个函数,还有下面几个函数:有关他们的使用,我们在这小部分结尾时会提到
    popBackStackImmediate()
    popBackStackImmediate(String tag)
    popBackStackImmediate(String tag, int flag)
    popBackStackImmediate(int id, int flag)

    下面我们就通过一个例子来讲解一下有关回退栈中的操作过程:

    先看下效果图:

    整体流程是这样的:
    1、逐个将Fragment1,2,3,4添加到窗口中,在添加时,每添加一个Fragment要利用transaction的addToBackStack将此次操作加入到回退栈中。
    2、然后点击"PopBackStack"方法,将栈顶最上层的操作回退。退将最后一次添加回退出来,显示Fragment3.
    3、点击“ADD Fragment4”将栈还原到1,2,3,4依次ADD进栈的状态,即操作1完成后的栈状态,然后点击“BackToStack2_0”,其实调用的方法是:

    manager.popBackStack("fragment2",0);//方法一,通过TAG回退

    从这里可以看出,要回退到添加ADD Fragment2的状态,注意最后一个参数,这里设为0,表明,要回退ADD Fragment2的之后的操作,将ADD Fragment2的操作置为栈顶。从效果图中也可以看出,点击后的视图在Fragment2的位置
    4、最后仍然是先点击"Add Fragment3"和"ADD Fragment4",将栈还原到操作1完成后的栈状态。然后点击“BackToStack2_INCLUSIVE”;其调用的方法是:

    manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退

    这里与上面的主要不同点在于第二个参数,这里设置为POP_BACK_STACK_INCLUSIVE,即在出栈时连带ADD Fragment2的操作一块出栈,放在栈顶的是ADD Fragment1的操作,所以放在界面上就是显示的是Fragment1的视图。
    下面我们看看具体实现:
    (1)、首先,与上部分一样,先添加四个Fragment,并用背景色和文字来区分。这部分代码我们就不讲了。
    主要看看点击按钮的代码处理方法。
    (2)、首先是添加Fragment1:

     

    Fragment1 fragment1 = new Fragment1();
    stackID1 = addFragment(fragment1,"fragment1");

    其中:

     

    private int stackID1,stackID2,stackID3,stackID4;
    private int addFragment(Fragment fragment,String stackName){
        FragmentManager manager = getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.add(R.id.fragment_container,fragment);
        transaction.addToBackStack(stackName);
        return transaction.commit();
    }

    首先,这里的stackID1,stackID2,stackID3,stackID4是用来保存每次commit()后返回的Transaction的ID值。在void popBackStack(int id, int flags);时,其中的参数id就是这个值
    然后在每次ADD操作后,利用addToBackStack(string name)将每次ADD操作添加进回退栈中;
    同样,添加Fragment2的代码如下,添加Fragment3,Fragment4的方法同理

    Fragment2 fragment2 = new Fragment2();
    stackID2 = addFragment(fragment2,"fragment2");

    (3)、然后是回退栈顶内容:

     

    private void popBackStack(){
        FragmentManager manager = getSupportFragmentManager();
        manager.popBackStack();
    }

    (4)、接着是点击BackToFrag2_0按钮的内容,这里有两种方法实现,一种是指定TAG,一种是利用Commit()返回的ID

     

    private void popBackStackToFrag2_0(){
    	FragmentManager manager = getSupportFragmentManager();
    	manager.popBackStack("fragment2",0);//方法一,通过TAG回退
    	// manager.popBackStack(stackID2,0);//方法二,通过Transaction ID回退
    }

    (5)、最后是点击BackToFrag2_INCLUSIVE按钮的代码:

     

    private void popBackStackToFrag2_Inclusive(){
        FragmentManager manager = getSupportFragmentManager();
        manager.popBackStack("fragment2",FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法一,通过TAG回退
    // manager.popBackStack(stackID2,FragmentManager.POP_BACK_STACK_INCLUSIVE);//方法二,通过Transaction ID回退
    }

    好了,到这里,有关回滚的基本使用就结束了,需要要注意的是:
    使用popBackStack()来弹出栈内容的话,调用该方法后会将事物操作插入到FragmentManager的操作队列,只有当轮询到该事物时才能执行。如果想立即执行事物的话,需要使用下面几个对应的方法:

     

    popBackStackImmediate()
    popBackStackImmediate(String tag)
    popBackStackImmediate(String tag, int flag)
    popBackStackImmediate(int id, int flag)

    2、回退栈(back stack)状态改变监听

     

    FragmentManager还为我们提供了监控回退栈状态改变的方法:

     

     

     

    FragmentManager::addOnBackStackChangedListener(listener);//添加监听器
    FragmentManager::removeOnBackStackChangedListener(listener);//移除监听器

    通过添加监听器,就可以在回退栈内容改变时,及时收到通知;
    我们在上面代码的基础上,在MainAcitivy中为FragmentManager添加一个监听器,当回退栈状态改变时,打出一个LOG。具体实现如下:
    (1)、OnCreate()中:
    为fragmentManger添加一个监听器:

    FragmentManager manager = getSupportFragmentManager();
    listener = new FragmentManager.OnBackStackChangedListener() {
    	
    	@Override
    	public void onBackStackChanged() {
    		// TODO Auto-generated method stub
    		Log.d("qijian","backstack changed");
    	}
    };
    manager.addOnBackStackChangedListener(listener);

    (2)、当onDestory()中将监听器remove掉:

     

    protected void onDestroy() {
    	// TODO Auto-generated method stub
    	super.onDestroy();
    	FragmentManager manager = getSupportFragmentManager();
    	manager.removeOnBackStackChangedListener(listener);
    }

    大家一定要注意,不管是这里的回退栈的监听还是其它的监听器,在页面对应的销毁时,都要记得remove掉,不然会造成页面不释放,这也是造成OOM的问题之一。

    这样当回退栈内容出现变动时,变会打LOG出来,如图:

    源码在文章底部给出

    3、Transaction事务回退的原则

    这里我们着重讲一下,回退是以commit()提交的一次事务为单位的,而不是以其中的add,replace等等操作为单位回退的,即,如果我们在一次提交是添加了fragment2,fragment3,fragment4,那么回退时,会依据添加时的顺序,将它们一个个删除,返回到没有添加fragment4,fragment3,fragment2的状态。
    下面我们仍然写一个例子来讲明一下事务的回退原则,效果图如下:

    • 1、首先,添加Fragment1,提交一次事务
    • 2、然后,一次添加Fragment2,Fragment3,Fragment4,然后提交一次事务
    • 3、利用popBackStack()将顶层事务出栈,可以看到把Fragment2,Fragment3,Fragment4一次出栈,界面显示在了Fragment1的位置,这就充分说明了,回滚是以提交的事务为单位进行的!

     

    下面是代码实现部分:
    1、同样,新建四个Fragment,分别利用背景色和文字来表明之间的不同。
    2、然后添加Fragment1的代码如下:

     

    private void addFragment1() {
        Fragment1 fragment1 = new Fragment1();
        FragmentManager manager = getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.add(R.id.fragment_container, fragment1);
        transaction.addToBackStack("fragment1");
        transaction.commit();
    }

    3、然后是添加其它三个Fragment的代码如下:

     

    private void addOtherFragments() {
        Fragment2 fragment2 = new Fragment2();
        Fragment3 fragment3 = new Fragment3();
        Fragment4 fragment4 = new Fragment4();
        FragmentManager manager = getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.add(R.id.fragment_container, fragment2);
        transaction.add(R.id.fragment_container, fragment3);
        transaction.add(R.id.fragment_container, fragment4);
        transaction.addToBackStack("other fragments");
        transaction.commit();
    }

    再一次重申,从代码中也可以看到,是依次将Fragment2、Fragment3、Fragment4加入容器之后,再提交一次事务,所以下面回滚时,会将他们反顺序的依次删除。即remove(fragment4)、remove(fragment3)、remove(fragment2)
    4、点击popBackStack按钮时的代码

     

    private void popBackStack() {
        FragmentManager manager = getSupportFragmentManager();
        manager.popBackStack();
    }

     

     

    好了,到这里这篇文章就结束了,这篇文章太TM长了……大家估计看得也快要吐了……知识点太多,又想能给大家讲的浅显易懂就只有拉长篇幅了……

     

    源码中有三个工程:
    1、《harvicBlog3_1》:对应第二部分:add()、replace()、remove()使用方法示例
    2、《harvicBlog3_2》:对应第三部分《有关回滚——FragmentTransaction》中的:FragmentTransaction事务回滚使用方法和回退栈内容监听部分
    3、《harvicBlog3_3》:对应第三部分《有关回滚——FragmentTransaction》中的:Transaction事务回退的原则部分

     

    如果本文有帮到你,记得加关注哦

    源码下载地址:http://download.csdn.net/detail/harvic880925/8578519

    请大家尊重原创者版权,转载请标明出处:http://blog.csdn.net/harvic880925/article/details/44927375, 谢谢!

     

    如果你喜欢我的文章,你可能更喜欢我的公众号

    启舰杂谈

    展开全文
  • Android Fragment 真正的完全解析(下)

    万次阅读 多人点赞 2014-07-21 09:09:56
    上篇博客中已经介绍了Fragment产生原因,以及一些基本的用法和各种API,如果你还不了解,请看:Android Fragment 真正的完全解析(上)。 本篇将介绍上篇博客提到的:如何管理Fragment回退栈,Fragment如何与...

    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/37992017

    上篇博客中已经介绍了Fragment产生原因,以及一些基本的用法和各种API,如果你还不了解,请看:Android Fragment 真正的完全解析(上)

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

    1、管理Fragment回退栈

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

    看这样一个效果图:


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

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

    FragmentTransaction.addToBackStack(String)

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

    先看Activity的布局文件:

    <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
        xmlns:tools="http://schemas.android.com/tools"
        android:layout_width="match_parent"
        android:layout_height="match_parent" >
    
        <FrameLayout
            android:id="@+id/id_content"
            android:layout_width="fill_parent"
            android:layout_height="fill_parent" >
        </FrameLayout>
    
    </RelativeLayout>
    不同的Fragment就在这个FrameLayout中显示。

    MainActivity.java

    package com.zhy.zhy_fragments;
    
    import android.app.Activity;
    import android.app.FragmentManager;
    import android.app.FragmentTransaction;
    import android.os.Bundle;
    import android.view.Window;
    
    public class MainActivity extends Activity
    {
    
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState)
    	{
    		super.onCreate(savedInstanceState);
    		requestWindowFeature(Window.FEATURE_NO_TITLE);
    		setContentView(R.layout.activity_main);
    
    		FragmentManager fm = getFragmentManager();
    		FragmentTransaction tx = fm.beginTransaction();
    		tx.add(R.id.id_content, new FragmentOne(),"ONE");
    		tx.commit();
    	}
    
    }
    
    很简单,直接将FragmentOne添加到布局文件中的FrameLayout中,注意这里并没有调用FragmentTransaction.addToBackStack(String),因为我不喜欢在当前显示时,点击Back键出现白板。而是正确的相应Back键,即退出我们的Activity.

    下面是FragmentOne

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.app.FragmentManager;
    import android.app.FragmentTransaction;
    import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.view.ViewGroup;
    import android.widget.Button;
    
    public class FragmentOne extends Fragment implements OnClickListener
    {
    
    	private Button mBtn;
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		View view = inflater.inflate(R.layout.fragment_one, container, false);
    		mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn);
    		mBtn.setOnClickListener(this);
    		return view;
    	}
    
    	@Override
    	public void onClick(View v)
    	{
    		FragmentTwo fTwo = new FragmentTwo();
    		FragmentManager fm = getFragmentManager();
    		FragmentTransaction tx = fm.beginTransaction();
    		tx.replace(R.id.id_content, fTwo, "TWO");
    		tx.addToBackStack(null);
    		tx.commit();
    
    	}
    
    }
    

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

    接下来FragmentTwo

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.app.FragmentManager;
    import android.app.FragmentTransaction;
    import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.view.ViewGroup;
    import android.widget.Button;
    
    public class FragmentTwo extends Fragment implements OnClickListener
    {
    
    	private Button mBtn ;
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		View view = inflater.inflate(R.layout.fragment_two, container, false);
    		mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn);
    		mBtn.setOnClickListener(this);
    		return view ; 
    	}
    	@Override
    	public void onClick(View v)
    	{
    		FragmentThree fThree = new FragmentThree();
    		FragmentManager fm = getFragmentManager();
    		FragmentTransaction tx = fm.beginTransaction();
    		tx.hide(this);
    		tx.add(R.id.id_content , fThree, "THREE");
    //		tx.replace(R.id.id_content, fThree, "THREE");
    		tx.addToBackStack(null);
    		tx.commit();
    	}
    
    
    }
    

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

    最后FragmentThree就是简单的Toast了:

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.view.ViewGroup;
    import android.widget.Button;
    import android.widget.Toast;
    
    public class FragmentThree extends Fragment implements OnClickListener
    {
    
    	private Button mBtn;
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		View view = inflater.inflate(R.layout.fragment_three, container, false);
    		mBtn = (Button) view.findViewById(R.id.id_fragment_three_btn);
    		mBtn.setOnClickListener(this);
    		return view;
    	}
    
    	@Override
    	public void onClick(View v)
    	{
    		Toast.makeText(getActivity(), " i am a btn in Fragment three",
    				Toast.LENGTH_SHORT).show();
    	}
    
    }
    

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

    这里极其注意一点:上面的整体代码不具有任何参考价值,纯粹为了显示回退栈,在后面讲解了Fragment与Activity通信以后,会重构上面的代码!

    2、Fragment与Activity通信

    因为所有的Fragment都是依附于Activity的,所以通信起来并不复杂,大概归纳为:

    a、如果你Activity中包含自己管理的Fragment的引用,可以通过引用直接访问所有的Fragment的public方法

    b、如果Activity中未保存任何Fragment的引用,那么没关系,每个Fragment都有一个唯一的TAG或者ID,可以通过getFragmentManager.findFragmentByTag()或者findFragmentById()获得任何Fragment实例,然后进行操作。

    c、在Fragment中可以通过getActivity得到当前绑定的Activity的实例,然后进行操作。

    注:如果在Fragment中需要Context,可以通过调用getActivity(),如果该Context需要在Activity被销毁后还存在,则使用getActivity().getApplicationContext()。

    3、Fragment与Activity通信的最佳实践

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

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

    首先看FragmentOne

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.view.ViewGroup;
    import android.widget.Button;
    
    public class FragmentOne extends Fragment implements OnClickListener
    {
    	private Button mBtn;
    
    	/**
    	 * 设置按钮点击的回调
    	 * @author zhy
    	 *
    	 */
    	public interface FOneBtnClickListener
    	{
    		void onFOneBtnClick();
    	}
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		View view = inflater.inflate(R.layout.fragment_one, container, false);
    		mBtn = (Button) view.findViewById(R.id.id_fragment_one_btn);
    		mBtn.setOnClickListener(this);
    		return view;
    	}
    
    	/**
    	 * 交给宿主Activity处理,如果它希望处理
    	 */
    	@Override
    	public void onClick(View v)
    	{
    		if (getActivity() instanceof FOneBtnClickListener)
    		{
    			((FOneBtnClickListener) getActivity()).onFOneBtnClick();
    		}
    	}
    
    }
    

    可以看到现在的FragmentOne不和任何Activity耦合,任何Activity都可以使用;并且我们声明了一个接口,来回调其点击事件,想要管理其点击事件的Activity实现此接口就即可。可以看到我们在onClick中首先判断了当前绑定的Activity是否实现了该接口,如果实现了则调用。

    再看FragmentTwo

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.view.ViewGroup;
    import android.widget.Button;
    
    public class FragmentTwo extends Fragment implements OnClickListener
    {
    
    	
    	private Button mBtn ;
    	
    	private FTwoBtnClickListener fTwoBtnClickListener ;
    	
    	public interface FTwoBtnClickListener
    	{
    		void onFTwoBtnClick();
    	}
    	//设置回调接口
    	public void setfTwoBtnClickListener(FTwoBtnClickListener fTwoBtnClickListener)
    	{
    		this.fTwoBtnClickListener = fTwoBtnClickListener;
    	}
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		View view = inflater.inflate(R.layout.fragment_two, container, false);
    		mBtn = (Button) view.findViewById(R.id.id_fragment_two_btn);
    		mBtn.setOnClickListener(this);
    		return view ; 
    	}
    	@Override
    	public void onClick(View v)
    	{
    		if(fTwoBtnClickListener != null)
    		{
    			fTwoBtnClickListener.onFTwoBtnClick();
    		}
    	}
    
    }
    

    与FragmentOne极其类似,但是我们提供了setListener这样的方法,意味着Activity不仅需要实现该接口,还必须显示调用mFTwo.setfTwoBtnClickListener(this)。

    最后看Activity :

    package com.zhy.zhy_fragments;
    
    import android.app.Activity;
    import android.app.FragmentManager;
    import android.app.FragmentTransaction;
    import android.os.Bundle;
    import android.view.Window;
    
    import com.zhy.zhy_fragments.FragmentOne.FOneBtnClickListener;
    import com.zhy.zhy_fragments.FragmentTwo.FTwoBtnClickListener;
    
    public class MainActivity extends Activity implements FOneBtnClickListener,
    		FTwoBtnClickListener
    {
    
    	private FragmentOne mFOne;
    	private FragmentTwo mFTwo;
    	private FragmentThree mFThree;
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState)
    	{
    		super.onCreate(savedInstanceState);
    		requestWindowFeature(Window.FEATURE_NO_TITLE);
    		setContentView(R.layout.activity_main);
    
    		mFOne = new FragmentOne();
    		FragmentManager fm = getFragmentManager();
    		FragmentTransaction tx = fm.beginTransaction();
    		tx.add(R.id.id_content, mFOne, "ONE");
    		tx.commit();
    	}
    
    	/**
    	 * FragmentOne 按钮点击时的回调
    	 */
    	@Override
    	public void onFOneBtnClick()
    	{
    
    		if (mFTwo == null)
    		{
    			mFTwo = new FragmentTwo();
    			mFTwo.setfTwoBtnClickListener(this);
    		}
    		FragmentManager fm = getFragmentManager();
    		FragmentTransaction tx = fm.beginTransaction();
    		tx.replace(R.id.id_content, mFTwo, "TWO");
    		tx.addToBackStack(null);
    		tx.commit();
    	}
    
    	/**
    	 * FragmentTwo 按钮点击时的回调
    	 */
    	@Override
    	public void onFTwoBtnClick()
    	{
    		if (mFThree == null)
    		{
    			mFThree = new FragmentThree();
    
    		}
    		FragmentManager fm = getFragmentManager();
    		FragmentTransaction tx = fm.beginTransaction();
    		tx.hide(mFTwo);
    		tx.add(R.id.id_content, mFThree, "THREE");
    		// tx.replace(R.id.id_content, fThree, "THREE");
    		tx.addToBackStack(null);
    		tx.commit();
    	}
    
    }
    

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

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

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

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

    好了,下面看一段代码:

    Activity:

    package com.zhy.zhy_fragments;
    
    import android.app.Activity;
    import android.app.FragmentManager;
    import android.app.FragmentTransaction;
    import android.os.Bundle;
    import android.view.Window;
    
    public class MainActivity extends Activity
    
    {
    	private FragmentOne mFOne;
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState)
    	{
    		super.onCreate(savedInstanceState);
    		requestWindowFeature(Window.FEATURE_NO_TITLE);
    		setContentView(R.layout.activity_main);
    
    		mFOne = new FragmentOne();
    		FragmentManager fm = getFragmentManager();
    		FragmentTransaction tx = fm.beginTransaction();
    		tx.add(R.id.id_content, mFOne, "ONE");
    		tx.commit();
    
    	}
    
    }
    

    Fragment

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    
    public class FragmentOne extends Fragment
    {
    	private static final String TAG = "FragmentOne";
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		Log.e(TAG, "onCreateView");
    		View view = inflater.inflate(R.layout.fragment_one, container, false);
    		return view;
    	}
    
    	@Override
    	public void onCreate(Bundle savedInstanceState)
    	{
    		// TODO Auto-generated method stub
    		super.onCreate(savedInstanceState);
    
    		Log.e(TAG, "onCreate");
    	}
    
    	@Override
    	public void onDestroyView()
    	{
    		// TODO Auto-generated method stub
    		super.onDestroyView();
    		Log.e(TAG, "onDestroyView");
    	}
    
    	@Override
    	public void onDestroy()
    	{
    		// TODO Auto-generated method stub
    		super.onDestroy();
    		Log.e(TAG, "onDestroy");
    	}
    
    }
    

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

    类似:

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

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

    那么如何解决呢:

    其实通过检查onCreate的参数Bundle savedInstanceState就可以判断,当前是否发生Activity的重新创建:

    默认的savedInstanceState会存储一些数据,包括Fragment的实例:通过打印可以看出:

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

    package com.zhy.zhy_fragments;
    
    import android.app.Activity;
    import android.app.FragmentManager;
    import android.app.FragmentTransaction;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.Window;
    
    public class MainActivity extends Activity
    
    {
    	private static final String TAG = "FragmentOne";
    	private FragmentOne mFOne;
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState)
    	{
    		super.onCreate(savedInstanceState);
    		requestWindowFeature(Window.FEATURE_NO_TITLE);
    		setContentView(R.layout.activity_main);
    
    		Log.e(TAG, savedInstanceState+"");
    		
    		if(savedInstanceState == null)
    		{
    			mFOne = new FragmentOne();
    			FragmentManager fm = getFragmentManager();
    			FragmentTransaction tx = fm.beginTransaction();
    			tx.add(R.id.id_content, mFOne, "ONE");
    			tx.commit();
    		}
    		
    		
    
    	}
    
    }
    

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

    现在还存在一个问题,就是重新绘制时,Fragment发生重建,原本的数据如何保持?

    其实和Activity类似,Fragment也有onSaveInstanceState的方法,在此方法中进行保存数据,然后在onCreate或者onCreateView或者onActivityCreated进行恢复都可以。

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

    5、Fragmeny与ActionBar和MenuItem集成

    Fragment可以添加自己的MenuItem到Activity的ActionBar或者可选菜单中。

    a、在Fragment的onCreate中调用 setHasOptionsMenu(true);

    b、然后在Fragment子类中实现onCreateOptionsMenu

    c、如果希望在Fragment中处理MenuItem的点击,也可以实现onOptionsItemSelected;当然了Activity也可以直接处理该MenuItem的点击事件。

    代码:

    Fragment

    package com.zhy.zhy_fragments;
    
    import android.app.Fragment;
    import android.os.Bundle;
    import android.view.LayoutInflater;
    import android.view.Menu;
    import android.view.MenuInflater;
    import android.view.MenuItem;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.Toast;
    
    public class FragmentOne extends Fragment
    {
    
    	@Override
    	public void onCreate(Bundle savedInstanceState)
    	{
    		super.onCreate(savedInstanceState);
    		setHasOptionsMenu(true);
    	}
    
    	@Override
    	public View onCreateView(LayoutInflater inflater, ViewGroup container,
    			Bundle savedInstanceState)
    	{
    		View view = inflater.inflate(R.layout.fragment_one, container, false);
    		return view;
    	}
    
    	@Override
    	public void onCreateOptionsMenu(Menu menu, MenuInflater inflater)
    	{
    		inflater.inflate(R.menu.fragment_menu, menu);
    	}
    
    	@Override
    	public boolean onOptionsItemSelected(MenuItem item)
    	{
    		switch (item.getItemId())
    		{
    		case R.id.id_menu_fra_test:
    			Toast.makeText(getActivity(), "FragmentMenuItem1", Toast.LENGTH_SHORT).show();
    			break;
    		}
    		return true;
    	}
    
    }
    

    Activity

    package com.zhy.zhy_fragments;
    
    import android.app.Activity;
    import android.app.FragmentManager;
    import android.app.FragmentTransaction;
    import android.os.Bundle;
    import android.util.Log;
    import android.view.Menu;
    import android.view.MenuItem;
    import android.view.Window;
    import android.widget.Toast;
    
    public class MainActivity extends Activity
    
    {
    	private static final String TAG = "FragmentOne";
    	private FragmentOne mFOne;
    
    	@Override
    	protected void onCreate(Bundle savedInstanceState)
    	{
    		super.onCreate(savedInstanceState);
    		requestWindowFeature(Window.FEATURE_NO_TITLE);
    		setContentView(R.layout.activity_main);
    
    		Log.e(TAG, savedInstanceState + "");
    
    		if (savedInstanceState == null)
    		{
    			mFOne = new FragmentOne();
    			FragmentManager fm = getFragmentManager();
    			FragmentTransaction tx = fm.beginTransaction();
    			tx.add(R.id.id_content, mFOne, "ONE");
    			tx.commit();
    		}
    
    	}
    
    	@Override
    	public boolean onCreateOptionsMenu(Menu menu)
    	{
    		super.onCreateOptionsMenu(menu);
    		getMenuInflater().inflate(R.menu.main, menu);
    		return true;
    	}
    
    	@Override
    	public boolean onOptionsItemSelected(MenuItem item)
    	{
    		switch (item.getItemId())
    		{
    		case R.id.action_settings:
    			Toast.makeText(this, "setting", Toast.LENGTH_SHORT).show();
    			return true;
    		default:
    			//如果希望Fragment自己处理MenuItem点击事件,一定不要忘了调用super.xxx
    			return super.onOptionsItemSelected(item);
    		}
    	}
    
    }
    

    效果图:

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

    6、没有布局的Fragment的作用

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

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

    7、使用Fragment创建对话框

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


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


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

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





    展开全文
  • Fragment详解之五——Fragment间参数传递

    万次阅读 多人点赞 2015-04-09 22:36:28
    前言:依然没有前言…… 相关文章: 1、《Fragment详解之一——概述》 2、《Fragment详解之二——基本...5、《Fragment详解之五——Fragment间参数传递》6、《Fragment详解之六——如何监听fragment中的回退...
  • Fragment嵌套Fragment

    千次阅读 2019-04-01 12:57:45
    问题1、fragment嵌套fragment不显示问题 通常时候,我们制作底部Tab切换,会用到fragment。即一个Activity下,使用4种fragment。这次遇到的问题是关于fragment再次嵌套fragmen的问题,功能需要在其中一个fragment中...
  • Android Fragment完全解析,关于碎片你所需知道的一切

    万次阅读 多人点赞 2013-05-07 09:33:45
    我们都知道,Android上的界面展示都是通过Activity实现的,Activity实在是太常用了,我相信大家都已经非常熟悉了,这里就不再赘述。 但是Activity也有它的局限性,同样的界面在...因此,我们今天的主角Fragment登场了
  • Fragment+FragmentTabHost实现仿新浪微博底部菜单栏效果(源码)
  • 至于fragment的用法,fragment+viewpager的滑动切换代码请参考博文 Android基础:翻页控件Viewpager的使用方法,viewpager+fragment混合使用 fragment与Activity 当在使用activity嵌套fragment,...
  • 前言:计划总是赶不上变化,无论结局怎样,只要一直跟随自己的内心,不放弃,总有...3、《Fragment详解之三——管理Fragment(1)》 4、《Fragment详解之四——管理Fragment(2)》 5、《Fragment详解之五——Fragme...
  • Fragment Fragment生命周期 Fragment详解 Fragment生命周期详解
  • fragment实现选项卡界面

    千次下载 热门讨论 2013-11-24 19:34:56
    在android 2.x时代,我们可能会地使用ActivityGroup来实现这种,但是随着jelly bean的市场份额超过50%,我们会发现有一种新的组建出现了,它叫Fragment...而这种底部选项卡的风格界面的实现也由ActivityGroup转向了...
  • Fragment里边嵌套Fragment

    万次阅读 2018-09-24 12:08:55
    一、如何切换Fragment ①、了解FragmentManager FragmentManager fm = getSupportFragmentManager(); 作用:管理Fragment的显示,存储。 FragmentManger中有三个容器。 第一个用来存储,Fragment的View,并控制...
  • Activity中加载不同的fragment /Fragment中加载不同的fragment主Activity中加载(切换)多个fragment(也可以理解为activity跳转fragment)或主fragment中加载(切换)多个fragmentActivity布局中要有一个fragment...
  • 跳转: 从一个Fragment跳转到另一个Fragment android从fragment跳转到...activity嵌套fragmentfragment内嵌fragment之间传值切换fragment 嵌套Fragment的使用及常见错误 android 布局中Fragment嵌套Fragmen...
  • ViewPager 详解(五)-----使用Fragment实现ViewPager滑动

    万次阅读 多人点赞 2014-08-18 15:03:51
    前言:前几篇文章讲解了ViewPager的普通实现方法,但android官方最推荐的一种实现方法却是使用fragment,下面我们使用fragment来重新实现一下第一篇《ViewPager 详解(一)---基本入门》所实现的效果。 系列文章...
  • Fragment详解之四——管理Fragment(2)

    万次阅读 多人点赞 2015-04-08 22:32:31
    前言:这篇依然没有前言…… 相关文章: 1、《Fragment详解之一——概述》 2、《Fragment详解之二——基本...5、《Fragment详解之五——Fragment间参数传递》6、《Fragment详解之六——如何监听fragment中的...
  • Android Fragment 你应该知道的一切

    万次阅读 多人点赞 2015-01-12 01:56:32
    转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/42628537,本文出自:【张鸿洋的博客】很久以前写过两篇Fragment的介绍,主要就是介绍其功能:Android Fragment 真正的完全解析(上)和Android...
  • 业务场景:有的时候我们的页面可能是Activity 嵌套多个Fragment ..其中某个Fragment 又嵌套多个Fragment。 其中某个子Fragment 定义为 NewsFragment 。父容器 Fragment 定义为 ShouYeMainFragment ...
  • 一个Activity中套着一个Fragment Fragment又用 viewPager+TabHost(这都2020了) 领导们还坚持着用TabHost viewPager里面又套着Fragment 需求是要:要在ViewPager里面第三个Fragment上的控件点击后切换到第二个Tab ....
  • FragmentFragment传值

    千次阅读 2019-01-07 18:08:33
    方式一:可以调用findFragmentById方法根据id获取到fragment的对象,调用fragment中的方法赋值 在LeftFragment传值 以下写法: RightFragment rightFragment = getFragmentManager().findFragmentById(R.id.fragm....
  • Fragment使用姿势之NoFragment

    万次阅读 多人点赞 2017-01-15 15:39:36
    NoFragment支持传统Fragment用法,支持startFragmentForResult,支持一个Fragment启动多个实例,自持自动维护Back Stack,顺序不会错乱,支持Fragment中直接setToolbar()、setTitle()、displayHomeButton()、支持...
  • Fragment 跳转到指定的Fragment 主要分为2中情况 1 同一个Activity上的Fragment 跳转到指定Fragment 例如MainActivity 上的Fragment 跳转问题 2 不在同一个Activity的2个Fragment 跳转 如果对Fragment 跳转问题...
  • 需求是 用ViewPager + Fragment(有3个Fragment) 实现页面滚动切换, 3个Fragment中其中有一个fragment中又嵌套了3个子fragment,最后滑动时, 界面出现了错位,要怎么解决
  • Fragment中嵌套Fragment

    千次阅读 2016-12-02 11:30:57
    fragment里面嵌套Fragment,最开始使用Fragment的hide,show等方法一直失败,,如图,message是一个fragment,在里面又有两个子fragment,(Firends和follow),后来把两个fragment改ViewPager方式进行切换,这
  • 现在的android主界面,普遍离不开FragmentActivity和Fragment。也经常会碰到这么一个问题,从其他界面跳回主界面时,无法分辨出回到了哪个fragment里面。一般我们会在fragment·的onResume 方法里面做一些处理,如果...
  • Android进阶(十二)Fragment VS Activity

    万次阅读 2015-06-14 21:11:14
     可以把Fragment想成Activity中的模块,这个模块有自己的布局,有自己的生命周期,单独处理自己的输入,在Activity运行的时候可以加载或者移除Fragment模块。  可以把Fragment设计成可以在多个Activity中复用
  • fragment怎么嵌套fragment

    2015-10-19 02:48:01
    我弄了一个fragment,底部有3个页面,在第一个页面再加fragment做一个顶部的滑动导航,可是加了顶部导航的代码之后,底部第一个页面的replace、add、show都出错了,应该怎么办!!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 71,750
精华内容 28,700
关键字:

fragment