Android入门教程之Fragment的具体使用详解

什么是Fragment？

Fragment是Android系统中的一个重要组建，它可以理解为Activity的模块化实现，可以通过将UI分割成多个模块来提高代码复用性和灵活性，同时能够更好地适应不同屏幕的尺寸和方向。

Fragment有自己的生命周期，并且可以被嵌套在其他Fragment或Activity中，可以在运行时添加和删除，并且可以使用Fragment管理器进行管理。

如何使用Fragment？

步骤一：创建Fragment类

首先我们需要创建一个Fragment类，通过继承Fragment类来实现，如下所示：

public class MyFragment extends Fragment {
    public MyFragment() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_my, container, false);
        // 初始化View
        return view;
    }
}

同时，我们需要在res/layout文件夹中创建一个与Fragment对应的布局文件，如下所示：

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical" android:layout_width="match_parent"
    android:layout_height="match_parent">

    <TextView
        android:id="@+id/text_view"
        android:text="Hello Fragment!"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
</LinearLayout>

步骤二：在Activity中添加Fragment

接下来我们需要在Activity中添加Fragment，通过FragmentManager来完成。如下所示：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        MyFragment fragment = new MyFragment();
        fragmentTransaction.add(R.id.fragment_container, fragment);
        fragmentTransaction.commit();
    }
}

在这里，我们使用了FragmentManager来获取Fragment事务的实例，然后使用beginTransaction()方法开始一个新的事务。

接着我们创建了一个MyFragment对象，并使用add()方法将其添加到Activity中对应的容器中，最后使用commit()方法提交这个事务。

同时，我们还需要在Activity的布局文件中添加一个用于显示Fragment的容器，如下所示：

<FrameLayout
    android:id="@+id/fragment_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

这样，我们就完成了将Fragment添加至Activity的过程。

步骤三：Fragment的交互

在Fragment中可以处理用户的交互事件，并通过getActivity()方法来获取到其所在的Activity的实例，从而实现Fragment和Activity之间的交互。如下所示：

public class MyFragment extends Fragment {

    private TextView mTextView;

    public MyFragment() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_my, container, false);
        initView(view);
        return view;
    }

    private void initView(View view) {
        mTextView = view.findViewById(R.id.text_view);
        mTextView.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Activity activity = getActivity();
                Toast.makeText(activity, "Hello Activity!", Toast.LENGTH_SHORT).show();
            }
        });
    }
}

在这里，我们通过在TextView上设置OnClickListener来处理点击事件，当用户点击TextView时，我们通过getActivity()方法获取到Activity的实例，然后使用Toast来显示提示信息。

另外，我们还需要在Activity的布局文件中添加一个用于显示交互结果的TextView，如下所示：

<TextView
    android:id="@+id/result_text_view"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

然后在MainActivity中获取到这个TextView并设置其文字，如下所示：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        MyFragment fragment = new MyFragment();
        fragmentTransaction.add(R.id.fragment_container, fragment);
        fragmentTransaction.commit();

        TextView resultTextView = findViewById(R.id.result_text_view);
        resultTextView.setText("Hello MainActivity!");
    }
}

这样，当我们点击Fragment中的TextView时，就会显示提示信息"Hello Activity!"，同时在Activity布局文件中的TextView中也会显示"Hello MainActivity!"。

Fragment的生命周期

Fragment的生命周期由如下几个方法组成：

• onAttach(): 当Fragment被依附到Activity时调用
• onCreate(): 当Fragment被创建时调用
• onCreateView(): 当Fragment的视图被创建时调用
• onActivityCreated(): 当Fragment所依附的Activity完成 onCreate() 方法时调用
• onStart(): 当Fragment可见时调用
• onResume(): 当Fragment获得用户焦点时调用
• onPause(): 当Fragment失去用户焦点时调用
• onStop(): 当Fragment不可见时调用
• onDestroyView(): 当Fragment视图被销毁时调用
• onDestroy(): 当Fragment被销毁时调用
• onDetach(): 当Fragment和Activity分离时调用

示例说明

示例一：Fragment的切换

我们可以使用FragmentTransaction来管理Fragment的切换，通过添加、移除、替换、隐藏、显示等方法实现，如下所示：

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private ImageView mMenuImageView;
    private MenuFragment mMenuFragment;
    private ContentFragment mContentFragment;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        initView();

        switchFragment(FragmentType.MENU);
    }

    private void initView() {
        mMenuImageView = findViewById(R.id.menu_image_view);
        mMenuImageView.setOnClickListener(this);
    }

    private void switchFragment(FragmentType type) {
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

        hideAllFragment(fragmentTransaction);

        switch (type) {
            case MENU:
                if (mMenuFragment == null) {
                    mMenuFragment = new MenuFragment();
                    fragmentTransaction.add(R.id.fragment_container, mMenuFragment);
                } else {
                    fragmentTransaction.show(mMenuFragment);
                }
                break;
            case CONTENT:
                if (mContentFragment == null) {
                    mContentFragment = new ContentFragment();
                    fragmentTransaction.add(R.id.fragment_container, mContentFragment);
                } else {
                    fragmentTransaction.show(mContentFragment);
                }
                break;
        }

        fragmentTransaction.commit();
    }

    private void hideAllFragment(FragmentTransaction transaction) {
        if (mMenuFragment != null) {
            transaction.hide(mMenuFragment);
        }
        if (mContentFragment != null) {
            transaction.hide(mContentFragment);
        }
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.menu_image_view:
                switchFragment(FragmentType.CONTENT);
                break;
        }
    }

    private enum FragmentType {
        MENU,
        CONTENT
    }
}

在这里，我们通过switchFragment()方法来切换Fragment，使用枚举变量FragmentType来表示不同的Fragment，然后通过hideAllFragment()方法来隐藏所有已添加的Fragment，最后使用show()或add()方法添加或显示对应的Fragment。

同时，我们还需要在Activity的布局文件中添加一个ImageView，用于跳转到对应Fragment，如下所示：

<ImageView
    android:id="@+id/menu_image_view"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:src="@drawable/ic_menu" />

示例二：Fragment的通信

我们可以使用接口来实现Fragment和Activity之间的通信，具体实现步骤如下：

首先，在Fragment中定义一个接口，如下所示：

public interface OnItemClickListener {
    void onItemClick(String content);
}

然后在Fragment中通过接口回调来实现与Activity的通信，如下所示：

private OnItemClickListener mListener;

@Override
public void onAttach(@NonNull Context context) {
    super.onAttach(context);
    if (context instanceof OnItemClickListener) {
        mListener = (OnItemClickListener) context;
    } else {
        throw new RuntimeException(context.toString()
                + " must implement OnItemClickListener");
    }
}

@Override
public void onDetach() {
    super.onDetach();
    mListener = null;
}

private void initView(View view) {
    mView = view.findViewById(R.id.list_view);
    mAdapter = new MyAdapter(mList, mListener);
    mView.setAdapter(mAdapter);
}

在这里，我们首先在Fragment的生命周期中调用onAttach()方法，将接口类型的mListener赋值为Activity传入的回调实例。然后在调用onDetach()方法时将mListener置为null，避免对Activity的引用。

接着，我们在对应的View上设置对应的OnClickListener，并在方法中调用接口回调导致Activity的方法执行，实现Fragment和Activity之间的通信，如下所示：

public class MainActivity extends AppCompatActivity implements OnItemClickListener {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        switchFragment();
    }

    @Override
    public void onItemClick(String content) {
        ContentFragment fragment = ContentFragment.newInstance(content);
        getSupportFragmentManager().beginTransaction()
                .replace(R.id.fragment_container, fragment)
                .addToBackStack(null)
                .commit();
    }
}

在Activity中，我们需要实现该接口，然后将实例传入给Fragment，在具体实现的方法中处理来自Fragment的回调。

同时，在Fragment中我们也需要通过newInstance()方法来创建该Fragment的实例，并在其中传入调用该方法所需的参数，以实现传参传递，如下所示：

public static ContentFragment newInstance(String content) {
    ContentFragment fragment = new ContentFragment();
    Bundle args = new Bundle();
    args.putString(ARG_CONTENT, content);
    fragment.setArguments(args);
    return fragment;
}

@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    if (getArguments() != null) {
        mContent = getArguments().getString(ARG_CONTENT);
    }
}

private void initView(View view) {
    mTextView = view.findViewById(R.id.content_text_view);
    mTextView.setText(mContent);
}

在这里，我们首先通过newInstance()方法来创建Fragment的实例，并将需要传递的参数设置到Bundle中。然后在Fragment的生命周期方法中通过getArguments()方法获取到传递的参数，最后实现具体的UI显示。

同时，我们还需要在Activity的布局文件中添加一个用于显示ContentFragment的TextView，如下所示：

<FrameLayout
    android:id="@+id/fragment_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

<TextView
    android:id="@+id/content_text_view"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

这样，我们就完成了Fragment和Activity之间的通信过程。