经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 移动开发 » Android » 查看文章
Fragment基本使用
来源：cnblogs　　作者：yooooooo　　时间：2021/4/19 8:40:51　　对本文有异议

1. Fragment概述

1.1 介绍

Fragment是一种可以嵌入在活动中的UI片段，能够让程序更加合理和充分地利用大屏幕的空间，出现的初衷是为了适应大屏幕的平板电脑，可以将其看成一个小型Activity，又称作Activity片段。

使用Fragment可以把屏幕划分成几块，然后进行分组，进行一个模块化管理。Fragment不能够单独使用，需要嵌套在Activity中使用，其生命周期也受到宿主Activity的生命周期的影响

官方定义如下：

A Fragment represents a behavior or a portion of user interface in an Activity. You can combine multiple fragments in a single activity to build a multi-pane UI and reuse a fragment in multiple activities. You can think of a fragment as a modular section of an activity, which has its own lifecycle, receives its own input events, and which you can add or remove while the activity is running.

从官方的定义可以得到：

  • Fragment依赖于Activity，不能独立存在
  • 一个Activity可以有多个Fragment
  • 一个Fragment可以被多个Activity重用
  • Fragment有自己的生命周期，并能接收输入事件
  • 可以在Activity运行时动态地添加或删除Fragment

Fragment的优势：

  • 模块化（Modularity）：我们不必把所有代码全部写在Activity中，而是把代码写在各自的Fragment中。
  • 可重用（Reusability）：多个Activity可以重用一个Fragment。
  • 可适配（Adaptability）：根据硬件的屏幕尺寸、屏幕方向，能够方便地实现不同的布局，这样用户体验更好。

1.2 Fragment基本生命周期

image

Fragment的一般生命周期如上图所示：

  • onAttach()：Fragment和Activity相关联时调用。可以通过该方法获取Activity引用，还可以通过getArguments()获取参数。
  • onCreate()：Fragment被创建时调用
  • onActivityCreated()：当Activity完成onCreate()时调用
  • onStart()：当Fragment可见时调用。
  • onResume()：当Fragment可见且可交互时调用
  • onPause()：当Fragment不可交互但可见时调用。
  • onStop()：当Fragment不可见时调用。
  • onDestroyView()：当Fragment的UI从视图结构中移除时调用。
  • onDestroy()：销毁Fragment时调用。
  • onDetach()：当Fragment和Activity解除关联时调用。

Fragment生命周期会经历：运行、暂停、停止、销毁。

  • 运行状态：碎片可见时，关联活动处于运行状态，其也为运行状态
  • 暂停状态：活动进入暂停状态，相关联可见碎片就会进入暂停状态
  • 停止状态：活动进入停止状态，相关联碎片就会进入停止状态，或者通过FragmentTransaction的remove()、replace()方法将碎片从从活动中移除，但如果在事务提交之前调用addToBackStack()方法，这时的碎片也会进入到停止状态。
  • 销毁状态：当活动被销毁，相关联碎片进入销毁状态。或者调用FragmentTransaction的remove()、replace()方法将碎片从活动中移除，但在事务提交之前并没有调用addToBackStack()方法，碎片也会进入到销毁状态。

在介绍Fragment的具体使用时，先介绍一下Fragment的几个核心类

  • Fragment：Fragment的基类，任何创建的Fragment都需要继承该类
  • FragmentManager：管理和维护Fragment。他是抽象类，具体的实现类是FragmentManagerImpl。
  • FragmentTransaction：对Fragment的添加、删除等操作都需要通过事务方式进行。他是抽象类，具体的实现类是BackStackRecord

扩展子类：

  • 对话框：DialogFragment
  • 列表：ListFragment
  • 选项设置：PreferenceFragment
  • WebView界面：WebViewFragment

备注：开发Fragment不建议使用android.app下的Fragment而应是android:support.v4.app，因为support库是不断更新的。

2. Fragment使用

使用Fragment有两种方式，分别是静态加载和动态加载

2.1 静态加载

关于静态加载的流程如下：

  • 定义Fragment的xml布局文件
  • 自定义Fragment类，继承Fragment类或其子类，同时实现onCreate()方法，在方法中，通过inflater.inflate加载布局文件，接着返回其View
  • 在需要加载Fragment的Activity对应布局文件中的name属性设为全限定类名，即包名.fragment
  • 最后在Activity调用setContentView()加载布局文件即可

静态加载一旦添加就不能在运行时删除

示例：

  • 定义Fragment布局，新建left_fragment.xml和right_fragment.xml文件
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout
  3.     xmlns:android="http://schemas.android.com/apk/res/android"
  4.     android:layout_width="match_parent"
  5.     android:layout_height="match_parent"
  6.     android:orientation="vertical">
  8.     <Button
  9.         android:id="@+id/button"
  10.         android:layout_width="wrap_content"
  11.         android:layout_height="wrap_content"
  12.         android:layout_gravity="center_horizontal"
  13.         android:text="Button" />
  14. </LinearLayout>
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <LinearLayout
  3.     xmlns:android="http://schemas.android.com/apk/res/android"
  4.     android:orientation="vertical"
  5.     android:background="#00ff00"
  6.     android:layout_width="match_parent"
  7.     android:layout_height="match_parent">
  9.     <TextView
  10.         android:layout_width="wrap_content"
  11.         android:layout_height="wrap_content"
  12.         android:layout_gravity="center_horizontal"
  13.         android:textSize="20sp"
  14.         android:text="this is Fragment" />
  16. </LinearLayout>
  • 自定义Fragment类，继承Fragment或其子类，重写onCreateView()，在方法中调用inflater.inflate()方法加载Fragment布局文件，接着返回加载的view对象
  1. public class LeftFragment extends Fragment {
  3.     @Override
  4.     public View onCreateView(LayoutInflater inflater, ViewGroup container,
  5.                              Bundle savedInstanceState) {
  6.         View view = inflater.inflate(R.layout.left_fragment, container,false);
  7.         return view;
  8.     }
  10. }
  1. public class RigthFragment extends Fragment {
  3.     @Nullable
  4.     @Override
  5.     public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
  6.         View view = inflater.inflate(R.layout.right_fragment, container, false);
  7.         return view;
  8.     }
  9. }
  • 在需要加载Fragment的Activity对应的布局文件中添加Fragment标签
  1. <fragment
  2.     android:id="@+id/left_fragment"
  3.     android:name="com.vivo.a11085273.secondfragmenttest.LeftFragment"
  4.     android:layout_width="0dp"
  5.     android:layout_height="match_parent"
  6.     android:layout_weight="1" />
  7. <fragment
  8.     android:id="@+id/right_fragment"
  9.     android:name="com.vivo.a11085273.secondfragmenttest.RigthFragment"
  10.     android:layout_width="0dp"
  11.     android:layout_height="match_parent"
  12.     android:layout_weight="1"
  13.     />
  • 在Activity的onCreate()方法中调用setContentView()加载布局文件即可

2.2 动态加载Fragment

动态加载Fragment的流程如下：

  • 获得FragmentManager对象，通过getSupportFragmentManager()
  • 获得FragmentTransaction对象，通过fm.beginTransaction()
  • 调用add()方法或者repalce()方法加载Fragment；
  • 最后调用commit()方法提交事务

简单示例：

  • 同静态加载一样，首先定义Fragment的布局和类，修改主布局文件，不指定标签的name属性。
  • 实现Fragment调用
  1. public class MainActivity extends AppCompatActivity implements View.OnClickListener {
  3.     @Override
  4.     protected void onCreate(Bundle savedInstanceState) {
  5.         super.onCreate(savedInstanceState);
  6.         setContentView(R.layout.activity_main);
  7.         Button button = (Button) findViewById(R.id.button);
  8.         button.setOnClickListener(this);
  9.         replaceFragment(new RigthFragment());
  10.     }
  12.     @Override
  13.     public void onClick(View v) {
  14.         switch (v.getId()) {
  15.             case R.id.button:
  16.                 replaceFragment(new AnotherRightFragment());
  17.                 break;
  18.             default:
  19.                 break;
  20.         }
  21.     }
  23.     private void replaceFragment(Fragment fragment) {
  24.         FragmentManager fragmentManager = getSupportFragmentManager();
  25.         FragmentTransaction transaction = fragmentManager.beginTransaction();   // 开启一个事务
  26.         transaction.replace(R.id.right_layout, fragment);
  27.         transaction.commit();
  28.     }
  29. }

2.3 使用注意点

  • Fragment的onCreateView()方法返回Fragment的UI布局，需要注意的是inflate()的第三个参数是false，因为在Fragment内部实现中，会把该布局添加到container中，如果设为true，那么就会重复做两次添加，则会抛如下异常：

Caused by: java.lang.IllegalStateException: The specified child already has a parent. You must call removeView() on the child’s parent first.

  • 如果在创建Fragment时要传入参数，必须要通过setArguments(Bundle bundle)方式添加，而不建议通过为Fragment添加带参数的构造函数，因为通过setArguments()方式添加，在由于内存紧张导致Fragment被系统杀掉并恢复（re-instantiate）时能保留这些数据

可以在Fragment的onAttach()中通过getArguments()获得传进来的参数。如果要获取Activity对象，不建议调用getActivity()，而是在onAttach()中将Context对象强转为Activity对象

示例：

  1. public class Fragment1 extends Fragment{
  2.     private static String ARG_PARAM = "param_key";
  3.     private String mParam;
  4.     private Activity mActivity;
  5.     public void onAttach(Context context) {
  6.         mActivity = (Activity) context;
  7.         mParam = getArguments().getString(ARG_PARAM);  //获取参数
  8.     }
  9.     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
  10.         View root = inflater.inflate(R.layout.fragment_1, container, false);
  11.         TextView view = root.findViewById(R.id.text);
  12.         view.setText(mParam);
  13.         return root;
  14.     }
  15.     public static Fragment1 newInstance(String str) {
  16.         Fragment1 frag = new Fragment1();
  17.         Bundle bundle = new Bundle();
  18.         bundle.putString(ARG_PARAM, str);
  19.         fragment.setArguments(bundle);   //设置参数
  20.         return fragment;
  21.     }
  22. }

  • 动态加载Fragment中，FragmentTransaction类提供了方法完成增删等操作，完成后调用FragmentTransaction.commit()方法提交修改

    • transaction.add()：往Activity里面添加一个片段
    • 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上并显示。

commit方法一定要在Activity.onSaveInstance()之前调用

commit()操作是异步的，内部通过mManager.enqueueAction()加入处理队列。对应的同步方法为commitNow()，commit()内部会有checkStateLoss()操作，如果开发人员使用不当（比如commit()操作在onSaveInstanceState()之后），可能会抛出异常，而commitAllowingStateLoss()方法则是不会抛出异常版本的commit()方法，但是尽量使用commit()，而不要使用commitAllowingStateLoss()。

  • FragmentManager拥有回退栈（BackStack），类似于Activity的任务栈，如果添加了该语句，就把该事务加入回退栈，当用户点击返回按钮，会回退该事务（回退指的是如果事务是add(frag1)，那么回退操作就是remove(frag1)）；如果没添加该语句，用户点击返回按钮会直接销毁Activity。

  • Fragment常见异常

java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState

at android.support.v4.app.FragmentManagerImpl.checkStateLoss(FragmentManager.java:1341)

at android.support.v4.app.FragmentManagerImpl.enqueueAction(FragmentManager.java:1352)

at android.support.v4.app.BackStackRecord.commitInternal(BackStackRecord.java:595)

at android.support.v4.app.BackStackRecord.commit(BackStackRecord.java:574)

出现原因：commit()在onSaveInstanceState()后调用。

由于onSaveInstanceState()在onPause()之后，onStop()之前调用。onRestoreInstanceState()在onStart()之后，onResume()之前，因此避免出现该异常的方案有：

  • 不要把Fragment事务放在异步线程的回调中
  • 逼不得已时使用commitAllowingStateLoss()

3. Fragment与Activity联动

image

Fragment和Activity完整的生命周期如上图所示

  1. 当Fragment在Activity的onCreate()中被添加时
  • Activity super.onCreate执行完毕
  • Fragment onAttach
  • Fragment onCreate
  • Fragment onCreateView
  • Fragment onViewCreated
  • Activity.super.onStart()执行中
  • Fragment onActivityCreated
  • Fragment onViewStateRestored
  • Fragment onStart()
  • Activity super.onStart执行完毕
  • Activity super.onPostCreate()
  • Activity super.onResume()
  • Activity super.onPostResume()执行中
  • Fragment onResume()
  • Activity super.onPosResume()执行完毕
  • Activity onAttachedToWindow()
  • Activity onCreateOptionsMenu()
  • Fragment onCreateOptionsMenu()
  • Activity onPrepareOptionsMenu()
  • Fragment onPrepareOptionsMenu()
  • Activity onWindowFocusChanged()
  1. 暂停生命周期
  • Activity super.onPause()执行中
  • Fragment.onPause()
  • Activity super.onPause()执行完毕
  • Activity super.onSaveInstanceState()执行中
  • Fragment onSaveInstanceState()
  • Activity super.onSaveInstanceState()执行完毕
  • Activity super.onStop()执行中
  • Fragment onStop()
  • Activity super.onStop()执行完毕
  1. 销毁的生命周期
  • Activity super.onDestroy()执行中
  • Fragment onDestroyView()
  • Fragment onDestroy()
  • Fragment onDetach()
  • Activity super.onDestroy()执行完毕
  1. 重启的生命周期
  • Activity super.onRestart()
  • Activity super.onStart()执行中
  • Fragment onStart()
  • Activity super.onStart()执行完毕
  • Activity super.onResume()
  • Activity super.onPostResume()执行中
  • Fragment onResume()
  • Activity super.onPosResume()执行完毕
  • Activity onWindowFocusChanged()执行完毕

3.1 回退栈

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

一旦Fragment完全从后退栈中弹出，用户再次点击后退键，则退出当前Activity

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

  1. FragmentTransaction.addToBackStack(String)

简单示例：

  1. private void replaceFragment(Fragment fragment) {
  2.     FragmentManager fragmentManager = getSupportFragmentManager();
  3.     FragmentTransaction transaction = fragmentManager.beginTransaction();
  4.     transaction.replace(R.id.right_layout, fragment);
  5.     transaction.addToBackStack(null);   //添加进回退栈
  6.     transaction.commit();
  7. }

replace是remove和add的合体，并且如果不添加事务到回退栈，前一个Fragment实例会被销毁。这里很明显，我们调用transaction.addToBackStack(null);将当前的事务添加到了回退栈，所以FragmentOne实例不会被销毁，但是视图层次依然会被销毁，即会调用onDestoryView和onCreateView

如果不希望视图重绘，可以将原来的Fragment隐藏：

  1. private void replaceFragment(Fragment fragment) {
  2.     FragmentManager fragmentManager = getSupportFragmentManager();
  3.     FragmentTransaction transaction = fragmentManager.beginTransaction();
  4.     transaction.hide(this);
  5.     transaction.add(R.id.right_layout, fragment);
  6.     transaction.addToBackStack(null);   //添加进回退栈
  7.     transaction.commit();
  8. }

4. Fragment与Activity通信

image

Fragment与Activity的通信交互如上图所示：

  • 如果Activity中包含自己管理的Fragment的引用，可以通过引用直接访问所有的Fragment的public方法
  • 如果Activity中未保存任何Fragment的引用，那么没关系，每个Fragment都有一个唯一的TAG或者ID,可以通过getFragmentManager.findFragmentByTag()或者findFragmentById()获得任何Fragment实例，然后进行操作
  • 在Fragment中可以通过getActivity得到当前绑定的Activity的实例，然后进行操作。

备注：

  • 如果在Fragment中需要Context，可以通过getActivity()，如果该Context需要在Activity被销毁后还存在，则使用getActivity.getApplicationContext();

考虑Fragment的重复使用问题，降低与Activity的耦合，Fragment操作应该由它的管理者Activity决定。

4.1 传递数据给Fragment

步骤流程：

  • 在Activity中创建Bundle数据包，调用Fragment实例的setArguments()，将Bundle数据包传给Fragment
  • Fragment调用getArguments()获得Bundle对象，然后进行解析就可以

简单示例：

  1. //创建Fragment对象，并通过Bundle对象传递值（在onCreate方法中）
  2. MyFragment fragment = new MyFragment();
  3. Bundle bundle = new Bundle();
  4. bundle.putString("key", values);
  5. fragment.setArguments(bundle);
  1. //（在Fragment类中的onCreateView方法中）
  2. Bundle bundle = this.getArguments();
  3.     if (bundle != null)
  4.     {
  5.         String str = bundle.getString("key");
  6.     }
  7.     TextView textView = new TextView(getActivity());
  8.     textView.setText("上上下下的享受");//是电梯，别误会

4.2 传递数据给Activity

步骤流程：

  • 在Fragment中定义一个内部回调接口，再让包含该Fragment的Activity实现该回调接口
  • Fragment通过回调接口传数据

简单示例：

  • 首先在Fragment中定义一个接口（定义抽象方法，传什么类型参数）
  1. /*接口*/  
  2. public interface Mylistener{
  3.     public void thanks(String code);
  4. }
  • Fragment类中定义该接口
  1. private Mylistener listener;
  • 在onAttach方法中，将定义的该接口强转为activity类型
  1. @Override
  2.     public void onAttach(Activity activity) {
  3.         // TODO Auto-generated method stub
  4.         listener=(Mylistener) activity;
  5.         super.onAttach(activity);
  6.     }
  • Activity只需实现该接口并重写该方法即可
  1. @Override
  2.     public void thanks(String code) {
  3.         // TODO Auto-generated method stub
  4.         Toast.makeText(this, "已收到Fragment的消息：--"+code+"--,客气了", Toast.LENGTH_SHORT).show();;
  5.     }

除了接口回调，还可以使用EventBus进行交互通信。

5. Fragment间通信

5.1 setArguments()

示例：

  • 在Fragment B中新建一个函数：newInstance()接收传过来的参数
  1. public static Fragment2 newInstance(String text) {
  2.         Fragment2 fragment = new Fragment2();
  3.         Bundle args = new Bundle();
  4.         args.putString("param", text);
  5.         fragment.setArguments(args);
  6.         return fragment;
  7.     }
  • 在Fragment B的onCreateView中获取参数
  1.     public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
  2.         View view =  inflater.inflate(R.layout.fragment2, container, false);
  3.         if (getArguments() != null) {
  4.             String mParam1 = getArguments().getString("param");
  5.             TextView tv =  (TextView)view.findViewById(R.id.textview);
  6.             tv.setText(mParam1);
  7.         }
  8.         return view;
  9.     }
  • 在Fragment A中，调用Fragment B时，通过newInstance函数获取实例并传递参数：
  1. public class Fragment1 extends Fragment {
  2.  
  3.     @Override
  4.     public View onCreateView(LayoutInflater inflater, ViewGroup container,
  5.                              Bundle savedInstanceState) {
  6.         View view = inflater.inflate(R.layout.fragment1, container, false);
  7.         Button btn = (Button)view.findViewById(R.id.load_fragment2_btn);
  8.         btn.setOnClickListener(new View.OnClickListener(){
  9.             @Override
  10.             public void onClick(final View view) {
  11.                 Fragment2 fragment2 = Fragment2.newInstance("从Fragment1传来的参数");
  12.  
  13.                 FragmentTransaction transaction = getFragmentManager().beginTransaction();
  14.                 transaction.add(R.id.main_layout, fragment2);
  15.                 transaction.addToBackStack(null);
  16.                 transaction.commit();
  17.             }
  18.         });
  19.         return view;
  20.     }
  21. }

5.2 同Activity不同Container的Fragment交互

这种情况有三中方法解决：

方法一：直接在Activity中操作

? 直接在Activity中找到对应控件的实例，然后直接操控即可

方法二：直接在Fragment中操作

? 这里有两个问题：如何获取自己控件的引用？如何获取其他Fragment页控件的引用？

  • 首先获取自己控件的引用

可以在onCreateView()中获取

  1. public View onCreateView(LayoutInflater inflater, ViewGroup container,
  2.         Bundle savedInstanceState) {
  3.     View rootView = inflater.inflate(R.layout.fragment1, container, false);
  4.     listView = (ListView)rootView.findViewById(R.id.list);//获取自己视图里的控件引用,方法一
  5.     return rootView;
  6. }

在onCreateView()中，还没有创建视图，所以在这里如果使用getView()方法将返回空

另一种方法是在onActivityCreated()中获取，其回调在onCreate()执行后再执行

  1. public void onActivityCreated(Bundle savedInstanceState) {
  2.     super.onActivityCreated(savedInstanceState);
  3.  
  4.     listView = (ListView) getView().findViewById(R.id.list);//获取自己视图里的控件引用,方法二
  5. }
  • 获取其它Fragment页控件引用方法

获取Activity资源，须等Activity创建完成后，必须放在onActivityCreated()回调函数中

  1. public void onActivityCreated(Bundle savedInstanceState) {
  2.     super.onActivityCreated(savedInstanceState);
  3.  
  4.     mFragment2_tv = (TextView) getActivity().findViewById(R.id.fragment2_tv);//获取其它fragment中的控件引用的唯一方法!!!
  5.  
  6. }

总的实现示例如下：

  1. public void onActivityCreated(Bundle savedInstanceState) {
  2.     super.onActivityCreated(savedInstanceState);
  3.  
  4.     mFragment2_tv = (TextView) getActivity().findViewById(R.id.fragment2_tv);//获取其它fragment中的控件引用的唯一方法!!!
  5.     listView = (ListView) getView().findViewById(R.id.list);//获取自己视图里的控件引用,方法二
  6.  
  7.     ArrayAdapter arrayAdapter = new ArrayAdapter<String>(getActivity(), android.R.layout.simple_list_item_1, mStrings);
  8.     listView.setAdapter(arrayAdapter);
  9.     listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
  10.         @Override
  11.         public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
  12.             String str = mStrings[position];
  13.             mFragment2_tv.setText(str);
  14.        }
  15.     });
  16. }

方法三：在各自Fragment中操作

方法二在Fragment A中操作了Fragment B，违背模块分离思想，应通过Activity将其分离

在Activity中可以直接通过FragmentManager.findFragmentById()获取Fragment实例

示例：

在Fragment2设置TextView函数

  1. public class Fragment2 extends Fragment {
  2.     private TextView mTv;
  3.     …………
  4.     public void setText(String text) {
  5.         mTv.setText(text);
  6.     }
  7. }

在Fragment1 中定义处理方式

  • 定义接口与变量
  1. private titleSelectInterface mSelectInterface;
  2.  
  3. public interface titleSelectInterface{
  4.     public void onTitleSelect(String title);
  5. }
  • 接口变量赋值

接口给Activity使用，在Activity中给接口变量赋值，在Fragment与Activity关联时，需要强转

  1. public void onAttach(Activity activity) {
  2.     super.onAttach(activity);
  3.  
  4.     try {
  5.         mSelectInterface = (titleSelectInterface) activity;
  6.     } catch (Exception e) {
  7.         throw new ClassCastException(activity.toString() + "must implement OnArticleSelectedListener");
  8.     }
  9. }
  • 调用接口变量
  1. public void onActivityCreated(Bundle savedInstanceState) {
  2.     super.onActivityCreated(savedInstanceState);
  3.  
  4.     listView = (ListView) getView().findViewById(R.id.list);//获取自己视图里的控件引用,方法二
  5.     ArrayAdapter arrayAdapter = new ArrayAdapter<String>(getActivity(), android.R.layout.simple_list_item_1, mStrings);
  6.     listView.setAdapter(arrayAdapter);
  7.     listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
  8.         @Override
  9.         public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
  10.             String str = mStrings[position];
  11.             mSelectInterface.onTitleSelect(str);
  12.         }
  13.     });
  14. }
  • 在Activity中实现接口
  1. public class MainActivity extends FragmentActivity implements Fragment1.titleSelectInterface {
  2.  
  3.     ……
  4.     
  5.     @Override
  6.     public void onTitleSelect(String title) {
  7.         FragmentManager manager = getSupportFragmentManager();
  8.         Fragment2 fragment2 = (Fragment2)manager.findFragmentById(R.id.fragment2);
  9.         fragment2.setText(title);
  10.     }
  11. }

原文链接：http://www.cnblogs.com/linhaostudy/p/14673871.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Android热门文章

  • 安卓虚拟定位实现与反作弊思路
  • Android之Activity启动流程详解（基于api28）
  • MAUI开发Android程序使PDA扫码广播消息转发至Web页面
  • android开发技巧杂谈
  • 高通CSR8675蓝牙音频芯片介绍
  • Android Studio列表用法之一：ListView图文列表显示（实例）
  • 分析Android 11.0Settings源码之主界面加载
  • 联发科MT6731 4G智能功能手机处理器芯片介绍
  • android 请求接口报错 org.apache.http.conn.HttpHostConnectException: Connection to http://192.168.1.90:9090 refused
  • GSYVideoPlayer使用记录

    • Android推荐文章

  • Jetpack Compose(7)——触摸反馈
  • 安卓开发日志采集和分析面面谈
  • Android桌面Launcher源码浅析
  • Android启动过程-万字长文(Android14)
  • Android Studio制作简单登录界面
  • FFmpeg开发笔记（九）Linux交叉编译Android的x265库
  • 在Android开发中如何使用OpenSL ES库播放解码后的pcm音频文件？
  • Android 开机流程介绍
  • 安卓端出现https请求失败的一次问题排查
  • Android 编译介绍

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号