Android studio开发入门教程详解(复习)

引言

本文为个人总结Android基础知识复习笔记。如有不妥之处，敬请指正。后续将持续更新更多知识点。

UI

TextView文本

TextView是一个基本的用户界面组件，用于在应用中显示文本。它是显示信息的一种简单而有效的方式，可以展示从简单的一行文本到复杂的数据。

基本用法

TextView可以通过XML布局文件或者Java/Kotlin代码来创建和管理。在XML中定义TextView时，你可以设置多种属性来控制其显示效果，如文本内容、字体大小、颜色和样式等。

<TextView
    android:id="@+id/textView"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Hello, World!"
    android:textSize="18sp"
    android:textColor="#FF0000"
    android:gravity="center"/>

在上述代码中，我们创建了一个TextView，设置了文本内容、字体大小、字体颜色，并使文本在TextView中居中显示。

实际应用

在实际应用中，TextView经常用于显示应用的标题、用户的输入信息、提示信息等。它也可以与其他组件如Button、EditText等结合使用，以提供更丰富的用户交互体验。

TextView userNameTextView = findViewById(R.id.textView);
userNameTextView.setText("Welcome, John Doe!");

通过TextView控件的ID进行逻辑控制
TextView是Android中用于显示文本的基础控件，它拥有许多属性和方法来定制文本的显示方式。以下是一些常用的TextView属性和方法的讲解：

常用属性和方法

常用属性

• android:text: 设置TextView显示的文本内容。
• android:textSize: 设置文本的大小，通常使用sp作为单位，以保证不同屏幕密度下的可读性。
• android:textColor: 设置文本的颜色，可以是直接的颜色值或者引用颜色资源。
• android:gravity: 设置文本在TextView内的对齐方式，如center、left、right等。
• android:textStyle: 设置文本的样式，如bold（加粗）、italic（斜体）或normal（正常）。
• android:fontFamily: 设置文本的字体。
• android:lineSpacingExtra: 设置行间距。
• android:drawableLeft: 在文本左侧添加一个图标。
• android:drawablePadding: 设置文本与图标之间的间距。

常用方法

• setText(CharSequence text): 通过代码设置TextView的文本内容。
• getText(): 获取TextView当前显示的文本内容。
• setTextSize(float size): 通过代码设置文本的大小。
• setTextColor(int color): 通过代码设置文本的颜色。
• setTypeface(Typeface tf, int style): 设置文本的字体和样式。
• setGravity(int gravity): 通过代码设置文本的对齐方式。

高级特性

• android:ellipsize: 当文本过长无法完全显示时，设置文本的省略方式，如end（末尾省略）、start（开头省略）等。
• android:maxLines: 设置TextView可以显示的最大行数。
• android:autoLink: 自动将文本中的网址、电话号码、邮件地址等转换为可点击的链接。
• android:shadowColor 和 android:shadowDx/android:shadowDy/android:shadowRadius: 设置文本的阴影颜色和阴影偏移量，以及模糊半径。

Button按钮

Button继承自TextView，因此它不仅包含了TextView的所有功能，还增加了可点击的交互能力。在界面上，Button通常表示为一个可以按压的区域，显示文本或图标，提示用户可以进行操作。

在XML布局文件中定义Button非常简单。你可以设置多种属性来控制其显示效果，如文本内容、背景、字体大小和颜色等。

<Button
    android:id="@+id/myButton"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="@string/button_label"
    android:background="@drawable/button_background"/>

在上述代码中，我们创建了一个Button，为其设置了ID、尺寸、文本和背景。

处理点击事件

Button最重要的功能是响应用户的点击事件。你可以通过在Activity中重写onClick方法来处理点击事件。

public class MyActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);

        Button myButton = findViewById(R.id.myButton);
        myButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 处理点击事件
            }
        });
    }
}

或者通过当前类继承于View.OnClickListener，此时需要重写onClick方法，后续此Activity有点击事件响应时，都会执行此方法。

public class MainActivity extends AppCompatActivity implements View.OnClickListener

通过v.getId()获取当前点击的控件，用case进行比较

@Override
public void onClick(View v) {
    switch (v.getId()){
        case R.id.Button_1:
            break;
    }
}

EditText输入框

在Android开发中，EditText是一个基础且功能丰富的用户界面组件，用于获取用户输入的文本。它不仅可以接收键盘输入，还可以通过各种样式和属性来增强用户体验。

基本属性

EditText继承自TextView，因此它包含了TextView的所有属性，同时增加了文本编辑的功能。以下是一些基本的属性：

• android:hint: 提供给用户的输入提示。
• android:inputType: 定义了输入的类型，如文本、密码或数字。
• android:maxLines: 设置最大行数。
• android:textSize: 设置文本大小。
• android:textColor: 设置文本颜色。
• android:drawableLeft: 在输入框左侧添加图标，常用于搜索框或带图标的输入框。
• android:maxLength: 限制输入的最大字符数。
• android:textAllCaps: 设置文本全部大写。

注意：可以进行自定义EditText样式，创建shape XML文件来定义EditText的背景，包括边框颜色、圆角等，这里目前不做讲解！

<EditText
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@null"
    android:drawableBottom="@drawable/shape_edittext_bottom_line"
    android:hint="请输入用户名"
    android:inputType="text"
    android:padding="10dp"
    android:textSize="14sp" />

在上述代码中，@drawable/shape_edittext_bottom_line是一个自定义的shape，用于显示下划线。

高级特性

android:focusable和android:imeOptions是两个重要的属性，它们用于控制EditText输入框的焦点行为和软键盘的交互。

android:focusable
android:focusable属性决定了组件是否能够获取焦点。当设置为true时，用户可以通过触摸或导航键（如方向键）来使组件获得焦点。通常，EditText默认是可获取焦点的，以便用户可以输入文本。

android:imeOptions
android:imeOptions属性用于控制软键盘上的动作按钮，这个按钮通常位于键盘的右下角。通过设置不同的值，你可以改变这个按钮的行为和外观，例如：

• actionDone: 显示“完成”按钮，用户点击后可以关闭键盘。
• actionGo: 显示“前往”按钮，通常用于导航到另一个视图或执行搜索操作。
• actionNext: 显示“下一项”按钮，用户点击后焦点会跳转到布局中的下一个EditText。
• actionSearch: 显示“搜索”按钮，用于提交搜索请求。

例如，如果你想要在用户完成输入后关闭软键盘，你可以在EditText的XML定义中设置android:imeOptions=“actionDone”。这样，当用户点击键盘上的“完成”按钮时，软键盘会关闭

<EditText
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:imeOptions="actionDone"
    android:inputType="text" />

在编程中，你也可以通过调用setImeOptions()方法来动态设置这个属性。例如，设置IME_ACTION_DONE会在软键盘上显示“完成”按钮，并且在用户点击后关闭键盘：

EditText editText = findViewById(R.id.editText);
editText.setImeOptions(EditorInfo.IME_ACTION_DONE);

ImageView图片

在Android应用开发中，ImageView是一个用于展示图片的基础控件。它不仅能够显示本地资源图片，还能够通过网络加载图片。

ImageView的基本属性

• android:src: 设置ImageView要展示的图片。
• android:background: 设置ImageView的背景样式。
• android:scaleType: 控制图片的缩放模式。
• android:maxHeight 和 android:maxWidth: 设置ImageView的最大高度和宽度。
• android:tint: 设置图片的色彩过滤。

其中，android:src和android:background的区别尤为重要。android:background表示背景样式，可以设置成图片文件或者背景资源；而android:src是ImageView特有的属性，用来设置要展示的图片。

ImageView的缩放模式

android:scaleType是一个关键属性，它定义了当图片尺寸和ImageView尺寸不一致时，图片应该如何调整。以下是一些常用的scaleType值：

• fitCenter: 保持图片的宽高比，缩放图片使得整个图片都能够显示出来。
• centerCrop: 保持图片的宽高比，缩放图片使得它完全覆盖ImageView，并且居中显示。
• fitXY: 不保持图片的宽高比，拉伸图片使得它完全符合ImageView的大小。

在实际应用中，ImageView可以用于显示用户头像、商品图片、广告宣传图等。你可以通过以下方式在代码中设置图片：

ImageView imageView = findViewById(R.id.myImageView);
imageView.setImageResource(R.drawable.my_image);

ProgressBar进度

在Android应用开发中，ProgressBar是一个用于展示操作进度的控件，如数据加载或文件下载。它可以通过多种样式来满足不同的设计需求。ProgressBar有两种基本样式：圆形和水平。圆形ProgressBar通常用于表示等待，而水平ProgressBar用于展示具体的进度信息。

圆形ProgressBar

圆形ProgressBar是默认的样式，它会不断旋转，表示一个操作正在进行中。在XML布局文件中，你可以这样定义一个圆形ProgressBar：

<ProgressBar
    android:layout_width="wrap_content"
    android:layout_height="wrap_content" />

水平ProgressBar

水平ProgressBar通过一个长条形状展示进度，可以显示具体的进度值。你可以通过设置style属性来使用这种样式：

<ProgressBar
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    style="?android:attr/progressBarStyleHorizontal" />

处理ProgressBar的行为

你可以通过代码来控制ProgressBar的行为，如设置当前进度、显示或隐藏进度条等。

ProgressBar progressBar = findViewById(R.id.myProgressBar);
progressBar.setProgress(50); // 设置进度为50%
progressBar.setVisibility(View.VISIBLE); // 显示进度条

常用属性和方法

• android:max：设置进度条的最大值。默认值是100。
• android:progress：设置当前进度值。
• android:secondaryProgress：设置次要进度值，通常用于显示缓冲进度。
• android:indeterminate：如果设置为true，进度条将显示一个不确定的进度（通常是一个循环动画），而不是具体的进度值。
• android:progressDrawable：设置进度条的Drawable对象，可以自定义进度条的外观。
• getMax()：返回进度条的最大值。（同时可以进行set）
• getProgress()：返回当前的进度值。
• getSecondaryProgress()：返回次要进度值。
• setProgress(int progress)：设置当前的进度值。
• setSecondaryProgress(int secondaryProgress)：设置次要进度值。
• incrementProgressBy(int diff)：增加当前进度值。
• setIndeterminate(boolean indeterminate)：设置进度条是否为不确定模式。
• setVisibility(View.VISIBLE)：当你调用setVisibility(View.VISIBLE)时，视图将变得可见。如果视图之前是不可见的（INVISIBLE或GONE），它将重新显示在用户界面上。
  • View.VISIBLE：视图可见。
  • View.INVISIBLE：视图不可见，但仍然占据布局空间。
  • View.GONE：视图不可见，并且不占据布局空间。

实际应用场景

在实际应用中，ProgressBar可以用于显示文件下载进度、数据加载进度等。例如，在文件下载过程中，你可以动态更新进度条的进度：

ProgressBar progressBar = findViewById(R.id.progressBar);
progressBar.setMax(100);

new Thread(new Runnable() {
    @Override
    public void run() {
        for (int i = 0; i <= 100; i++) {
            final int progress = i;
            runOnUiThread(new Runnable() {
                @Override
                public void run() {
                    progressBar.setProgress(progress);
                }
            });
            try {
                Thread.sleep(100); // 模拟下载过程
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}).start();

在这个示例中，我们创建了一个线程来模拟文件下载过程，并在主线程中更新进度条的进度。

ListView滚动菜单

ListView 是 Android 开发中最常用的组件之一，基本上每一个 Android 应用都会使用到它。在使用 ListView 时，我们通常会涉及到适配器（Adapter）。ListView 中常用的适配器有三种：BaseAdapter、SimpleAdapter 和 ArrayAdapter。这些适配器充当了数据与 ListView 之间的中介，将数据映射到列表视图上。

常用的属性

在使用 ListView 时，我们可以设置一些常用的属性，例如：

• android:cacheColorHint：设置拖动时的背景色。
• android:divider：设置分割线的样式。
• android:dividerHeight：设置分割线的高度。
• android:listSelector：设置选中时的颜色。
• android:scrollbars：设置滚动条的显示。
• android:fadeScrollbars：设置为 true 可实现滚动条的自动隐藏和显示。

ListView中的点击事件

其中每个item元素点击事件使用setOnItemClickListener方法，position参数是点击的元素在整个数据集合中的下标

listView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
    @Override
    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
        Toast.makeText(listActivity.this,position+"",Toast.LENGTH_SHORT).show();
    }
});

简单用法

首先，在布局文件中添加一个 ListView：

<?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">

    <ListView
        android:id="@+id/list_view"
        android:layout_width="match_parent"
        android:layout_height="wrap_content" />
</LinearLayout>

接下来，在 MainActivity 中设置数据并创建适配器：

public class MainActivity extends AppCompatActivity {
    private String[] data = {"Apple", "Banana", "Orange", "Apple", "Banana", "Orange","Apple", "Banana", "Orange","Apple", "Banana", "Orange","Apple", "Banana", "Orange","Apple", "Banana", "Orange","Apple", "Banana", "Orange"};

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

        ArrayAdapter<String> adapter = new ArrayAdapter<>(this,
                android.R.layout.simple_list_item_1, data);

        ListView listView = findViewById(R.id.list_view);
        listView.setAdapter(adapter);
    }
}

在这里，我们使用了 ArrayAdapter，将字符串数组作为数据源，并将其与 ListView 关联起来。android.R.layout.simple_list_item_1 是一个内置的布局文件，其中只包含一个 TextView，用于简单地显示文本。

android.R.layout.simple_list_item_1 是 Android 框架中内置的一个布局资源文件，用于在 ListView 中显示简单的文本项。这个布局只包含一个 TextView，用于显示文本内容。

需要适配器讲解，请跳转适配器查看讲解。

定制ListView的Item

1. 创建子项布局文件：
   • 在 res/layout 目录下创建一个 XML 文件，例如 list_item_fruit.xml。
   • 在这个文件中定义子项的布局，例如包含一个 ImageView 和一个 TextView。

<?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">

    <ImageView
        android:id="@+id/fruit_image1"
        android:layout_width="100dp"
        android:layout_height="100dp"
        android:background="@drawable/apple"/>

    <TextView
        android:id="@+id/fruit_name1"
        android:layout_width="wrap_content"
        android:layout_height="100dp"
        android:gravity="center_vertical"
        android:layout_marginLeft="18dp"
        android:text="123"/>
</LinearLayout>

2. 在自定义适配器中引用子项布局：
   • 在你的适配器类中，使用 LayoutInflater 来加载子项布局文件。
   • 在 getView() 方法中，将数据绑定到布局中的视图。

public class FruitAdapter extends ArrayAdapter<Fruit> {
    private int resourceId;


    public FruitAdapter(@NonNull Context context, int resource, List<Fruit> object) {
        super(context, resource, object);
        resourceId = resource;
    }

    @NonNull
    @Override
    public View getView(int position, @Nullable View convertView, @NonNull ViewGroup parent) {
        Fruit fruit = getItem(position);
        convertView = LayoutInflater.from(parent.getContext())
                .inflate(resourceId, parent, false);
        ImageView image = convertView.findViewById(R.id.fruit_image1);
        TextView text = convertView.findViewById(R.id.fruit_name1);
        image.setImageResource(fruit.getImgAgeId());
        text.setText(fruit.getName());
        return convertView;
    }
}

FruitAdapter构造函数需要传入当前上下文，子列项模板ID（自定义的XML）以及需要加载的数据元素。

注意：其中Fruit是自定义的，需要将子列项的元素值声明一个类，具体值与子列项的XML文件相同

public class Fruit {
    private String name;
    private int imgAgeId;

    public Fruit(String name, int imAgeId) {
        this.name = name;
        this.imgAgeId = imAgeId;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getImgAgeId() {
        return imgAgeId;
    }

    public void setImgAgeId(int imAgeId) {
        this.imgAgeId = imAgeId;
    }
}

3. 使用适配器：

public class listActivity extends AppCompatActivity {

    private ListView listView;
    private List<Fruit> fruitList = new ArrayList<>();

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_listview);
        listView = findViewById(R.id.list_view);
        initFruits();
        FruitAdapter fruitAdapter = new FruitAdapter(listActivity.this,R.layout.fruit_item,fruitList);
        listView.setAdapter(fruitAdapter);
    }

    public void initFruits(){
        for (int i = 0; i < 8; i++) {
            Fruit fruit = new Fruit("Apple",R.drawable.apple);
            fruitList.add(fruit);
        }
    }
}

效果演示

组件

Intent跳转

在Android开发中，Intent是一个非常重要的组件，用于在应用程序的不同组件之间进行通信和数据传递。它可以启动活动（Activity）、服务（Service）以及发送广播（Broadcast）

什么是Intent？
Intent是一种消息传递机制，用于在应用程序的不同组件之间进行通信。它可以启动新的活动、服务，或者发送广播。Intent分为两种类型：显式Intent和隐式Intent。

显式Intent

显式Intent明确指定要启动的目标组件（如Activity或Service）。这种方式通常用于启动同一个应用程序中的组件。

示例代码
以下是一个使用显式Intent从一个Activity跳转到另一个Activity的示例：

Intent intent = new Intent(MainActivity.this, SecondActivity.class);
startActivity(intent);

在这个示例中，我们创建了一个Intent对象，指定当前Activity为MainActivity，目标Activity为SecondActivity，然后调用startActivity(intent)方法来启动目标Activity。

隐式Intent

隐式Intent不指定目标组件，而是通过Intent的action、category和data等属性来描述要执行的操作。系统会根据这些属性匹配合适的组件来处理Intent。

示例代码
以下是一个使用隐式Intent打开网页的示例：

Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setData(Uri.parse("http://www.example.com"));
startActivity(intent);

在这个示例中，我们创建了一个Intent对象，设置其action为Intent.ACTION_VIEW，并通过setData方法指定要打开的网址。系统会根据这个Intent找到合适的应用（如浏览器）来处理它。

Intent.ACTION_VIEW是Android中的一个常用操作，它用于显示用户的数据。这个操作非常通用，会根据用户的数据类型打开相应的应用程序。例如，如果数据是一个网址，Intent.ACTION_VIEW会打开浏览器；如果数据是一个电话号码，它会打开拨号程序；如果数据是一个地理位置，它会打开地图应用。

传递数据

Intent不仅可以启动组件，还可以在组件之间传递数据。你可以使用putExtra方法将数据添加到Intent中，并在目标组件中使用getIntent().getExtras()方法获取这些数据。

示例代码
以下是一个从一个Activity向另一个Activity传递字符串数据的示例：

// 在源Activity中
Intent intent = new Intent(MainActivity.this, SecondActivity.class);
intent.putExtra("message", "Hello, SecondActivity!");
startActivity(intent);

// 在目标Activity中
String message = getIntent().getStringExtra("message");
Toast.makeText(this, message, Toast.LENGTH_SHORT).show();

在这个示例中，我们在源Activity中使用putExtra方法将字符串数据添加到Intent中，并在目标Activity中使用getStringExtra方法获取并显示这条消息。

Toast提示

Toast的使用非常简单。你可以通过调用Toast.makeText()方法来创建一个Toast对象，并使用show()方法来显示它。以下是一个基本的示例：

Toast.makeText(getApplicationContext(), "Hello, World!", Toast.LENGTH_SHORT).show();

在这个示例中，我们创建了一个Toast对象，显示文本“Hello, World!”并设置显示时间为短时间（Toast.LENGTH_SHORT）。

Toast有两种显示时间：

• Toast.LENGTH_SHORT：短时间显示，一般为2秒。
• Toast.LENGTH_LONG：长时间显示，一般为3.5秒。

你可以根据需要选择合适的显示时间。

参数说明

参数1：Context
第一个参数是Context，它表示当前的上下文环境。Context提供了访问应用资源和类的接口。常见的用法包括：

• getApplicationContext()：获取应用的上下文，适用于需要在整个应用中使用的Toast。
• this：在Activity中使用当前Activity的上下文。
• getContext()：在Fragment中使用当前Fragment的上下文。

参数2：CharSequence或int
第二个参数是要显示的文本内容，可以是一个字符串（CharSequence）或字符串资源ID（int）。这就是Toast消息中显示的内容。

• 字符串：直接传递要显示的文本。
• 资源ID：传递字符串资源的ID，如R.string.message。

参数3：int
第三个参数是显示的时长，表示Toast消息在屏幕上显示的时间。Android提供了两个常量：

• Toast.LENGTH_SHORT：短时间显示，一般为2秒。
• Toast.LENGTH_LONG：长时间显示，一般为3.5秒。

自定义Toast的位置

默认情况下，Toast会显示在屏幕的底部中央。如果你想改变Toast的位置，可以使用setGravity()方法。例如，将Toast显示在屏幕中央。

Toast toast = Toast.makeText(getApplicationContext(), "Centered Toast", Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
toast.show();

Menu菜单

在Android开发中，菜单（Menu）是一个非常重要的组件，它为用户提供了一个直观的方式来与应用程序的各种功能进行交互。

使用步骤

1. 使用XML定义菜单：首先在res资源目录下，新建一个xml，Menu resource file

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item
        android:id="@+id/item1"
        android:title="选项1"/>
    <item
        android:id="@+id/item2"
        android:title="选项2"/>
</menu>

注意：菜单资源文件（例如main_menu.xml）通常放在项目的res/menu/目录下（自定义）

2. 在Activity中加载菜单：要在Activity中使用这个菜单，你需要重写onCreateOptionsMenu方法，并使用MenuInflater来加载XML文件：

@Override
public boolean onCreateOptionsMenu(Menu menu) {
    MenuInflater inflater = getMenuInflater();
    inflater.inflate(R.menu.main_menu, menu);
    return true;
}

onCreateOptionsMenu方法是Android中Activity类的一个重要回调方法，它用于创建活动的选项菜单。当用户首次点击菜单按钮时，系统会调用这个方法来加载菜单项。这个方法只会在菜单首次需要显示时被调用一次，除非活动被销毁后重新创建。

在这个例子中，getMenuInflater().inflate()方法用于加载名为main_menu的菜单资源文件，并将菜单项添加到传入的Menu对象中。返回true表示菜单应该显示；如果你返回false，则菜单不会显示。

3. 响应菜单项点击：当用户点击菜单项时，onOptionsItemSelected方法会被调用。你可以在这个方法中处理每个菜单项的点击事件：

@Override
public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
        case R.id.item1:
            // 菜单1操作
            return true;
        case R.id.item2:
            // 菜单2操作
            return true;
        default:
            return super.onOptionsItemSelected(item);
    }
}

Dialog对话框

可在当前界面弹出一共对话框，这个对话框是置顶于所有界面元素之上，可以屏蔽掉其他控件交互的能力，一般用于提示非常重要的内容或者警告信息

创建 AlertDialog.Builder 对象

AlertDialog.Builder builder = new AlertDialog.Builder(this);

创建一个AlertDialog.Builder对象。AlertDialog.Builder是一个辅助类，用于构建一个AlertDialog对话框。你可以通过这个构建器设置对话框的标题、消息内容、按钮以及其他自定义的视图。这里的this关键字是一个对当前Activity的引用，它告诉AlertDialog.Builder，新创建的对话框应该与当前的Activity相关联。也可以传入具体的Activity.this

// Step 1: 创建 AlertDialog.Builder 对象
AlertDialog.Builder builder = new AlertDialog.Builder(this);

// Step 2: 设置对话框的属性，如图标、标题和消息
builder.setIcon(R.drawable.ic_dialog_alert);
builder.setTitle("对话框标题");
builder.setMessage("这是对话框的内容。");

// Step 3: 添加按钮和它们的点击事件处理器
builder.setPositiveButton("确认", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        // 用户点击了确认按钮的事件处理
    }
});
builder.setNegativeButton("取消", new DialogInterface.OnClickListener() {
    public void onClick(DialogInterface dialog, int id) {
        // 用户点击了取消按钮的事件处理
    }
});

// Step 4: 创建 AlertDialog 对象
AlertDialog dialog = builder.create();

// Step 5: 显示对话框
dialog.show();

DialogInterface.OnClickListener是一个回调接口，用于定义当对话框中的按钮被点击时应该执行的操作。当你为对话框的按钮设置了OnClickListener，你需要重写onClick方法来处理按钮点击事件。这里是onClick方法的参数讲解：

• DialogInterface dialog: 这个参数是一个DialogInterface对象，代表触发点击事件的对话框。通过这个参数，你可以控制对话框的显示和隐藏，或者查询对话框的状态。
• int id: 这个参数是一个整型标识符，表示被点击的按钮。它通常用于区分对话框中的不同按钮。例如，如果你的对话框有多个按钮，你可以使用这个id来识别哪个按钮被点击了。

更多方法

方法	描述
setIcon(int iconId)	设置对话框的图标。
setTitle(CharSequence title)	设置对话框的标题。
setMessage(CharSequence message)	设置对话框显示的消息内容。
setPositiveButton(CharSequence text, DialogInterface.OnClickListener listener)	设置一个正面的按钮（通常用作“确认”）和它的点击事件监听器。
setNegativeButton(CharSequence text, DialogInterface.OnClickListener listener)	设置一个负面的按钮（通常用作“取消”）和它的点击事件监听器。
setNeutralButton(CharSequence text, DialogInterface.OnClickListener listener)	设置一个中立的按钮（例如“忽略”）和它的点击事件监听器。
setItems(CharSequence[] items, DialogInterface.OnClickListener listener)	设置对话框要显示的列表项。
setMultiChoiceItems(CharSequence[] items, boolean[] checkedItems, DialogInterface.OnMultiChoiceClickListener listener)	设置对话框显示一系列的复选框。
setSingleChoiceItems(CharSequence[] items, int checkedItem, DialogInterface.OnClickListener listener)	设置对话框显示一系列的单选按钮，并指定默认选中项。
setView(View view)	设置对话框的自定义视图。
setCancelable(boolean cancelable)	设置对话框是否可以通过点击外部区域或者按返回键来取消。
setOnDismissListener(DialogInterface.OnDismissListener listener)	设置对话框被取消时的监听器。
setOnCancelListener(DialogInterface.OnCancelListener listener)	设置对话框取消时的监听器。
setOnKeyListener(DialogInterface.OnKeyListener onKeyListener)	设置对话框的按键监听器。

效果预览

ProgressDialog模态对话框

ProgressDialog是Android提供的一个UI组件，用于在屏幕上显示一个模态对话框，其中包含一个进度条和一些可选的文字信息。这个对话框可以是圆形的，也可以是水平的，并且可以显示确定或不确定的进度。ProgressDialog和AlertDialog有点类似，都可以弹出对话框，都可以屏蔽其他控件的交互能力，不同的是ProgressDialog会在对话框中显示一个进度条，一般用于显示当前操作比较耗时，让用户耐心的等待。

ProgressDialog的基本用法

要使用ProgressDialog，你需要创建一个ProgressDialog实例，并设置一些参数，然后调用show()方法来显示它。以下是一个简单的例子：

ProgressDialog progressDialog = new ProgressDialog(MyActivity.this);
progressDialog.setProgressStyle(ProgressDialog.STYLE_SPINNER); // 设置为圆形
progressDialog.setMessage("加载中..."); // 设置加载信息
progressDialog.setIndeterminate(true); // 设置进度条是否为不确定模式
progressDialog.setCancelable(false); // 设置是否可以通过点击Back键取消
progressDialog.show(); // 显示ProgressDialog

在上面的代码中，我设置了进度条的样式为圆形（旋转的），并且是不确定模式，这意味着进度条会一直旋转，直到任务完成。我们还设置了一个消息来告诉用户正在加载，并且禁止用户取消对话框。

更新ProgressDialog的进度

如果你的任务有确定的进度，你可以使用水平样式的ProgressDialog，并更新进度条的值：

ProgressDialog progressDialog = new ProgressDialog(MyActivity.this);
progressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
progressDialog.setMax(100); // 设置最大进度
progressDialog.setProgress(0); // 设置当前进度
progressDialog.show();

// 在你的任务中更新进度
progressDialog.setProgress(50); // 假设任务完成了一半

后续可以启用线程进行更新进度条！

注意：虽然ProgressDialog是一个非常有用的组件，但自Android API 26开始，它已被标记为过时。Google建议开发者使用其他方式来显示进度，比如使用ProgressBar组件或者自定义对话框。

更多方法

方法	描述
setProgressStyle(int style)	设置进度条的样式。ProgressDialog.STYLE_SPINNER为圆形旋转样式，ProgressDialog.STYLE_HORIZONTAL为水平进度条样式。
setMessage(CharSequence message)	设置在进度条中显示的消息。
setIndeterminate(boolean indeterminate)	设置进度条是否为不确定模式。如果为true，进度条将持续旋转，否则显示具体进度。
setCancelable(boolean flag)	设置对话框是否可以被取消。如果为false，则不能通过按返回键取消对话框。
setMax(int max)	设置水平进度条的最大值。
setProgress(int value)	设置水平进度条的当前进度值。
setSecondaryProgress(int secondaryProgress)	设置水平进度条的第二进度值，通常用于显示次要进度，如缓冲进度。
setProgressNumberFormat(String format)	设置水平进度条中显示的数字格式。
setProgressPercentFormat(NumberFormat format)	设置水平进度条中百分比的格式。
setButton(int whichButton, CharSequence text, DialogInterface.OnClickListener listener)	设置对话框上的按钮和它们的点击事件处理器。
show()	创建并显示ProgressDialog。

效果预览

Broadcast Receiver动态广播

在Android开发中，BroadcastReceiver是用于响应系统或应用程序发出的广播消息的组件。动态注册BroadcastReceiver意味着在代码中注册接收器，而不是在AndroidManifest.xml文件中静态注册。这样做的好处是可以更灵活地控制广播接收器的注册和注销，使其能够在运行时根据需要监听广播。

public class broadActivity extends AppCompatActivity {

    private NetworkChangeReceiver networkChangeReceiver;

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

        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");

        NetworkChangeReceiver networkChangeReceiver = new NetworkChangeReceiver();
        registerReceiver(networkChangeReceiver,intentFilter);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        unregisterReceiver(networkChangeReceiver);
    }

    class NetworkChangeReceiver extends BroadcastReceiver{

        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context,"network changes",Toast.LENGTH_SHORT).show();
        }
    }
}

在broadActivity类中，我们首先定义了一个名为networkChangeReceiver的NetworkChangeReceiver实例。这个内部类继承自BroadcastReceiver，并重写了onReceive方法，以便在接收到广播时执行特定的操作。

在onCreate方法中，我们创建了一个IntentFilter对象，并为其添加了一个作"android.net.conn.CONNECTIVITY_CHANGE"。这个动作是系统在网络状态发生变化时发送的广播。

IntentFilter intentFilter = new IntentFilter();
intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");

然后，我们实例化了NetworkChangeReceiver并通过registerReceiver方法注册它。这意味着，只要网络状态发生变化，我们的NetworkChangeReceiver就会被通知。

NetworkChangeReceiver networkChangeReceiver = new NetworkChangeReceiver();
registerReceiver(networkChangeReceiver, intentFilter);

最后，在onDestroy方法中，我们通过unregisterReceiver方法注销了networkChangeReceiver。这是一个很好的实践，因为它可以防止潜在的内存泄漏。

unregisterReceiver(networkChangeReceiver);

NetworkChangeReceiver类是我们自定义的BroadcastReceiver。在onReceive方法中，我们使用Toast消息通知用户网络状态的变化。

注意：因为使用的系统网络相关的广播，所以这里需要开启Android应用的系统网络权限，在AndroidManifest.xml文件中，添加此代码即可<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

之后，当系统网络发送变化，会默认弹出此提示network changes

效果预览

SharedPreferences数据操作

SharedPreferences提供了一种方便的方法来存储和检索键值对数据。与数据库相比，它更适合存储少量的数据，如登录状态、用户设置等。

如何使用SharedPreferences？

使用SharedPreferences非常简单。以下是基本的步骤：

1. 获取SharedPreferences对象： 你可以通过调用Context的getSharedPreferences方法来获取SharedPreferences对象。这个方法需要两个参数：文件名和模式。

SharedPreferences sharedPreferences = getSharedPreferences("MyPrefs", MODE_PRIVATE);

在Android开发中，MODE_PRIVATE是SharedPreferences文件的一个操作模式。当你使用这个模式创建SharedPreferences文件时，它意味着这个文件是私有的，只能被创建它的应用程序访问。换句话说，其他应用程序无法读取或写入这个文件。

除了MODE_PRIVATE，在Android的SharedPreferences中还有其他几种操作模式，但请注意，其中一些模式已经被弃用，因为它们可能导致安全问题。以下是所有的模式：

• MODE_PRIVATE：这是最常用的模式，它设置文件为私有数据，只能被调用的应用程序访问。如果文件已存在，写入的内容将覆盖原文件的内容1。
• MODE_APPEND：在这个模式下，如果文件存在，就会检查文件并在文件末尾追加内容；如果文件不存在，就会创建新文件2。

弃用的模式不过多说明

2. 读写数据： 要写入数据，你需要使用SharedPreferences.Editor对象。通过调用edit()方法来获取它，然后使用put系列方法来添加或更新键值对。

SharedPreferences.Editor editor = sharedPreferences.edit();
editor.putString("key", "value");
editor.commit();

要读取数据，直接使用SharedPreferences对象的get系列方法。当你调用.edit()方法时，你会进入编辑模式，可以添加、更新或删除SharedPreferences中的键值对。

String value = sharedPreferences.getString("key", "default_value");

3. 提交更改： 当你完成了更改，需要调用commit()或apply()方法来保存。请注意，所有的更改都是在调用commit()或apply()之后才会被持久化保存的。在此之前，所有的更改都只存在于内存中。

布局

LinearLayout线性布局

LinearLayout 是 Android 开发中一种非常常用的布局方式，它将包含的控件按照水平或垂直方向依次排列。如果是水平排列，垂直方向上只能有一个控件；如果是垂直排列，则水平方向上只能有一个控件。这个布局会将它所包含的控件，在线性的方向上依次排列，可以通过orientation属性指定方向：

• vertical：垂直布局
• horizontal：水平布局

LinearLayout 常用属性

• android:orientation：设置线性布局的排列方向，vertical 为垂直排列，horizontal 为水平排列。
• android:gravity：控制子控件的对齐方式。可以让子控件对齐右边缘或底部边缘。
• android:layout_gravity：设置子控件在父控件中的摆放位置，优先级高于父控件的 gravity。
• android:layout_weight：按比例分配控件占用父控件的大小。

效果演示

LinearLayout 又称作线性布局，是 Android 开发中最常见的布局之一。下面是一个简单的示例，展示了如何在布局文件中使用 LinearLayout 来垂直排列三个按钮：

<?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="horizontal"
    >

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_weight="1"
        android:text="按钮1"
        />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="center_vertical"
        android:layout_weight="1"
        android:text="按钮2"
        />

    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom"
        android:layout_weight="1"
        android:text="按钮3"
        />
</LinearLayout>

RelativeLayout相对布局

RelativeLayout 是 Android 开发中最常用的布局之一，它允许您根据父容器和兄弟控件的位置来确定控件的位置。在 RelativeLayout 中，您可以使用各种属性来精确控制子视图的排列。可以通过相对定位的方式，让控件出现在布局的任何位置。

RelativeLayout 是一种根据父容器和兄弟控件作为参照来确定控件位置的布局方式。要使用相对布局，您需要将布局节点改成 RelativeLayout，基本格式如下：

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

    <!-- 在这里添加子视图 -->

</RelativeLayout>

根据父容器定位

在相对布局中，您可以使用以下属性将控件放置在父容器的不同位置：

• android:layout_alignParentLeft=“true”：控件左对齐父容器。
• android:layout_alignParentRight=“true”：控件右对齐父容器。
• android:layout_alignParentTop=“true”：控件顶部对齐父容器。
• android:layout_alignParentBottom=“true”：控件底部对齐父容器。
• android:layout_centerHorizontal=“true”：水平方向居中。
• android:layout_centerVertical=“true”：垂直方向居中。
• android:layout_centerInParent=“true”：水平和垂直都居中。

根据兄弟控件定位

在相对布局中，还可以使用已确定位置的控件作为参考来确定其他控件的位置。以下是一些常用的属性：

• android:layout_toLeftOf=“@+id/button1”：在 button1 控件的左侧。
• android:layout_toRightOf=“@+id/button1”：在 button1 控件的右侧。
• android:layout_above=“@+id/button1”：在 button1 控件的上方。
• android:layout_below=“@+id/button1”：在 button1 控件的下方。
• android:layout_alignLeft=“@+id/button1”：与 button1 控件的左边平齐。
• android:layout_alignRight=“@+id/button1”：与 button1 控件的右边平齐。
• android:layout_alignTop=“@+id/button1”：与 button1 控件的上边平齐。
• android:layout_alignBottom=“@+id/button1”：与 button1 控件的下边平齐。

效果演示

<?xml version="1.0" encoding="utf-8"?>
<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"
    tools:context=".relativeActivity">

    <Button
        android:id="@+id/rel_btn1"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="按钮1"
        android:layout_alignParentRight="true"
        />

    <Button
        android:id="@+id/rel_btn2"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="按钮2"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        />

    <Button
        android:id="@+id/rel_btn3"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="按钮3"
        android:layout_alignParentLeft="true"
        android:layout_alignParentBottom="true"
        />

    <Button
        android:id="@+id/rel_btn4"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="按钮4"
        android:layout_below="@id/rel_btn2"
        android:layout_alignRight="@id/rel_btn2"
        />
</RelativeLayout>

ConstraintLayout约束布局

ConstraintLayout 是 Android 开发中最常用的布局之一，它允许您根据父容器和兄弟控件的位置来确定控件的位置。在 ConstraintLayout 中，您可以使用各种属性来精确控制子视图的排列。

ConstraintLayout 是一种根据父容器和兄弟控件作为参照来确定控件位置的布局方式。要使用约束布局，您需要将布局节点改成 ConstraintLayout，基本格式如下：

<androidx.constraintlayout.widget.ConstraintLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <!-- 在这里添加子视图 -->

</androidx.constraintlayout.widget.ConstraintLayout>

根据父容器定位

在约束布局中，您可以使用以下属性将控件放置在父容器的不同位置：

• app:layout_constraintStart_toStartOf=“parent”：控件左对齐父容器。
• app:layout_constraintEnd_toEndOf=“parent”：控件右对齐父容器。
• app:layout_constraintTop_toTopOf=“parent”：控件顶部对齐父容器。
• app:layout_constraintBottom_toBottomOf=“parent”：控件底部对齐父容器。
• app:layout_constraintHorizontal_bias=“0.5”：水平方向偏移量，0.5 表示居中。
• app:layout_constraintVertical_bias=“0.5”：垂直方向偏移量，0.5 表示居中。

根据兄弟控件定位

在约束布局中，您还可以使用已确定位置的控件作为参考来确定其他控件的位置。以下是一些常用的属性：

• app:layout_constraintStart_toEndOf=“@+id/button1”：在 button1 控件的右侧。
• app:layout_constraintEnd_toStartOf=“@+id/button1”：在 button1 控件的左侧。
• app:layout_constraintTop_toBottomOf=“@+id/button1”：在 button1 控件的下方。
• app:layout_constraintBottom_toTopOf=“@+id/button1”：在 button1 控件的上方。

自定义布局

使用步骤

1. 创建新的XML布局文件
2. 设计自定义视图
3. 加载自定义布局

这里以定义一个标题栏布局，方便其他页面引用作为讲解，首先在res.layout目录下，新建一个xml文件

<?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="wrap_content"
    android:background="#000000">
    <Button
        android:layout_width="10dp"
        android:layout_height="40dp"
        android:background="@drawable/back"
        android:layout_margin="10dp"
        android:layout_weight="1"
        android:layout_gravity="center"/>

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="标题栏"
        android:textColor="#ffffff"
        android:textSize="30dp"
        android:layout_weight="3"
        android:layout_gravity="center"
        android:gravity="center"/>

    <Button
        android:layout_width="10dp"
        android:layout_height="40dp"
        android:background="@drawable/edit"
        android:layout_margin="10dp"
        android:layout_weight="1"
        android:layout_gravity="center"/>
</LinearLayout>

效果预览

注意：图片素材需要自己寻找

之后，在需要引入的页面使用<include>标签引入此标题栏

<include>标签在 Android Studio 中用于实现布局的复用，特别适合在界面布局复杂、不同界面有共用布局的应用中。例如，一个应用的顶部布局、侧边栏布局、底部 Tab 栏布局、ListView 和 GridView 每一项的布局等，可以通过 标签引用这些共用布局，从而降低布局的复杂度并实现布局重用。下面是使用 标签的方法和注意事项：

在布局文件中需要引用其他布局的地方，使用 layout=“@layout/child_layout” 即可。例如，如果你有一个名为 titlebar.xml 的共用布局，可以在其他布局中这样引用它：

<include layout="@layout/titlebar" />

注意：在 Android 布局文件中使用 标签引用其他布局时，实际上是将被引用的布局的 XML 内容插入到当前布局中。这意味着，被引用布局的属性会与包裹 的父布局的属性进行合并。如果在 中设置了 layout 属性，它会覆盖父布局的相应属性，可能导致布局效果不如预期。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout 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"
    tools:context=".MainActivity"
    android:orientation="vertical">

    <include layout="@layout/title"/>

    <EditText
        android:id="@+id/edit_text1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="请输入内容"/>

    <Button
        android:id="@+id/Button_1"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center"
        android:textSize="20sp"
        android:text="登录"/>
</LinearLayout>

注意（取消显示系统自带的标题栏）

此时加载，默认还有系统自带的标题栏，这里需要在对应的页面进行取消。复制下列代码！

//取消系统默认的标题栏
ActionBar supportActionBar = getSupportActionBar();
if (supportActionBar != null){
    supportActionBar.hide();
}

获取当前活动（Activity）的 ActionBar 对象，然后检查它是否为 null。如果不为 null，就调用 hide() 方法来隐藏整个 ActionBar，包括其中的选项卡。

或者将style文件中的parent属性的值切换为：Theme.AppCompat.Light.NoActionBar，默认的是：Theme.AppCompat.Light.DarkActionBar

• Theme.AppCompat.Light.NoActionBar：这个主题用于设置整个应用程序的全局主题。它适用于不需要显示顶部标题栏（ActionBar）的情况。如果你的应用程序不需要默认的 ActionBar，你可以选择这个主题。
• Theme.AppCompat.Light.DarkActionBar：这个主题也用于设置整个应用程序的全局主题。它适用于需要显示顶部标题栏（ActionBar）的情况。如果你的应用程序需要默认的 ActionBar，并且你希望它的文本颜色为深色，你可以选择这个主题。

适配器

BaseAdapter

BaseAdapter 是一个抽象类，它提供了适配器的基本功能。当我们自定义适配器时，通常会继承这个类并实现其中的抽象方法。因此，BaseAdapter 具有较高的灵活性，但需要我们自己实现一些方法。

用法
继承 BaseAdapter 类。实现以下抽象方法：

• getCount()：返回数据集中的项数。
• getItem(int position)：返回指定位置的数据项。
• getItemId(int position)：返回指定位置的数据项的 ID。
• getView(int position, View convertView, ViewGroup parent)：返回一个视图，用于显示指定位置的数据项。
  • convertView是一个可复用的视图，用于显示子项的内容。当滚动列表时，旧的子项会被回收并传递给 getView() 方法作为 convertView。如果 convertView 不为空，我们可以直接使用它，避免重复创建视图，提高性能。如果 convertView 为空，我们需要创建一个新的视图。
  • parent是子项视图的父容器，通常是 ListView 或其他列表视图。我们可以使用这个参数来获取上下文、资源等信息。在创建新的子项视图时，我们需要将其添加到 parent 中。

SimpleAdapter

SimpleAdapter 是一个简单适配器，它可以显示复杂的信息。它的数据源形式是 List<Map<String, ?>>，适用于显示多个字段的数据。
用法
准备好数据源，通常是一个 List<Map<String, ?>>。创建一个 SimpleAdapter 对象，传入上下文、数据源、条目布局和数据源数据的键数组以及对应的条目布局控件 ID 数组。

ArrayAdapter

ArrayAdapter 是数组适配器，它只能显示一条文本信息。它支持泛型操作，最为简单，适用于展示单一文本的数据。
用法
准备好数据源，通常是一个数组。创建一个 ArrayAdapter 对象，传入上下文、数据源和一个内置的布局资源文件（例如 android.R.layout.simple_list_item_1）。

// 准备数据源
String[] dataArray = {"Apple", "Banana", "Orange"};

// 创建 ArrayAdapter
ArrayAdapter<String> arrayAdapter = new ArrayAdapter<>(this,
        android.R.layout.simple_list_item_1, dataArray);

// 设置适配器
ListView listView = findViewById(R.id.list_view);
listView.setAdapter(arrayAdapter);

nflate方法

nflate() 方法是 Android 中的一个重要方法，用于将 XML 布局文件转换为视图对象。它通常在适配器中的 getView() 方法中使用，用于创建或复用子项的视图。
参数：

• resource：要加载的布局资源的 ID。
• root：父容器，即要将布局添加到哪个容器中。如果为 null，则不添加到任何容器中。
• attachToRoot：是否将布局添加到父容器中。如果为 true，则添加；如果为 false，则只加载布局但不添加。