Android_Studio学习笔记-04（四大组件与Activity的使用）

一、四大组件概览

Android 的四大组件是构建 Android 应用的核心基础，每个组件都有特定的用途和生命周期。

共同特点：

• 都必须在AndroidManifest.xml中注册

• 都通过Intent进行通信和激活

• 都有各自的生命周期

• 都在主线程中运行（需要注意避免ANR）

二、Activity

2.1 什么是Activity？

Activity是Android应用的入口点，代表一个单一屏幕的用户界面。

// Activity继承关系
java.lang.Object
↳ android.content.Context
↳ android.content.ContextWrapper
↳ android.view.ContextThemeWrapper
↳ android.app.Activity
↳ androidx.appcompat.app.AppCompatActivity ← 我们最常用

2.2 Activity的基本特征

• 每个Activity都是一个独立的类

• 必须继承自Activity类或其子类

• 每个Activity都需要在AndroidManifest.xml中注册

• 一个应用可以有多个Activity

• Activity之间通过Intent进行通信

2.3 Activity的完整生命周期

创建 → 开始 → 恢复 → 运行 → 暂停 → 停止 → 销毁

2.4 生命周期方法详解

2.4.1 onCreate() – 创建阶段

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

// 这是Activity的第一个回调方法
// 作用：
// 1. 初始化Activity（绑定布局、初始化变量）
// 2. 恢复之前保存的状态（savedInstanceState）
// 3. 进行一次性设置

// 注意事项：
// – 必须调用super.onCreate()
// – 只能调用一次（除非Activity被系统杀死后重建）
// – 不要在这里做耗时操作（可能导致ANR）
}

面试重点：Bundle savedInstanceState的作用

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

// 判断Activity是正常创建还是重建
if (savedInstanceState == null) {
// 正常创建，首次启动
Log.d("TAG", "Activity首次创建");
} else {
// Activity被系统杀死后重建
// 可以恢复之前保存的数据
String savedData = savedInstanceState.getString("key");
int savedNumber = savedInstanceState.getInt("number", 0);
}
}

2.4.2 onStart() – 可见但不可交互

@Override
protected void onStart() {
super.onStart();
// Activity即将变得可见
// 但还没有出现在前台，不能与用户交互

// 常见用途：
// 1. 注册广播接收器
// 2. 开始监听传感器
// 3. 初始化需要可见时才需要的资源
}

2.4.3 onResume() – 可交互状态

@Override
protected void onResume() {
super.onResume();
// Activity已经可见且可以交互
// Activity现在位于活动堆栈的顶部

// 常见用途：
// 1. 启动动画
// 2. 打开相机预览
// 3. 开始播放音频/视频
// 4. 恢复UI更新
}

2.4.4 onPause() – 部分可见

@Override
protected void onPause() {
super.onPause();
// Activity失去焦点，部分可见
// 另一个Activity正在启动（覆盖部分屏幕）

// 注意事项：
// 1. 必须快速执行（不要做耗时操作）
// 2. 通常在这里保存持久化数据
// 3. 释放CPU密集型资源

// 常见用途：
// 1. 暂停动画
// 2. 提交未保存的数据
// 3. 释放相机等独占资源
}

2.4.5 onStop() – 完全不可见

@Override
protected void onStop() {
super.onStop();
// Activity完全不可见
// 另一个Activity已经覆盖了当前Activity

// 常见用途：
// 1. 注销广播接收器
// 2. 停止网络请求
// 3. 释放大内存对象
// 4. 保存数据库操作
}

2.4.6 onRestart() – 重新启动

@Override
protected void onRestart() {
super.onRestart();
// Activity从停止状态重新回到前台

// 注意：onRestart()只会在onStop()后调用
// 不会在onPause()后直接调用
}

2.4.7 onDestroy() – 销毁阶段

@Override
protected void onDestroy() {
super.onDestroy();
// Activity被销毁前最后一个回调
// 调用finish()或被系统销毁时会触发

// 常见用途：
// 1. 取消所有异步任务
// 2. 关闭数据库连接
// 3. 释放所有资源
// 4. 解除所有绑定

// 注意：不能保证一定会被调用！
// 极端情况下（系统急需内存），Activity可能直接被杀死
}

2.5 生命周期状态图

[不存在]
↓ (创建)
[创建中] → onCreate()
↓
[已创建] → onStart()
↓
[已开始] → onResume()
↓
[已恢复] ←→ onPause()
↓
[已暂停] → onStop()
↓
[已停止] ←→ onRestart()
↓
[已销毁] → onDestroy()
↓
[不存在]

2.6 常见场景的生命周期变化

场景1：启动新Activity

当前Activity：onPause() → onStop()
新Activity：onCreate() → onStart() → onResume()

场景2：返回原Activity

当前Activity：onPause() → onStop() → onDestroy()
原Activity：onRestart() → onStart() → onResume()

场景3：弹出对话框（不覆盖全屏）

当前Activity：onPause()
对话框关闭：onResume()

场景4：屏幕旋转（配置更改）

onPause() → onStop() → onDestroy()
onCreate() → onStart() → onResume()

2.7  Activity的启动模式

2.7.1 在AndroidManifest.xml中配置

<activity
android:name=".MainActivity"
android:launchMode="standard" <!– 启动模式 –>
android:taskAffinity="" <!– 任务亲和性 –>
android:allowTaskReparenting="true|false"
android:clearTaskOnLaunch="true|false"
android:alwaysRetainTaskState="true|false"
android:finishOnTaskLaunch="true|false"
android:documentLaunchMode="none|intoExisting|always|never">
</activity>

2.7.2 四种启动模式

1 standard（标准模式）- 默认

// 特点：
// 1. 每次启动都创建新实例
// 2. 谁启动了这个Activity，该Activity就运行在谁的任务栈中
// 3. 同一个任务栈中可以有多个相同的Activity实例

// 实际例子：
// 任务栈状态：[A, B, C] → 在C中启动B → [A, B, C, B]
// 按返回键：B → C → B → A

// 使用场景：大多数普通页面

2 singleTop（栈顶复用模式）

// 特点：
// 1. 如果Activity已经在栈顶，则复用，调用onNewIntent()
// 2. 如果不在栈顶，则创建新实例
// 3. 避免重复打开同一个Activity

// 实际例子：
// 任务栈状态：[A, B] → 在B中启动B → [A, B]（复用B）
// 任务栈状态：[A, B] → 在B中启动A → [A, B, A]（创建新A）

// 使用场景：
// 1. 搜索页面（避免重复打开）
// 2. 通知跳转
// 3. 防止快速点击多次打开同一个页面

// onNewIntent()方法：
@Override
protected void onNewIntent(Intent intent) {
super.onNewIntent(intent);
// 当singleTop Activity被复用时调用
// 可以在这里更新UI或处理新的Intent
setIntent(intent); // 更新当前的intent
processIntent(intent); // 处理新的意图
}

3 singleTask（栈内复用模式）

// 特点：
// 1. 整个任务栈中只允许有一个实例
// 2. 如果已存在，则清除该实例上面的所有Activity
// 3. 会调用onNewIntent()
// 4. 可以指定任务栈（通过taskAffinity）

// 实际例子：
// 任务栈状态：[A, B, C, D] → 启动B（singleTask） → [A, B]
// 按返回键：直接回到A

// 使用场景：
// 1. 主页面（Home）
// 2. 登录页面
// 3. 应用中唯一的页面（如设置页面）

4 singleInstance（单实例模式）

// 特点：
// 1. 单独的任务栈，且该任务栈中只有这个Activity
// 2. 其他Activity不能进入这个任务栈
// 3. 应用间共享页面

// 实际例子：
// 启动A（singleInstance）：任务栈1：[A]
// 从A启动B（standard）：任务栈2：[B]
// 按返回键：B消失，显示A

// 使用场景：
// 1. 拨号界面
// 2. 锁屏界面
// 3. 与其他应用共享的页面

2.8 Intent Flag与启动模式结合

// 通过Intent Flag可以动态改变启动行为
Intent intent = new Intent(this, TargetActivity.class);

// 常用Flag组合：
// 1. 清除返回栈
intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK |
Intent.FLAG_ACTIVITY_NEW_TASK);

// 2. 单例模式（类似singleInstance）
intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
Intent.FLAG_ACTIVITY_MULTIPLE_TASK);

// 3. 不保存到历史栈
intent.setFlags(Intent.FLAG_ACTIVITY_NO_HISTORY);

// 4. 重用已有的（类似singleTop）
intent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP |
Intent.FLAG_ACTIVITY_CLEAR_TOP);

// 面试题：FLAG_ACTIVITY_CLEAR_TOP和FLAG_ACTIVITY_CLEAR_TASK的区别？
// – CLEAR_TOP：清除目标Activity之上的所有Activity
// – CLEAR_TASK：清除整个任务栈中的所有Activity

2.9 Activity间的数据传递

2.9.1 基本数据传递

// 发送数据
public void navigateToDetail() {
Intent intent = new Intent(this, DetailActivity.class);

// 基本数据类型
intent.putExtra("id", 1001);
intent.putExtra("title", "商品详情");
intent.putExtra("price", 299.99);
intent.putExtra("isAvailable", true);

// 数组类型
intent.putExtra("tags", new String[]{"新品", "热销", "折扣"});

// Bundle对象（用于传递多个数据）
Bundle bundle = new Bundle();
bundle.putString("name", "商品名称");
bundle.putInt("stock", 100);
intent.putExtras(bundle);

startActivity(intent);
}

// 接收数据
public class DetailActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

Intent intent = getIntent();
int id = intent.getIntExtra("id", 0); // 0是默认值
String title = intent.getStringExtra("title");
double price = intent.getDoubleExtra("price", 0.0);
boolean isAvailable = intent.getBooleanExtra("isAvailable", false);
String[] tags = intent.getStringArrayExtra("tags");

// 从Bundle获取
Bundle bundle = getIntent().getExtras();
if (bundle != null) {
String name = bundle.getString("name");
int stock = bundle.getInt("stock");
}
}
}

2.9.2 传递对象（必须序列化）

方式1：实现Serializable接口

// 1. 定义可序列化的Java Bean
public class Product implements Serializable {
private static final long serialVersionUID = 1L; // 序列化ID

private int id;
private String name;
private double price;

// 构造函数、getter、setter…

// Serializable优点：简单，自动序列化所有字段
// 缺点：性能差，通过反射实现
}

// 2. 传递对象
Product product = new Product(1001, "手机", 2999);
Intent intent = new Intent(this, DetailActivity.class);
intent.putExtra("product", product);
startActivity(intent);

// 3. 接收对象
Product receivedProduct = (Product) getIntent()
.getSerializableExtra("product");

方式2：实现Parcelable接口（Android推荐）

// 1. 定义Parcelable对象
public class Product implements Parcelable {
private int id;
private String name;
private double price;

// 构造方法、getter、setter…

// 2. 实现Parcelable接口
protected Product(Parcel in) {
id = in.readInt();
name = in.readString();
price = in.readDouble();
}

@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(id);
dest.writeString(name);
dest.writeDouble(price);
}

@Override
public int describeContents() {
return 0;
}

// 3. 创建CREATOR字段（必须）
public static final Creator<Product> CREATOR = new Creator<Product>() {
@Override
public Product createFromParcel(Parcel in) {
return new Product(in);
}

@Override
public Product[] newArray(int size) {
return new Product[size];
}
};
}

// 4. 传递和接收
Product product = new Product(1001, "手机", 2999);
intent.putExtra("product", product); // 直接传递Parcelable对象

Product receivedProduct = getIntent().getParcelableExtra("product");

// Parcelable优点：性能好，Android原生支持
// 缺点：代码较复杂

2.9.3 带返回结果的跳转

// MainActivity.java
public class MainActivity extends AppCompatActivity {
private static final int REQUEST_CODE_SELECT = 1001;
private static final int REQUEST_CODE_EDIT = 1002;

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

Button btnSelect = findViewById(R.id.btn_select);
btnSelect.setOnClickListener(v -> {
// 启动选择页面，期望返回结果
Intent intent = new Intent(this, SelectionActivity.class);
startActivityForResult(intent, REQUEST_CODE_SELECT);
});
}

// 处理返回结果
@Override
protected void onActivityResult(int requestCode, int resultCode,
@Nullable Intent data) {
super.onActivityResult(requestCode, resultCode, data);

if (resultCode == RESULT_OK) {
switch (requestCode) {
case REQUEST_CODE_SELECT:
if (data != null) {
String selectedItem = data.getStringExtra("selected_item");
// 更新UI
updateSelection(selectedItem);
}
break;

case REQUEST_CODE_EDIT:
// 处理编辑结果
break;
}
} else if (resultCode == RESULT_CANCELED) {
// 用户取消了操作
Toast.makeText(this, "操作已取消", Toast.LENGTH_SHORT).show();
}
}
}

// SelectionActivity.java
public class SelectionActivity extends AppCompatActivity {

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

Button btnConfirm = findViewById(R.id.btn_confirm);
btnConfirm.setOnClickListener(v -> {
// 返回结果给调用者
Intent resultIntent = new Intent();
resultIntent.putExtra("selected_item", "已选择的内容");

// 设置结果码和返回数据
setResult(RESULT_OK, resultIntent);

// 关闭当前Activity
finish();

// 可选的返回动画
overridePendingTransition(R.anim.slide_in_left, R.anim.slide_out_right);
});

Button btnCancel = findViewById(R.id.btn_cancel);
btnCancel.setOnClickListener(v -> {
// 取消操作
setResult(RESULT_CANCELED);
finish();
});
}

// 处理返回键
@Override
public void onBackPressed() {
setResult(RESULT_CANCELED);
super.onBackPressed();
}
}

2.9.4 使用ActivityResult API（推荐）

// 新的API，更灵活，推荐使用
public class MainActivity extends AppCompatActivity {
private ActivityResultLauncher<Intent> launcher;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

// 注册结果回调
launcher = registerForActivityResult(
new ActivityResultContracts.StartActivityForResult(),
result -> {
if (result.getResultCode() == RESULT_OK) {
Intent data = result.getData();
if (data != null) {
String resultData = data.getStringExtra("result");
// 处理结果
}
}
}
);

Button btnStart = findViewById(R.id.btn_start);
btnStart.setOnClickListener(v -> {
Intent intent = new Intent(this, TargetActivity.class);
launcher.launch(intent);
});
}
}