读前须知

本系列旨在快速开发Android端运用，以笔记（便签）为例。体系：Windows10 东西：Android Studio，版别：2022.3.19 言语：Java （版别：17）

此系列适合的人群： 想开发一款项目（Android）但无从下手的人
1. 你必须保证有满意以下根底：
  1. 成功装备好了Java环境
  2. 成功安装了Android Studio
  3. 运用Android Studio新建了第一个文件并成功类似输出Hello World！
  4. 了解过编程（最好能够娴熟运用一门言语解决问题）
2. 你能够不具备以下条件：
  1. 娴熟运用Java
  2. 实践过项目开发

留意：

本文保证细致入微，但为了行文结构和阅览体会抛弃了一些内容，所以假如你在阅览本文章时有任何疑问请留言，我将回答你！
本人尚且大二，学业压力较大。但将保证学习并实践的过程错时最多30天同步更新此系列。
阅览并娴熟掌握本文内容，你将最少花费2小时！

学习本文章后你会取得什么？

了解Android Studio项目结构
了解Java部分语法和XML文件的撰写
完成界面跳转
编写文档

演示如下：

轻松上手：＜Android Studio笔记应用开发＞（一）入门与笔记应用浅开发

点击上图中的悬浮按钮后，将跳转页面，见下图；

如上图所示，你能够在此界面编写。

芜湖！写好喽！

接下来，点击手机（AVD）的后退按键，你将在logcat界面见到你输入的信息（见下图）。记得筛选词哦~~

如你所见，本文章完成的仅是记事本的雏形，你能够根据自己实践需求挑选持续阅览本文或停止阅览本文。

一、翻开Android Studio并新建项目

二、Android Studio项目结构详解

（一）Android 视图与磁盘上的结构之间的结构差异

默认情况下，Android Studio 会在 Android 视图中显现您的项目文件。此视图并未反映磁盘上的实践文件层次结构。相反，它按模块和文件类型进行整理，以简化项目的关键源文件之间的导航办法，并躲藏某些不常用的文件或目录。

Android 视图与磁盘上的结构之间的一些结构差异在于 Android 视图：

在顶级 Gradle Script 组中显现项目的一切与构建相关的装备文件。在模块级组中显现每个模块的一切清单文件（当您针对不同的产品变种和 build 类型运用不同的清单文件时）。在一个组（而非在每个资源限定符的单独文件夹）中显现一切备用资源文件。例如，发动器图标的一切密度版别都能够并排显现。在每个 Android 运用模块中，文件显现在以下组中：

manifests 包括 AndroidManifest.xml 文件。 java 包括 Kotlin 和 Java 源代码文件（以软件包称号分隔各文件，包括 JUnit 测验代码）。 res 包括一切非代码资源（例如 XML 布局、界面字符串和位图图画），这些资源划分到相应的子目录中。如需详细了解或许的资源类型，请参阅运用资源概览。

（二）对Android 视图下的结构作如下解说

Android Studio项目结构包括许多目录和文件，每个都有不同的用途和功用。下面是一个更详细的介绍，包括每个目录和文件：

.app 目录：
- manifests 目录：
  - AndroidManifest.xml：包括了您的运用程序的装备信息，如运用程序的称号、包名、权限请求、组件声明（Activity、Service、BroadcastReceiver等）以及运用程序的图标等。这是Android运用程序的入口点。
- java 目录：
  - com.example.my_notes_record 目录（实践包名会根据您的项目而有所不同）：这是您的运用程序的Java代码的主目录。
    - MainActivity.java：默认的主活动，运用程序的入口点。
    - 其他.java 文件：您的运用程序的其他活动、服务或东西类等或许会包括在这儿。
- 其他com.example.my_notes_record 目录：没啥用，就测验用的，平时没事也用不着。

res 目录：
- drawable 目录：包括各种图画资源文件（如PNG、JPEG等）。
- layout 目录：包括布局文件，界说了运用程序的UI界面的布局结构。
- values 目录：
  - strings.xml：包括字符串资源，用于存储运用程序中运用的文本。
  - colors.xml：包括色彩资源，用于界说运用程序中运用的色彩。另可有包括但不限于下面这两个文件：
  - dimens.xml：包括尺度资源，用于界说运用程序中运用的尺度。
  - styles.xml：包括运用程序的样式和主题界说。

Gradle Scripts 目录：
- build.gradle (Module: app)：运用程序模块的Gradle构建装备。您能够在此文件中指定依靠项、插件、构建类型等。
- build.gradle (Project: MyNotes)：整个项目的Gradle装备，用于装备项目等级的属性和依靠项。
- gradle-wrapper.properties：Gradle包装器装备文件，用于指定项目运用的Gradle版别。
- settings.gradle：项目的设置文件，用于界说模块和包括的子项目。

（三）你所需求重视的重点

1. app/manifests/AndroidManifests.xml 文件：

AndroidManifest.xml 文件是 Android 运用程序的核心装备文件。

这个文件能干啥？
- 用于声明和注册运用程序的组件，如 Activity、Service 和 Broadcast Receiver。
- 用于请求拜访设备功用和资源的权限。
- 指定运用程序的发动 Activity。
- 允许界说 Intent 过滤器，使运用程序能够与其他运用程序交互。

2. 什么时候要修正这个文件？

增加新的组件（Activity、Service、Broadcast Receiver）时需求声明它们。
请求权限时需求声明所需权限。
需求指定运用程序的发动界面时。
当运用程序装备或包名产生更改时需求更新。
界说其他自界说装备时需求修正。

2. app/java/com.example.my_notes_record 目录：

com.example.my_notes_record这个是包名

这个目录下将寄存你要运用或新建的Java文件

3. app/res/drawable 目录：

该目录下的很多xml文件实质上便是图片。

下面展现新建vector assert

4. app/res/layout 目录：

此目录下的很多xml文件用于布局。每一个xml文件都与一个app/java/com.example.my_notes_record 目录下的Java文件对应。

例如：

//app/java/com.example.my_notes_record/MainActivity.java
package com.example.my_notes_record;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

<!-- app/res/layout/activity_main.xml  -->
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!"
        app:layout_constraintBottom_toBottomOf="parent"
        app:layout_constraintEnd_toEndOf="parent"
        app:layout_constraintStart_toStartOf="parent"
        app:layout_constraintTop_toTopOf="parent"
        app:layout_constraintVertical_bias="0.412" />
</androidx.constraintlayout.widget.ConstraintLayout>

解说如下：

MainActivity.java（Java 代码文件）：这个文件就像是一位魔术师，他担任操控和办理整个扮演。他知道要在哪里放置道具，何时进行魔术动作，以及如何与观众互动。
activity_main.xml（XML 布局文件）：这个文件就像是魔术师的道具箱，里边有各种道具和说明书。在道具箱中，有一块特别的纸张，上面写着：“在舞台上放置一个名为 ‘Hello World!’ 的文本，并将它放在舞台的中央底部。”

现在，让咱们看看它们如何联络起来：

魔术师（MainActivity.java）在扮演开端时翻开了他的道具箱（activity_main.xml）。
他仔细研究了道具箱中的说明书，然后按照上面的指示在舞台上放置了一个名为 ‘Hello World!’ 的文本。
魔术师告知观众：“现在，我将展现一个奇特的魔术！”然后他开端扮演，文本 ‘Hello World!’ 在舞台上以特定的办法出现了。

更直白的说：

在 MainActivity.java 文件的 onCreate 办法中，经过以下代码行：
```
setContentView(R.layout.activity_main);
```
告知 Android 在此活动中运用名为 activity_main.xml 的布局文件作为用户界面的布局。
在 activity_main.xml 文件中，界说了一个 TextView，其间包括 “Hello World!” 文本。这个 TextView 的属性和布局束缚决定了它在屏幕上的位置和外观。
因此，这两个文件的联络在于，MainActivity.java 运用 activity_main.xml 作为其界面的布局。当 MainActivity 运转时，它会加载并显现 activity_main.xml 中界说的用户界面，用户将看到带有 “Hello World!” 文本的界面。

啰里噜苏，简略说便是Java 代码操控着界面的行为和逻辑，而 XML 布局文件界说了界面的外观和布局。通俗意义上说便是前后端别离，二者经过 setContentView(R.layout.activity_main);链接在一起。

接下来对 setContentView(R.layout.activity_main);解说如下：

setContentView 是一个 Android Activity 类的办法，它用于设置当时 Activity 所显现的用户界面（UI）的布局。
R.layout.activity_main 是一个引证，它指向了一个在 res/layout 目录下的 XML 布局文件，即运用程序主界面的布局文件。
- R 代表 “资源”（Resource）的缩写。它是一个由 Android 自动创立的类，包括了运用程序中运用的各种资源的引证，如布局、图画、字符串、色彩等。
- R.layout 是 R 类中的一个内部类，用于引证布局文件。在 R.layout 中，每个布局文件都会分配一个唯一的整数标识符（ID），以便在代码中引证。
当调用 setContentView(R.layout.activity_main); 时，Android 体系会加载并显现 activity_main.xml 布局文件中界说的用户界面。
换句话说，这行代码告知 Android 体系将 activity_main.xml 文件中界说的布局设置为当时 Activity 的界面，运用户能够看到该界面。

5. app/res/values 目录：

当涉及到 app/res/values 目录和 Gradle Scripts/build.gradle (Module: app) 文件时，这两者的简略解说如下：

app/res/values 目录：
- 这是 Android 运用程序中的一个目录，用于存储各种资源的值，如字符串、色彩、尺度等。它是用来会集办理运用程序的可装备数据的地方。
- 在这个目录中，您会找到 strings.xml、colors.xml、dimens.xml 等文件，它们分别用于存储运用程序中运用的字符串、色彩和尺度信息。
- 运用这个目录有助于运用程序的国际化和主题化，由于您能够在不同的文件夹中存储不同言语的字符串，或许在不同的文件中界说不同的色彩和尺度，然后使运用程序更具灵活性和可维护性。
- 留意：在 app/res/values 目录中，您能够创立自界说的 XML 文件，但这些文件必须符合一定的规矩和命名约好。一般来说，values 目录用于存储字符串、色彩、尺度等资源的值，这些资源一般以 XML 文件的办法进行存储。

以下是一些常见的 values 目录中的 XML 文件命名约好：

strings.xml：用于存储运用程序中的字符串资源，如界面标签、按钮文本等。这个文件是必需的，一般包括默认言语的字符串资源。
colors.xml：用于存储色彩值的资源。您能够在这个文件中界说运用程序运用的色彩，以便在布局文件和代码中引证。
dimens.xml：用于存储尺度值的资源。这个文件能够用来界说布局元素的尺度，以便在不同设备上保持一致的外观。
arrays.xml：用于存储数组资源。您能够在这个文件中界说字符串数组、整数数组等。
styles.xml：用于界说运用程序的样式和主题。这个文件包括运用程序的外观和行为的装备信息。
其他自界说文件：您能够根据需求创立其他自界说的 XML 文件，但一般应该保持与资源类型相关的文件名，并在文件中界说相应类型的资源值。
Gradle Scripts/build.gradle (Module: app) 文件：
- 这是运用程序的 Gradle 构建文件，用于装备和办理运用程序的构建过程。Gradle 是一种构建自动化东西，用于编译、构建和打包 Android 运用程序。
- 在 build.gradle (Module: app) 文件中，您能够指定运用程序的依靠项、编译版别、签名装备、构建类型（如调试或发布）等构建相关的设置。
- 经过修正这个文件，您能够增加第三方库、插件，或许装备运用程序的各种构建选项，以满意特定的需求，例如增加新的功用或优化性能。
- 留意：你最好不要修正这个文件，假如不对错改不行的话。

（四）xml文件到底是个什么东西？

XML 文件就像运用程序的”翻译书”，是一种符号言语，用于存储和传输数据。它类似于运用程序中的数据存储办法。就像书中的章节和段落将信息安排成结构化的办法，XML 文件用标签（tags）将数据以结构化的办法表明出来。

比如，想象一本书，每章都有标题，每段都有内容。在 XML 文件中，您能够创立一个类似的结构，例如：

<book>
    <chapter>
        <title>Chapter 1</title>
        <content>This is the content of Chapter 1.</content>
    </chapter>
    <chapter>
        <title>Chapter 2</title>
        <content>This is the content of Chapter 2.</content>
    </chapter>
</book>

在这个例子中，<book> 是顶级标签，表明整本书。<chapter> 标签表明章节，包括了<title> 和 <content> 子标签，分别表明章节标题和内容。这种结构使得数据易于安排和了解。

简言之，XML 文件是一种用于存储和传输数据的符号言语，类似于书中的章节和段落，用于安排和表明结构化数据。

（五）gradle是什么？

Gradle 就像运用程序的”修建师”，是一种构建自动化东西，用于编译、构建和打包运用程序。它的作业办法类似于修建师方案和协调修建项目。Gradle 协助您办理和构建运用程序的不同部分，保证它们在一起协作以创立一个完整的运用程序。

比如，想象您正在制作一座房子，房子由不同的部分组成，如墙、房顶、地板等。Gradle 就像一位修建师，它能够：

方案项目：确认哪些部分需求制作，以及如何组装它们。
协调作业：与不同的工人（编译器、库、插件）协作，保证每个部分都按方案进行。
解决问题：假如有问题或错误，Gradle 协助找到并修正它们，就像修建师解决施工问题相同。
终究构建：将一切部分组合成一个完整的房子，即运用程序。

简言之，Gradle 是一种构建自动化东西，类似于运用程序的修建师，用于方案、协谐和构建运用程序的各个部分，以创立一个完整的运用程序。

三、完成页面跳转

（一）完成浮动按钮（FAB）

1. 为何要完成FAB？

它一般是一个圆形按钮，悬浮在界面的底部右侧。这是我想要的效果。

FAB 是一种常见的 UI 元素，一般用于触发运用程序中的重要操作，例如创立新内容、翻开菜单或履行查找等。

2. 过程

2.1. 修正布局根元素

修正activity_main.xml中的<androidx.constraintlayout.widget.ConstraintLayout为<RelataveLayout 如下图所示：

2.2. 新建FAB

挺简略的。

这儿随意选个就行，无所谓。

OK了。

留意：activity_main.xml中随之出现新的代码段。右上角提示反常，不必管。

运转界面如下,你能够点这个小方框，但没啥用。

2.3. 增加加号

（二）验证点击

如前文所见，咱们现在已完成了FAB,但点击后毫无反响，接下来咱们要完成：点击FAB产生反响。

1. 简略改下代码


package com.example.my_notes_record;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

改成这样

package com.example.my_notes_record;
import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
public class MainActivity extends AppCompatActivity {
    final String TAG ="FXS";
    FloatingActionButton btn;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn=(FloatingActionButton) findViewById(R.id.floatingActionButton4);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Log.d(TAG,"OnClick:Click");
            }
        });
    }
}

对修正部分作简略解说如下：

final String TAG = "FXS";

这行代码界说了一个常量字符串 TAG，用于在日志中符号这个活动的信息。TAG 一般用于协助您在日志中过滤和辨认特定活动或类的信息。

FloatingActionButton btn;

这行代码声明晰一个名为 btn 的变量，类型是 FloatingActionButton。这个变量将用于引证布局文件中的悬浮操作按钮（FloatingActionButton）。

btn = (FloatingActionButton) findViewById(R.id.floatingActionButton4);

这行代码将初始化 btn 变量，经过 findViewById 办法查找布局文件中的悬浮操作按钮，保证 floatingActionButton4与activity_main.xml中的Id对应。这样，您能够在代码中操作和操控这个按钮。

能够将ID修正为其他，如fab： android:id="@+id/fab" MainActivity.java 中也要随之改变： btn = (FloatingActionButton) findViewById(R.id.fab);

btn.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Log.d(TAG, "OnClick: Click");
    }
});

这部分代码设置了一个点击事情监听器，它会在用户点击按钮时履行。当按钮被点击时，onClick 办法内的代码将履行。详细解说如下：
- btn.setOnClickListener(...)：这是设置按钮的点击事情监听器的办法。它承受一个 View.OnClickListener 目标作为参数，用于指定按钮被点击时要履行的操作。
- new View.OnClickListener()：这是一个匿名内部类的创立，它完成了 View.OnClickListener 接口。在这个内部类中，您能够界说按钮点击时要履行的操作。
- public void onClick(View view)：这是 View.OnClickListener 接口的 onClick 办法的完成。当按钮被点击时，这个办法会被调用。
- Log.d(TAG, "OnClick: Click")：这行代码运用 Log.d 办法将一条调试日志记录到 Android 日志中。它会输出 “OnClick: Click” 文本，并运用之前界说的 TAG 来符号日志。这有助于您在开发过程中追寻按钮点击事情。

2. 演示如下

(三)新建Java文件和xml文件

1. 为什么要新建Java文件和xml文件？

在 Android 运用程序开发中，一般每个 Java 文件和 XML 布局文件都对应一个手机软件的界面或一个特定的功用模块。
如上文所示，当下已完成了FAB并保证点击有效。
接下来，需求完成页面跳转到记笔记的界面。

新建文件的过程如下： <New 1>7>

接下来需求将EditActivity.java和edit_layout.xml联络起来，操作过程如下：

代码自取：

//EditActivity.java
package com.example.my_notes_record;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
public class EditActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.edit_layout);
    }
}

最后，你需求修正AndroidManifest.xml文件，或许说每次你新建了个布局，都需求在你的项目“说明书”（AndroidManifest.xml）里增加上去，操作类似如下：

代码自取：

<activity android:name=".EditActivity">
</activity>

(四)完成简略跳转，运用Intent

这部分挺简略的，你只需求将MainActivity.java中的Log.d(TAG,"OnClick:Click");(如下图所示)

换成

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

就Ok了。

你运转试下，点击FAB，现在理应跳转到一个空白界面。

我这边解说一下替换的代码（不想看，越过就好）

Intent intent = new Intent(MainActivity.this, EditActivity.class);：首要，创立了一个名为 intent 的 Intent 目标。Intent 是 Android 中用于履行各种操作的目标，它一般用于发动活动、发送广播、履行服务等。
- MainActivity.this：这儿的 MainActivity.this 表明当时活动，即您正在编写的 MainActivity。它是一个上下文（Context）目标，用于指定从哪个活动发动 Intent。
- EditActivity.class：这儿指定了要发动的目标活动，即 EditActivity。经过传递 EditActivity.class，您告知 Android 体系要发动 EditActivity 这个活动。
startActivity(intent);：接下来，运用 startActivity 办法来发动指定的活动，也便是 EditActivity。当用户点击悬浮操作按钮时，这行代码将触发从 MainActivity 跳转到 EditActivity 的操作。

四、完成文本编写功用

你只需再edit_layout.xml文件中增加如下代码：

<EditText
   android:id="@+id/et"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   android:gravity="top">
</EditText>

如下图所示：

是不是很简答呐？快来快来运转试试吧！你将能够再跳转的界面里编写文档了！

五、输出文本

这儿咱们需求解决这样一个问题：如何在 Android 中处理活动成果？

(一)修正MainActivity.java文件

本来长这样：

package com.example.my_notes_record;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
public class MainActivity extends AppCompatActivity {
    final String TAG ="FXS";
    FloatingActionButton btn;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn=(FloatingActionButton) findViewById(R.id.fab);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, EditActivity.class);
                startActivity(intent);
            }
        });
    }
}

变成下面这样就OK了：

package com.example.my_notes_record;
import androidx.activity.result.ActivityResultLauncher;
import androidx.activity.result.contract.ActivityResultContracts;
import androidx.appcompat.app.AppCompatActivity;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.google.android.material.floatingactionbutton.FloatingActionButton;
public class MainActivity extends AppCompatActivity {
    final String TAG = "FXS";
    FloatingActionButton btn;
    // Define an ActivityResultLauncher
    private ActivityResultLauncher<Intent> someActivityResultLauncher;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn = findViewById(R.id.fab);
        // Initialize the ActivityResultLauncher
        someActivityResultLauncher = registerForActivityResult(
                new ActivityResultContracts.StartActivityForResult(),
                result -> {
                    if (result.getResultCode() == RESULT_OK) {
                        Intent data = result.getData();
                        if (data != null) {
                            String edit = data.getStringExtra("input");
                            Log.d(TAG, edit);
                        }
                    }
                }
        );
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Intent intent = new Intent(MainActivity.this, EditActivity.class);
                someActivityResultLauncher.launch(intent);
            }
        });
    }
}

好吧！改动非常大！别问我为啥便是个承受成果的逻辑，咋整这么杂乱。我也想知道(┬┬﹏┬┬) 所以假如你看到现在还有耐心的话，请听我渐渐讲来：

// Define an ActivityResultLauncher
private ActivityResultLauncher<Intent> someActivityResultLauncher;

在这儿，咱们首要界说了一个 ActivityResultLauncher 目标，名为 someActivityResultLauncher。ActivityResultLauncher 是一个用于发动活动并获取成果的新办法。在这儿，咱们声明晰它，并指定它将承受一个 Intent 目标作为输入。

// Initialize the ActivityResultLauncher
someActivityResultLauncher = registerForActivityResult(
        new ActivityResultContracts.StartActivityForResult(),
        result -> {
            if (result.getResultCode() == RESULT_OK) {
                Intent data = result.getData();
                if (data != null) {
                    String edit = data.getStringExtra("input");
                    Log.d(TAG, edit);
                }
            }
        }
);

在 onCreate 办法中，咱们初始化了 someActivityResultLauncher。这是一个两步过程：
- 首要，咱们调用 registerForActivityResult 办法来初始化 someActivityResultLauncher。这个办法承受两个参数：第一个参数是 ActivityResultContracts.StartActivityForResult()，它告知体系咱们要发动一个活动并获取成果。第二个参数是一个回调函数，当活动回来成果时，将履行这个回调。
- 在回调函数中，咱们查看 result.getResultCode()，以保证活动回来的成果是 RESULT_OK，这一般表明操作成功。然后，咱们查看 result.getData() 是否为 null，以保证有数据回来。假如有数据回来，咱们从回来的 Intent 中获取额外的数据，例如用户输入的文本，并记录到日志中。

btn.setOnClickListener(new View.OnClickListener() {
    @Override
    public void onClick(View view) {
        Intent intent = new Intent(MainActivity.this, EditActivity.class);
        someActivityResultLauncher.launch(intent);
    }
});

最后，在按钮的点击事情监听器中，当用户点击按钮时，咱们运用 someActivityResultLauncher.launch(intent) 来发动 EditActivity。这个办法会发动活动并在活动完成后触发回调函数，然后处理活动回来的成果。

(二)修正EditActivity.java文件

原来长这样：

package com.example.my_notes_record;
import android.os.Bundle;
import androidx.appcompat.app.AppCompatActivity;
public class EditActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.edit_layout);
    }
}

变成这样：

package com.example.my_notes_record;
import android.content.Intent;
import android.os.Bundle;
import android.view.KeyEvent;
import android.widget.EditText;
import androidx.appcompat.app.AppCompatActivity;
import java.security.Key;
public class EditActivity extends AppCompatActivity{
    EditText et;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.edit_layout);
        et=findViewById(R.id.et);
    }
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if(keyCode == KeyEvent.KEYCODE_HOME){
            return true;
        }else if(keyCode == KeyEvent.KEYCODE_BACK){
            Intent intent = new Intent();
            intent.putExtra("input",et.getText().toString());
            setResult(RESULT_OK,intent);
            finish();
            return true;
        }
        return super.onKeyDown(keyCode,event);
    }
}

作简略解说如下：这次的修正是在 EditActivity 增加了一些新的功用：

EditText 控件的引证：首要，在 onCreate 办法中，您经过 et=findViewById(R.id.et); 获取了一个 EditText 控件的引证，其间 R.id.et 是布局文件 edit_layout.xml 中的一个 EditText 控件的标识符。
按键事情监听：您还重写了 onKeyDown 办法来处理按键事情。在这个办法中，您查看用户按下的按键码（keyCode）是否是 KeyEvent.KEYCODE_HOME 或 KeyEvent.KEYCODE_BACK。
- 假如用户按下了 HOME 键（KeyEvent.KEYCODE_HOME），则回来 true，表明您处理了此按键事情。这样能够阻止用户按下 HOME 键时退出运用程序。
- 假如用户按下了回来键（KeyEvent.KEYCODE_BACK），则履行以下操作：
  - 创立一个新的 Intent 目标。
  - 将用户在 EditText 中输入的文本（et.getText().toString()）放入 Intent 中，以便回来到 MainActivity。
  - 运用 setResult 办法设置成果为 RESULT_OK，表明操作成功。
  - 调用 finish() 办法封闭当时的 EditActivity，回来到 MainActivity。

这个修正的目的是在用户修正文本后，按下回来键时将修正的文本数据传递回到 MainActivity，以便在 MainActivity 中处理和显现这些数据。

大功告成！！！

接下来你能够运转试下，就像开篇时演示时那样！

结语

好的，本文结束。希望你在本文中找到了有关Android运用开发的有用信息，不要害怕测验新的东西，愿你编码愉快，创造出出色的运用，做一名优秀的开发者！假如你有任何问题，无妨向国际求助，由于谷歌是你最好的朋友，至少在编码的国际里是这样的。祝编码愉快，愿你的代码永久不溃散！

轻松上手：＜Android Studio笔记应用开发＞（一）入门与笔记应用浅开发