《第一行代码Andorid》阅读笔记-第一章

《第一行代码Andorid》阅读笔记-第一章
这篇文章是我自己的《第一行代码Andorid》的阅读笔记，虽然大量参考了别人已经写好的一些笔记和代码但是也有自己的提炼和新的问题在里面，我也会放上参考文章链接。

学习重点

Android系统的四大组件：
（1）活动（Activity）：是所有Android应用程序的门面，凡是在应用中你看得到的东西，都是放在活动中的。
（2）服务（Service）：你无法看到它，但它会一直在后台默默地运行，即使用户退出了应用，服务仍然是可以继续运行的。
（3）广播接收器（Broadcast Receiver）：广播接收器允许你的应用接收来自各处的广播消息，比如电话、短信等，当然你的应用同样也可以向外发出广播消息。
（4）内容提供器（Content Provider）：为应用程序之间共享数据提供了可能，比如你想要读取系统电话簿中的联系人，就需要通过内容提供器来实现。

参考笔记

https://www.cnblogs.com/1693977889zz/p/16256303.html

开始第一个Android项目

注意点：
1. 如果要跟着《第一行代码：Android篇（第2版）》这本书学习一定一定一定要把SDK版本以及设备模拟器设置成和书里一样的，我一开始就是因为SDK版本太高出现了很多的错误和不同之处。以前的旧版本虽然和新版本有不一样的地方但是不影响理解Android架构。书中的配置是：
  Minimum SDK：API 15
  设备模拟器：Nexus 5X
  操作系统版本：API Level： 24 ，Target： Android 7.0 (Google Play)
2. 多用调试工具Log而不是System.out
  除了Log.v()、Log.d()、Log.i()、Log.w()、Log.w()之外，logcat中还能很轻松地添加过滤器
  目前只有3个过滤器：
- Show only selected application表示只显示当前选中程序的日志；
- Firebase是谷歌提供的一个分析工具，我们可以不用管它；
- NoFilters相当于没有过滤器，会把所有的日志都显示出来；
1. 目录结构略，可以参考上面提供的笔记链接，和书上的内容一样。
第一章活动

注意点：
1. 第一次Greadle构建需要点时间，要下载很多东西，需要翻墙，可能失败，没关系多试几次。
2. 新建project的时候记得一定要选择语言为Java，但是注意如果选择Empty Activity就会没有语言选择的选项，所以我们跟着书上选择No Activity或者Empty View Activity
  暂时无法在飞书文档外展示此内容
1. 活动的基本用法🎯

1.1 创建活动
1. 在创建新的活动的时候会遇到几个选项：
- 勾选Generate Layout File表示会自动为FirstActivity创建一个对应的布局文件
- 勾选Launcher Activity表示会自动将FirstActivity设置为当前项目的主活动
1. 创建的.xml的layout布局文件在右上角可以有几种模式选择
- Code Mode（代码模式）：
  这个模式允许您直接编辑布局文件的 XML 代码。您可以在这里手动编写 XML 代码来定义布局结构、属性和样式。这是最灵活的方式，适用于对 XML 布局代码熟悉的开发者。
- Split Mode（分割模式）：
  这个模式将布局文件分为两个窗格，上半部分显示布局的设计预览，下半部分显示布局的 XML 代码。这允许您同时查看设计和代码，方便调整布局时的实时预览以及在代码中进行必要的修改。
- Design Mode（设计模式）：
  这个模式提供了一个可视化的界面，允许您通过拖放组件、设置属性和布局，以图形方式创建和编辑布局。在这个模式下，您可以快速预览 UI 的外观，而不需要直接编辑代码。
1.2 活动注册

所有的活动都要在AndroidManifest.xml中进行注册才能生效，一般编辑器会帮我们自动注册。
1. intent-filter用于指定主活动,即点击桌面应用程序图标时首先打开的就是这个活动。
```
        
        

1
2
3
4
```
1. android:label指定活动中标题栏的内容
```
android:label="This is FirstActivity"
1
```
1.3 提醒小弹窗Toast

Toast是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，这些信息会在一段时间后自动消失，并且不会占用任何屏幕空间。
下面这段代码我们一般放在点击事件里面
Toast.makeText(FirstActivity.this,“You clicked Button 1”,Toast.LENGTH_SHORT).show();
makeText()方法需要传入3个参数。
- 第一个参数是Context，是Toast要求的上下文，由于活动本身就是一个Context对象，因此这里直接传入FirstActivity.this即可。
- 第二个参数是Toast显示的文本内容。
- 第三个参数是Toast显示的时长，有两个内置常量可以选择Toast.LENGTH_SHORT和Toast.LENGTH_LONG。
1.4 顶部小菜单Menu

效果是在标题栏的右侧多了一个三点的符号，这个就是菜单按钮。点击之后会显示多个我们定义好的菜单按键，使用方式如下：
1. 新建菜单文件：文件夹→New→Menu resource file
2. 编写菜单按钮：在main.xml中添加代码
```
    
    

1
2
3
4
5
```
上面的代码建了两个菜单项，其中标签就是用来创建具体的某一个菜单项，然后通过android:id给这个菜单项指定一个唯一的标识符，通过android:title给这个菜单项指定一个名称。
3. 给当前活动创建菜单：回到FirstActivity中来重写onCreateOptionsMenu()方法，重写的内容里面通过getMenuInflater()方法能够得到MenuInflater对象再调用它的inflate()方法就可以给当前活动创建菜单。
```
@Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.main,menu);
        return true;
    }
1
2
3
4
5
```
1. 给菜单按钮编写逻辑处理：在FirstActivity中重写onOptionsItemSelected()方法，
```
@Override
public boolean onOptionsItemSelected(@NonNull MenuItem item) {

    if(item.getItemId() == R.id.add_item)
        Toast.makeText(this,"You clicked Add",Toast.LENGTH_SHORT).show();
    if(item.getItemId() == R.id.remove_item)
        Toast.makeText(this,"You clicked Remove",Toast.LENGTH_SHORT).show();
    return true;
}
1
2
3
4
5
6
7
8
9
```
注意这里的代码和书上的不一样，因为现在好像不能使用 case R.id.add_item了，必须是一个静态常量才行，所以我换成了if语句判断。这样写完后点击菜单按钮就会有不同的处理回应了。

1.5 销毁一个活动 finish()

销毁活动的方式有两种，一种是按一下Back键，另一种是通过代码 finish();

2. 活动之间的跳转🎯

2.1 活动间的跳转Intent

Intent是Android程序中各组件之间进行交互的一种重要方式，它不仅可以指明当前组件想要执行的动作，还可以在不同组件之间传递数据。Intent一般可被用于启动活动、启动服务以及发送广播等场景。
Intent大致可以分为两种：显式Intent和隐式Intent。

2.1.1 显式使用

在FirstActivity的中按钮的点击事件中加入以下代码：
Intent intent=new Intent(FirstActivity.this,SecondActivity.class);
startActivity(intent);
第一个参数是FirstActivity.this作为上下文
第二个参数是SecondActivity这个活动
这样就会在点击按钮时运行这段代码启动SecondActivity活动

2.1.2 隐式使用

它并不明确指出我们想要启动哪一个活动，而是指定了一系列更为抽象的action和category等信息，然后交由系统去分析这个Intent，并帮我们找出合适的活动去启动。
1. 在标签下配置的内容，可以指定当前活动能够响应的action和category
```
    
    
    

1
2
3
4
5
```
这时候的FirstActivity中按钮的点击事件中的Intent 要这么写：
```
Intent intent=new Intent("com.example.activitytest.ACTION_START");
startActivity(intent);
1
2
```
注意：
- 这里的是在SecondActivity的标签里面哦，表示的是SecondActivity活动可以响应Intent中指定的action和category中的内容同时能够匹配上和标签里面的内容的Intent。
- SecondActivity的category 可以指定多个，匹配上一个就行，FirstActivity的Intent 可以不指定category ，这时会默认给一个DEFAULT的category ，但是如果想换其他的category 就需要指定。
```
Intent intent=new Intent("com.example.activitytest.ACTION_START");
intent.addCategory("com.example.activitytest.MY_CATEGORY");
startActivity(intent);
1
2
3
```
2.1.3 隐式Intent 的更多用法-跳转网页、拨打电话…

隐式Intent除了用于Activity跳转，还可以用于拨打电话、发送短信、访问网页、调用音乐播放器、调用视频播放器、发送邮件和打开地图等。
拨打电话：
```
//隐式Intent拨打电话
Intent intent=new Intent(Intent.ACTION_DIAL);
intent.setData(Uri.parse("tel:10086"));
startActivity(intent);
1
2
3
4
```
发送短信：
```
//隐式发送短信
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.putExtra("这里填写短信收信人", "这里填写短信内容");
intent.setType("vnd.android-dir/mms-sms");
startActivity(intent);
1
2
3
4
5
```
访问网页：
```
//隐式Intent访问网页
Intent intent=new Intent(Intent.ACTION_VIEW);
intent.setData(Uri.parse("http://www.baidu.com"));
startActivity(intent);
1
2
3
4
```
调用音乐播放器：
```
//调用音乐播放器
Intent intent = new Intent(Intent.ACTION_VIEW);
Uri uri = Uri.parse("file://sdcard/demo.mp3");
intent.setDataAndType(uri, "audio/mp3");
startActivity(intent);
1
2
3
4
5
```
调用视频播放器：
```
//调用视频播放器
Intent intent = new Intent(Intent.ACTION_VIEW);
Uri uri = Uri.parse("file://sdcard/demo.mp4");
intent.setDataAndType(uri, "video/mp4");
startActivity(intent);
1
2
3
4
5
```
发送邮件：
```
//发送邮件
Intent intent = new Intent(Intent.ACTION_SENDTO);
intent.setData(Uri.parse("mailto:xxx@gmail.com"));
intent.putExtra(Intent.EXTRA_SUBJECT, "这是标题");
intent.putExtra(Intent.EXTRA_TEXT, "这是内容");
startActivity(intent);
1
2
3
4
5
6
```
打开地图：
```
//打开地图查看某经纬度的地点（如：天安门）
Intent intent = new Intent(Intent.ACTION_VIEW);
intent.setData(Uri.parse("geo:39.9073,116.3912"));
startActivity(intent);
1
2
3
4
```
2.2 向下一个活动传递数据 intent.putExtra

Intent中提供了一系列putExtra()方法的重载，可以把想要传递的数据暂存在Intent中，启动了另一个活动后，只需要把这些数据再从Intent中取出就可以了。
比如在FirstActivity中：
```
button1.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        String data="Hello SecondActivity";
        Intent intent= new Intent(FirstActivity.this,SecondActivity.class);
        intent.putExtra("extra data",data);
        startActivity(intent);
    }
});
1
2
3
4
5
6
7
8
9
```
使用显式Intent的方式来启动SecondActivity，并通过putExtra()方法传递了一个字符串。注意这里putExtra()方法接收两个参数，第一个参数是键，用于后面从Intent中取值，第二个参数才是真正要传递的数据。
然后在SecondActivity中将传递的数据取出，并打印出来，代码如下所示：
```
public class SecondActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.second_layout);
        Intent intent = getIntent();
        String data = intent.getStringExtra("extra data");
        Log.d("SecondActivity",data);
    }
1
2
3
4
5
6
7
8
9
10
```
注意：
- 如果传递的是整型数据，则使用getIntExtra()方法；如果传递的是布尔型数据，则使用getBooleanExtra()方法，以此类推。
2.3 返回数据给上一个活动ActivityResultLauncher 实例

这一部分的内容需要注意，书上给的例子是使用 startActivityForResult()但是在 Android 11（API 级别 30）及以后的版本中，方法 startActivityForResult(Intent, int) 已经被弃用。尽管它仍然可以使用，但为了确保兼容性和未来的应用程序发展，建议使用新的替代方案。现在，可以使用 ActivityResultLauncher API 来替代 startActivityForResult()。这个新的 API 提供了更灵活和现代的方式来处理活动结果。
1. 声明 ActivityResultLauncher：
  在FirstActivity中，声明一个 ActivityResultLauncher 对象。你需要指定你想使用的合同（例如，
```
ActivityResultContracts.StartActivityForResult()）。
ActivityResultLauncher myLauncher = registerForActivityResult(
    new ActivityResultContracts.StartActivityForResult(),
    result -> {
        if (result.getResultCode() == RESULT_OK) {
            // 处理结果Intent data = result.getData();
            // ...
        }
    }
);
1
2
3
4
5
6
7
8
9
10
```
1. 启动活动：
  现在，不再使用 startActivityForResult()，而是在 ActivityResultLauncher 实例上调用 launch() 方法来启动活动。下面的例子中我通过intent.putExtra传入了参数。
```
@Override
public void onClick(View view) {
    Intent intent = new Intent();
    intent.putExtra("data_return","Hello FirstActivity");
    setResult(RESULT_OK,intent);
    finish();
}
1
2
3
4
5
6
7
```
1. 处理结果：
  现在我要在FirstActivity提取我们传来的参数，只需要修改声明 ActivityResultLauncher时候的代码：
```
private final ActivityResultLauncher myLauncher = registerForActivityResult(
        new ActivityResultContracts.StartActivityForResult(),
        result -> {
            if (result.getResultCode() == RESULT_OK) {
                Intent data = result.getData();//拿取传过来的数据
                if (data != null) {
                    String returnedData = data.getStringExtra("data_return");
                    if (returnedData != null) {
                        // 弹出提示框
                        AlertDialog.Builder builder = new AlertDialog.Builder(this);
                        builder.setMessage(returnedData)
                                .setTitle("Returned Data")
                                .setPositiveButton("OK", null);
                        AlertDialog dialog = builder.create();
                        dialog.show();
                    }
                }
            }
        }
);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
```
通过String returnedData = data.getStringExtra(“data_return”);拿到我们的数据再进行处理。
补充：如果通过按下Back键返回呢
如果用户在SecondActivity中并不是通过点击按钮，而是通过按下Back键回到FirstActivity，我们可以通过在SecondActivity中重写onBackPressed()方法来处理返回的数据。
```
@Override
public void onBackPressed() {
    Intent intent = new Intent();
    intent.putExtra("data_return","Hello FirstActivity");
    setResult(RESULT_OK,intent);
    finish();
}
1
2
3
4
5
6
7
```
在用户点击Back键的时候就会调用这个函数，那么我们的intent.putExtra存进去的数据仍然可以传回去。

3. 活动的生命周期🎯

3.1 返回栈
1. Android中的活动是可以层叠的。每启动一个新的活动，就会覆盖在原活动之上，然后点击Back键会销毁最上面的活动，下面的一个活动就会重新显示出来。
2. Android是使用任务（Task）来管理活动的，一个任务就是一组存放在栈里的活动的集合，这个栈也被称作返回栈（Back Stack）。
3. 系统总是会显示处于栈顶的活动给用户。
  返回栈是如何管理活动入栈出栈操作的示意图：
3.2 活动状态

每个活动在其生命周期中最多可能会有4种状态。
1. 运行状态
  当一个活动位于返回栈的栈顶时，这时活动就处于运行状态。系统最不愿意回收的就是处于运行状态的活动，因为这会带来非常差的用户体验。
2. 暂停状态
  当一个活动不再处于栈顶位置，但仍然可见时，这时活动就进入了暂停状态。处于暂停状态的活动仍然是完全存活着的，系统也不愿意去回收这种活动（因为它还是可见的，回收可见的东西都会在用户体验方面有不好的影响），只有在内存极低的情况下，系统才会去考虑回收这种活动。
3. 停止状态
  当一个活动不再处于栈顶位置，并且完全不可见的时候，就进入了停止状态。系统仍然会为这种活动保存相应的状态和成员变量，但是这并不是完全可靠的，当其他地方需要内存时，处于停止状态的活动有可能会被系统回收。
4. 销毁状态
  当一个活动从返回栈中移除后就变成了销毁状态。系统会最倾向于回收处于这种状态的活动，从而保证手机的内存充足。
3.3 活动的生存期

Activity类中定义了7个回调方法，覆盖了活动生命周期的每一个环节，下面就来一一介绍这7个方法。
1. onCreate()：它会在活动第一次被创建的时候调用。你应该在这个方法中完成活动的初始化操作，比如说加载布局、绑定事件等。
2. onStart()：在活动由不可见变为可见的时候调用。
3. onResume()：在活动准备好和用户进行交互的时候调用。此时的活动一定位于返回栈的栈顶，并且处于运行状态。
4. onPause()：在系统准备去启动或者恢复另一个活动的时候调用。我们通常会在这个方法中将一些消耗CPU的资源释放掉，以及保存一些关键数据，但这个方法的执行速度一定要快，不然会影响到新的栈顶活动的使用。
5. onStop()：在活动完全不可见的时候调用。它和onPause()方法的主要区别在于，如果启动的新活动是一个对话框式的活动，那么onPause()方法会得到执行，而onStop()方法并不会执行。
6. onDestroy()：在活动被销毁之前调用，之后活动的状态将变为销毁状态。
7. onRestart()：在活动由停止状态变为运行状态之前调用，也就是活动被重新启动了。
  以上7个方法中除了onRestart()方法，其他都是两两相对的，从而又可以将活动分为3种生存期。
8. 完整生存期：活动在onCreate()方法和onDestroy()方法之间所经历的，就是完整生存期。一般情况下，一个活动会在onCreate()方法中完成各种初始化操作，而在onDestroy()方法中完成释放内存的操作。
9. 可见生存期：活动在onStart()方法和onStop()方法之间所经历的，就是可见生存期。在可见生存期内，活动对于用户总是可见的，即便有可能无法和用户进行交互。我们可以通过这两个方法，合理地管理那些对用户可见的资源。比如在onStart()方法中对资源进行加载，而在onStop()方法中对资源进行释放，从而保证处于停止状态的活动不会占用过多内存。
10. 前台生存期：活动在onResume()方法和onPause()方法之间所经历的就是前台生存期。在前台生存期内，活动总是处于运行状态的，此时的活动是可以和用户进行交互的，我们平时看到和接触最多的也就是这个状态下的活动。
3.4 活动回收后

想象以下场景：应用中有一个活动A，用户在活动A的基础上启动了活动B，活动A就进入了停止状态，这个时候由于系统内存不足，将活动A回收掉了，然后用户按下Back键返回活动A，会出现什么情况呢？
其实还是会正常显示活动A的，只不过这时并不会执行onRestart()方法，而是会执行活动A的onCreate()方法，因为活动A在这种情况下会被重新创建一次。这样看上去好像一切正常，可是别忽略了一个重要问题，活动A中是可能存在临时数据和状态的。打个比方，MainActivity中有一个文本输入框，现在你输入了一段文字，然后启动NormalActivity，这时MainActivity由于系统内存不足被回收掉，过了一会你又点击了Back键回到MainActivity，你会发现刚刚输入的文字全部都没了，因为MainActivity被重新创建了。因此，我们引入了可以在活动回收后保存数据的方法onSaveInstanceState()回调方法，这个方法可以保证在活动被回收之前一定会被调用，因此我们可以通过这个方法来解决活动被回收时临时数据得不到保存的问题。
1. 重写onSaveInstanceState()方法
```
@Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        String tempData = "Something you just typed";
        outState.putString("data_key",tempData);
    }
1
2
3
4
5
6
```
1. 在onCreate()方法中加入判断
```
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d(TAG,"onCreate");
        setContentView(R.layout.activity_main);
        if (savedInstanceState!=null) {
            String tempData = savedInstanceState.getString("data_key");
            Log.d(TAG,tempData);
        }
1
2
3
4
5
6
7
8
9
```
不过这里注意一点：
onSaveInstanceState()方法，它不是生命周期方法，它不同于生命周期方法，它并不会一定会被触发，它只有具备以下条件的时候才会触发：
1. 当按下HOME键的时
2. 长按HOME键，选择运行程序的时
3. 按下电源(关闭屏幕显示)时
4. 从Activity中启动其他Activity时
5. 屏幕方向切换时(例如从竖屏切换到横屏时)
  如果想实现以上效果请使用屏幕方向切换(例如从竖屏切换到横屏时)
  Intent还可以结合Bundle一起用于传递数据，首先可以把需要传递的数据都保存在Bundle对象中，然后再将Bundle对象存放在Intent里。到了目标活动之后先从Intent中取出Bundle，再从Bundle中一一取出数据。
4. 活动的启动模式🎯

活动的启动模式一共有4种，分别是standard、singleTop、singleTask和singleInstance，可以在AndroidManifest.xml中通过给标签指定android:launchMode属性来选择启动模式。

4.1 四种启动模式
1. Standard（标准模式）：
- 在这种模式下，每次启动活动时都会创建一个新的活动实例。
- 如果您多次启动同一活动，将会创建多个不同的实例，它们位于活动堆栈中的顶部。
- 这是默认的启动模式。
1. SingleTop（单顶模式）：
- 在这种模式下，如果新活动的实例已经位于栈的顶部，系统将重用该实例而不创建新的。
- 如果新活动不在栈的顶部，系统将创建新的实例并将其推入栈的顶部。
- 这允许在同一活动的不同任务之间共享实例，但在任务内仍然可以创建多个实例。
1. SingleTask（单任务模式）：
- 在这种模式下，对于同一个活动系统只允许一个活动实例存在于任务中。
- 如果新活动已经存在于任务中，系统将通过调用 onNewIntent() 方法来重新激活它，而不会创建新实例。
- 这通常用于定义应用的入口点，例如主界面。
1. SingleInstance（单实例模式）：
- 这是最特殊的启动模式，每个活动实例都会独立存在于自己的任务中。
- 即使是相同活动的不同实例也不会共享任务。
- 这通常用于具有独立性的组件，如电话应用中的来电界面。
  每一个活动都可以单独设置启动模式，但是当有不同的启动模式的时候，会创建不同的返回栈，也可以叫做任务栈（Task Stack），此时活动退出时候的顺序和活动启动的顺序可能不一样。
- 当用户从一个活动退出时，优先返回到该活动所属返回栈的栈顶活动。
- 当该活动所属返回栈已经没有活动了时，会返回到还存在活动的返回栈，读取里面的活动
4.2 “任务”（Task）

在 Android 中，“任务”（Task）是一种管理应用活动（Activity）的方式。一个任务通常包含一个或多个活动，并用于组织和管理这些活动的生命周期。
1. 任务栈（Task Stack）：每个任务都有一个与之关联的活动栈，它是活动实例的有序堆栈。当您启动一个新的活动时，它将被推入栈的顶部。用户可以通过返回键按照栈的顺序导航回先前的活动。
2. 任务的启动：任务可以从应用的入口点（通常是主活动）开始，并随着用户与应用的互动而增长。您可以使用不同的启动模式来定义新活动如何与任务中的现有活动实例进行交互。
3. 任务之间的分离：不同任务的活动通常是相互分离的，它们不共享相同的任务栈。这意味着每个任务都有自己独立的活动堆栈。这在某些情况下很有用，例如使用 singleInstance 启动模式的活动。
4. 任务的生命周期：任务具有自己的生命周期，当任务中的最后一个活动关闭时，整个任务将被销毁。这可以在某些情况下用于应用的清理和管理。
5. 活动的最佳实践技巧🎯

5.1 知晓当前是在哪一个活动
1. 新建一个BaseActivity类，创建时选择一个普通的Java类，不需要在AndroidManifest.xml中注册。
2. 让BaseActivity继承自AppCompatActivity，并重写onCreate()方法
```
public class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("BaseActivity",getClass().getSimpleName());
    }
1
2
3
4
5
6
```
1. 让BaseActivity成为ActivityTest项目中所有活动的父类
  现在每当我们进入到一个活动的界面，该活动的类名就会被打印出来，这样我们就可以时时刻刻知晓当前界面对应的是哪一个活动了。
5.2 随时随地退出程序

用一个专门的集合类对所有的活动进行管理就可以随时随地都能退出程序，而不需要一个一个注销和退出。
1. 新建一个ActivityCollector类作为活动管理器
```
public class ActivityCollector {
    public static List activities = new ArrayList<>();
    public static void addActivity(Activity activity){
        activities.add(activity);
    }
    public static void removeActivity(Activity activity){
        activities.remove(activity);
    }
    public static void finishAll(){
        for (Activity activity : activities) {
            if (!activity.isFinishing()){
                activity.finish();
            }
            activities.clear();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
```
在活动管理器中，我们通过一个List来暂存活动，然后提供了一个addActivity()方法用于向List中添加一个活动，提供了一个removeActivity()方法用于从List中移除活动，最后提供了一个finishAll()方法用于将List中存储的活动全部销毁掉。
2. 修改BaseActivity中的代码
```
public class BaseActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        Log.d("BaseActivity",getClass().getSimpleName());
        ActivityCollector.addActivity(this);
    }
    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityCollector.removeActivity(this);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
```
在BaseActivity的onCreate()方法中调用了ActivityCollector的addActivity()方法，表明将当前正在创建的活动添加到活动管理器里。然后在BaseActivity中重写onDestroy()方法，并调用了ActivityCollector的removeActivity()方法，表明将一个马上要销毁的活动从活动管理器里移除。
从此以后，不管你想在什么地方退出程序，只需要调用ActivityCollector.finishAll()方法就可以了。例如在ThirdActivity界面想通过点击按钮直接退出程序：
```
 Button button3 = (Button) findViewById(R.id.button_3);
        button3.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                ActivityCollector.finishAll();
            }
        });
1
2
3
4
5
6
7
```
当然你还可以在销毁所有活动的代码后面再加上杀掉当前进程的代码，以保证程序完全退出，杀掉进程的代码如下所示：
```
android.os.Process.killProcess(android.os.Process.myPid())
1
```
其中，killProcess()方法用于杀掉一个进程，它接收一个进程id参数，我们可以通过myPid()方法来获得当前程序的进程id。需要注意的是，killProcess()方法只能用于杀掉当前程序的进程，我们不能使用这个方法去杀掉其他程序。

5.3 启动活动的最佳写法

当我们启动一个活动需要两个特别重要的参数时，可以使用以下办法
假设SecondActivity中需要用到两个非常重要的字符串参数，在启动SecondActivity的时候必须要传递过来，
```
public class SecondActivity extends BaseActivity {
    public static void actionStart(Context context, String data1, String data2){
        Intent intent = new Intent (context,SecondActivity.class);
        intent.putExtra("param1",data1);
        intent.putExtra("param2",data2);
        context.startActivity(intent);
    }
    ......
}
1
2
3
4
5
6
7
8
9
```
在SecondActivity中添加了一个actionStart()方法，在这个方法中完成了Intent的构建，另外所有SecondActivity中需要的数据都是通过actionStart()方法的参数传递过来的，然后把它们存储到Intent中，最后调用startActivity()方法启动SecondActivity。
这样写的好处就是SecondActivity所需要的数据在方法参数中全部体现出来了，这样即使不用阅读SecondActivity中的代码，不去询问负责编写SecondActivity的同事，你也可以非常清晰地知道启动SecondActivity需要传递哪些数据。另外，这样写还简化了启动活动的代码，现在只需要一行代码就可以启动SecondActivity，如下所示：
在FirstActivity中：
```
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    Log.d("FirstActivity","Task id is "+getTaskId());
    setContentView(R.layout.first_layout);
    Button button1=(Button) findViewById(R.id.button_1);
    button1.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {
            //Intent intent = new Intent(FirstActivity.this,SecondActivity.class);
            //startActivity(intent);
            SecondActivity.actionStart(FirstActivity.this,"data1","data2");
        }
    });
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
```
相关阅读:
【Leetcode】 707. 设计链表
 【BOOST C++ 14 消息编程】（2）异步数据交换
 【反射】Field类
 5.5 真-白给题
 mindspore.dataset.NumpySlicesDataset使用报错
 QTableView右键显示菜单
 Huffman哈夫曼树思想即代码
 为什么 Java 中 byte 类型变量，值的范围是[-128 , 127]？
超详细的springBoot学习笔记
 软考高级系统架构设计师系列论文真题三：论软件设计模式及其应用
原文地址：https://blog.csdn.net/xuanyulevel6/article/details/133643568

学习重点

参考笔记

开始第一个Android项目

第一章 活动

1. 活动的基本用法🎯

1.1 创建活动

1.2 活动注册

1.3 提醒小弹窗Toast

1.4 顶部小菜单Menu

1.5 销毁一个活动 finish()

2. 活动之间的跳转🎯

2.1 活动间的跳转Intent

2.1.1 显式使用

2.1.2 隐式使用

2.1.3 隐式Intent 的更多用法-跳转网页、拨打电话…

2.2 向下一个活动传递数据 intent.putExtra

2.3 返回数据给上一个活动ActivityResultLauncher 实例

3. 活动的生命周期🎯

3.1 返回栈

3.2 活动状态

3.3 活动的生存期

3.4 活动回收后

4. 活动的启动模式🎯

4.1 四种启动模式

4.2 “任务”（Task）

5. 活动的最佳实践技巧🎯

5.1 知晓当前是在哪一个活动

5.2 随时随地退出程序

5.3 启动活动的最佳写法

第一章活动