Skip to content

S
studytonight-zh

OpenDocCN / studytonight-zh
9 个月 前同步成功

通知 1
Star 4
Fork 0
S
studytonight-zh

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

提交 b26ae976 编写于 作者: W wizardforcel
浏览文件
操作

2022-01-28 22:32:23

上级 ee51a05a
隐藏空白更改
内联 并排
Showing with 304 addition and 304 deletion
docs/mobi/006.md
浏览文件 @ b26ae976
......@@ -19,7 +19,7 @@
3. **可选包:**SDK示例，安卓SDK来源&应用编程接口级别的文档是可选的。SDK管理器还允许您为任何特定的SDK平台下载一些示例，并为应用编程接口级别下载源代码。如果有文档，您可以下载包含该 API 级别的特定类和方法信息的文档。如果你需要它们，你可以选择下载，否则就不要。
4. 在 SDK 管理器中向下滚动，您将看到 **Extras** 部分，其中包含应用开发所需/有帮助的附加包/库/服务。你可以下载，如果你认为你需要的话。从现在开始，我们建议你忽略它们。
我们希望您已经选择了需要安装的工具和软件包，点击**确定**或**安装**。这将打开另一个窗口，如下图所示，选择**接受许可**单选按钮，然后点击 SDK 管理器窗口右下角的**安装软件包**按钮，这将开始下载您选择的软件包。安装需要时间，请耐心等待。当所有软件包安装到您的系统中时，系统会要求您重新启动 **ADB** ，单击**是**即可。
我们希望您已经选择了需要安装的工具和软件包，点击**确定**或**安装**。这将打开另一个窗口，如下图所示，选择**接受许可**`RadioButton`，然后点击 SDK 管理器窗口右下角的**安装软件包**按钮，这将开始下载您选择的软件包。安装需要时间，请耐心等待。当所有软件包安装到您的系统中时，系统会要求您重新启动 **ADB** ，单击**是**即可。
![Accept License for Packages in SDK manager](img/5c3492a21c3a86025a76fec9eef44057.png)
......
docs/mobi/010.md
浏览文件 @ b26ae976
......@@ -65,7 +65,7 @@ AndroidStudio中不同的窗格被称为**工具窗口**。
默认的活动布局定义了两个小部件:一个`RelativeLayout`和一个`TextView`。
当我们说小部件时，**小部件**是您用来组成用户界面的构建块。小部件可以显示文本或图形，与用户交互，或者在屏幕上排列其他小部件。按钮、文本输入控件和复选框都是小部件的类型。在接下来的课程中，我们将学习[视图](introduction-to-views)和小部件。
当我们说小部件时，**小部件**是您用来组成用户界面的构建块。小部件可以显示文本或图形，与用户交互，或者在屏幕上排列其他小部件。按钮、文本输入控件和`CheckBox`都是小部件的类型。在接下来的课程中，我们将学习[视图](introduction-to-views)和小部件。
```
<?xml version="1.0" encoding="utf-8"?>
......
docs/mobi/023.md
浏览文件 @ b26ae976
......@@ -66,8 +66,8 @@ XML 中的每个视图都有以下格式:
* [按钮](android-button-view)
* [影像检视](android-imageview)
* [`ImageButton`](android-imageview)
* [复选框](radiogroup-radiobutton-checkbox)
* [单选按钮](radiogroup-radiobutton-checkbox)
* [`CheckBox`](radiogroup-radiobutton-checkbox)
* [`RadioButton`](radiogroup-radiobutton-checkbox)
* [列表浏览](android-listview)
* [GridView](android-gridview)
* 日期选择器
......
docs/mobi/026.md
浏览文件 @ b26ae976
......@@ -2,9 +2,9 @@
> 原文：<https://www.studytonight.com/android/android-radiobutton-and-checkbox>
当你在安卓应用中创建一个接受用户输入的表单，并且你必须列出几个选项供用户选择时，复选框和单选框就派上了用场。
当你在安卓应用中创建一个接受用户输入的表单，并且你必须列出几个选项供用户选择时，`CheckBox`和单选框就派上了用场。
因此，单选框和复选框之间的功能区别在于，当用户在多个选项中只能选择一个选项时，我们使用单选框，如果允许多选，则应使用复选框。
因此，单选框和`CheckBox`之间的功能区别在于，当用户在多个选项中只能选择一个选项时，我们使用单选框，如果允许多选，则应使用`CheckBox`。
* * *
......@@ -25,7 +25,7 @@
* `android:checked="true"`
该属性检查，即默认情况下在复选框中放置勾号。
该属性检查，即默认情况下在`CheckBox`中放置勾号。
这涵盖了我们如何在应用屏幕上显示 CheckBox 视图。它是如何工作的，我们很快就会知道。
......@@ -39,7 +39,7 @@
## 安卓系统中的`RadioButton`视图
当您必须允许在多个选项列表中只选择一个选项时，使用`RadioButton`。它在其父视图–`RadioGroup`下使用，因此我们可以从所有列出的单选按钮中选择一个值。
当您必须允许在多个选项列表中只选择一个选项时，使用`RadioButton`。它在其父视图–`RadioGroup`下使用，因此我们可以从所有列出的`RadioButton`中选择一个值。
```
<RadioGroup
......@@ -68,7 +68,7 @@
我们也可以使用[微调视图](spinner-in-android)来显示选项列表，其中只能选择一个。但是在 Spinner 中，并不是所有的选项都同时显示给用户，它更像是一个下拉菜单。
还有`RadioGroup`是`LinearLayout`的子类，垂直排列单选按钮，因为默认是垂直方向。但是您可以通过在布局 XML 文件中将属性`android:orientation="horizontal"`添加到您的`RadioGroup`中来更改它。
还有`RadioGroup`是`LinearLayout`的子类，垂直排列`RadioButton`，因为默认是垂直方向。但是您可以通过在布局 XML 文件中将属性`android:orientation="horizontal"`添加到您的`RadioGroup`中来更改它。
* * *
......@@ -78,9 +78,9 @@
* * *
## 检查单选按钮或`Checkbox`视图的当前状态
## 检查`RadioButton`或`Checkbox`视图的当前状态
为了检查单选按钮或复选框是否被选中，我们可以在 Java 代码文件中编写一个简单的代码。
为了检查`RadioButton`或`CheckBox`是否被选中，我们可以在 Java 代码文件中编写一个简单的代码。
```
// initiate the radio button
......@@ -91,7 +91,7 @@ Boolean RadioButtonState = maleRadioButton.isChecked();
代码的第一行使用布局 XML 中为`RadioButton`视图指定的`id`来创建该视图的实例。这段代码对于所有类型的视图都是一样的。
同样，我们也可以选中相同的复选框，
同样，我们也可以选中相同的`CheckBox`，
```
// initiate the check box
......@@ -104,13 +104,13 @@ Boolean CheckBoxState = myCheckbox.isChecked();
### 常用属性
这里我们有一些常用的属性，你可以用它们来设计你的单选按钮和`Checkbox`视图。
这里我们有一些常用的属性，你可以用它们来设计你的`RadioButton`和`Checkbox`视图。
* `android:textColor`:改变文字的颜色。
* `android:textSize`:调整文字大小。
* `android:textStyle`:文本样式，可能的值有`Bold`或`Italic`等。
* `android:background`:给单选按钮一个背景色。
* 我们也可以在单选按钮的文本旁边使用图像。要添加图像，我们可以使用`android:drawableTop`、`android:drawableBottom`、`android:drawableRight`和`android:drawableLeft`，分别在文本的顶部、底部、右侧或左侧设置图像。
* `android:background`:给`RadioButton`一个背景色。
* 我们也可以在`RadioButton`的文本旁边使用图像。要添加图像，我们可以使用`android:drawableTop`、`android:drawableBottom`、`android:drawableRight`和`android:drawableLeft`，分别在文本的顶部、底部、右侧或左侧设置图像。
```
android:drawableRight="@drawable/any_picture"
......
docs/mobi/027.md
浏览文件 @ b26ae976
......@@ -70,7 +70,7 @@ public void study(View view) {
}
```
类似地，`android:onClick`属性可以用于所有可用的视图子类，如[`TextView`](android-textview)、`EditText`、单选按钮、复选框等。
类似地，`android:onClick`属性可以用于所有可用的视图子类，如[`TextView`](android-textview)、`EditText`、`RadioButton`、`CheckBox`等。
* * *
......
docs/mobi/041.md
浏览文件 @ b26ae976
# 在安卓系统中使用单选按钮和复选框
# 在安卓系统中使用`RadioButton`和`CheckBox`
> 原文：<https://www.studytonight.com/android/radiogroup-radiobutton-checkbox>
到目前为止，您一定非常熟悉`EditText`和`TextView`以及各种布局。让我们继续，了解更多关于其他视图的信息，如`RadioButton`和`CheckBox`。
在本教程中，我们将设计一个表单，用户必须使用单选按钮选择其中一个选项。用户将不得不使用复选框选择更多的建议和选项。然后我们将在显示屏上显示用户使用[吐司](toast-in-android)选择的所有选项。
在本教程中，我们将设计一个表单，用户必须使用`RadioButton`选择其中一个选项。用户将不得不使用`CheckBox`选择更多的建议和选项。然后我们将在显示屏上显示用户使用[吐司](toast-in-android)选择的所有选项。
* * *
......@@ -90,7 +90,7 @@
因此，我们需要用户将与之交互的视图，以便我们能够获得必要的信息。然后我们需要实现**点击提交按钮上的监听器**。
在`onClickListener()`中，首先我们必须从收音机组中获取选定的单选按钮`id`。一旦我们有了所选单选按钮[的`id`按钮](android-button-view)，我们就可以很容易地获取所选单选按钮的**文本值**并将其显示在屏幕上。让我们实现它。下面我们有**MainActivity.java**文件的所有代码。
在`onClickListener()`中，首先我们必须从收音机组中获取选定的`RadioButton``id`。一旦我们有了所选`RadioButton`[的`id`按钮](android-button-view)，我们就可以很容易地获取所选`RadioButton`的**文本值**并将其显示在屏幕上。让我们实现它。下面我们有**MainActivity.java**文件的所有代码。
```
package com.example.akshay.studytonightandroid;
......@@ -138,9 +138,9 @@ public class MainActivity extends AppCompatActivity {
}
```
为了得到选中的单选按钮，我们使用了`radioGroup.getCheckedRadioButtonId()`方法，返回选中单选按钮的`id`。
为了得到选中的`RadioButton`，我们使用了`radioGroup.getCheckedRadioButtonId()`方法，返回选中`RadioButton`的`id`。
然后为了获得所选单选按钮的文本，我们在该所选单选按钮上使用了`getText()`方法。我们从该方法接收的文本使用`toString()`方法转换为`String`类型。最后，我们使用一个 Toast 向用户显示了所选的选项值。
然后为了获得所选`RadioButton`的文本，我们在该所选`RadioButton`上使用了`getText()`方法。我们从该方法接收的文本使用`toString()`方法转换为`String`类型。最后，我们使用一个 Toast 向用户显示了所选的选项值。
将以上代码添加到**MainActivity.java**文件中，然后运行你的安卓应用项目。结果将类似于下图所示。每当用户选择任何选项时，它都会以吐司的形式显示给用户。
......@@ -148,9 +148,9 @@ public class MainActivity extends AppCompatActivity {
* * *
### 是复选框的时候了
### 是`CheckBox`的时候了
现在，是时候玩一些复选框了。通过在布局 XML 文件中的`Button`视图后复制粘贴以下代码来扩展用户界面设计(将`id`作为**b 提交**)。
现在，是时候玩一些`CheckBox`了。通过在布局 XML 文件中的`Button`视图后复制粘贴以下代码来扩展用户界面设计(将`id`作为**b 提交**)。
```
<TextView
......@@ -200,13 +200,13 @@ public class MainActivity extends AppCompatActivity {
android:checked="false"/>
```
> **重要提示:** *对于提交按钮，我们必须设置这个属性:`android:layout_below="@+id/cb4"`，使其出现在最后，因为我们现在已经在现有表单中添加了复选框。*
> **重要提示:** *对于提交按钮，我们必须设置这个属性:`android:layout_below="@+id/cb4"`，使其出现在最后，因为我们现在已经在现有表单中添加了`CheckBox`。*
复选框用于向用户显示多个选项，并且允许用户从这些选项中选择一个或多个。所有复选框最初都将`checked`属性设置为 **false** 。
`CheckBox`用于向用户显示多个选项，并且允许用户从这些选项中选择一个或多个。所有`CheckBox`最初都将`checked`属性设置为 **false** 。
要在用户点击提交按钮时从用户界面获取用户选择的复选框值，我们将使用`isChecked()`检查复选框是否被选中。
要在用户点击提交按钮时从用户界面获取用户选择的`CheckBox`值，我们将使用`isChecked()`检查`CheckBox`是否被选中。
因此，我们将不得不对我们的**MainActivity.java**类文件进行一些更改。首先，我们必须使用`findViewById()`方法为复选框创建实例。为此，我们还必须声明 CheckBox 类型的全局变量。
因此，我们将不得不对我们的**MainActivity.java**类文件进行一些更改。首先，我们必须使用`findViewById()`方法为`CheckBox`创建实例。为此，我们还必须声明 CheckBox 类型的全局变量。
要声明全局变量，
......@@ -223,9 +223,9 @@ cb3 = (CheckBox) findViewById(R.id.cb3);
cb4 = (CheckBox) findViewById(R.id.cb4);
```
一旦我们准备好了所有的实例，我们所要做的就是当用户点击提交按钮时，检查用户选择了哪些复选框。正如我们已经提到的，这是通过使用 CheckBox 视图的`isChecked()`方法来完成的。
一旦我们准备好了所有的实例，我们所要做的就是当用户点击提交按钮时，检查用户选择了哪些`CheckBox`。正如我们已经提到的，这是通过使用 CheckBox 视图的`isChecked()`方法来完成的。
`isChecked()`如果复选框被选中，方法返回**真**，否则返回**假**。使用`getText()`和`toString()`方法检索选定的复选框值并将其添加到一个字符串(`checkBoxChoices`)中。最后，一个吐司被用来显示所有选择的选项。
`isChecked()`如果`CheckBox`被选中，方法返回**真**，否则返回**假**。使用`getText()`和`toString()`方法检索选定的`CheckBox`值并将其添加到一个字符串(`checkBoxChoices`)中。最后，一个吐司被用来显示所有选择的选项。
因此，用以下代码更新 SUBMIT 按钮的`OnClick()`方法中的现有代码:
......@@ -282,7 +282,7 @@ buttonSubmit.setOnClickListener(new View.OnClickListener() {
![Using RadioGroup, RadioButton and CheckBox in Android](img/901c01c9b2d6f2ffd23ec9a1f43b0ae0.png) ![RadioGroup, RadioButton and CheckBox in Android](img/b5d21db736dbea94492614c5027fefa6.png)
当您运行该应用时，您将看到在所有单选按钮中，您只能选择一个单选按钮，而在复选框的情况下，您可以选择任意数量的单选按钮。这就是单选按钮和复选框的工作方式。这就是安卓应用开发中单选按钮和复选框的实现。
当您运行该应用时，您将看到在所有`RadioButton`中，您只能选择一个`RadioButton`，而在`CheckBox`的情况下，您可以选择任意数量的`RadioButton`。这就是`RadioButton`和`CheckBox`的工作方式。这就是安卓应用开发中`RadioButton`和`CheckBox`的实现。
* * *
......
docs/mobi/042.md
浏览文件 @ b26ae976
# Android 中的自动完成 xtView
# Android 中的`AutoCompleteTextView`
> 原文：<https://www.studytonight.com/android/autocomplete-textview>
......@@ -10,7 +10,7 @@
在`AutoCompleteTextView`的帮助下，类似的功能可以在安卓应用中实现。
自动完成[`TextView`](android-textview)是一个可编辑的`TextView`，用户可以在其中键入任何值，甚至可以从建议的项目列表中选择输入。当用户点击一个项目时，将从列表中选择建议的项目。此外，编辑框的内容将被所选的建议项目替换。以下是自动完成`TextView`的示例:
自动完成[`TextView`](android-textview)是一个可编辑的`TextView`，用户可以在其中键入任何值，甚至可以从建议的项目列表中选择输入。当用户点击一个项目时，将从列表中选择建议的项目。此外，编辑框的内容将被所选的建议项目替换。以下是`AutoCompleteTextView`的示例:
![AutoCompleteTextView example in Android App](img/2e7d129f04af6923a8ac2f7b4eac0fd5.png)
......@@ -65,11 +65,11 @@
在这个布局中，我们有一个`TextView`在屏幕上显示标题**“输入任何餐厅名称”**。然后在它下面，我们有一个`AutoCompleteTextView`，它将从用户那里获取餐厅名称，并提供建议。之后我们还有一个`TextView`，它将显示从建议列表中选择的项目。
如您所见，在自动完成`TextView`中，我们设置了一个名为`android:completionThreshold`的属性。此属性指示要输入的字符数，之后，建议列表将显示给用户。这意味着，如果您为其分配一个等于`2`的值，那么，该视图将需要至少 2 个字符来向用户显示建议列表。
如您所见，在`AutoCompleteTextView`中，我们设置了一个名为`android:completionThreshold`的属性。此属性指示要输入的字符数，之后，建议列表将显示给用户。这意味着，如果您为其分配一个等于`2`的值，那么，该视图将需要至少 2 个字符来向用户显示建议列表。
在**MainActivity.java**文件中，首先我们将创建`AutoCompleteTextView`和`TextView`的实例。然后，我们将使用 [`ArrayAdapter`](adapter-and-adapter-view) 在自动完成`TextView`中显示建议项目。为此，我们首先需要创建一个名为`restaurants`的数组，并添加各种餐厅的名称以显示它们作为建议。
在**MainActivity.java**文件中，首先我们将创建`AutoCompleteTextView`和`TextView`的实例。然后，我们将使用 [`ArrayAdapter`](adapter-and-adapter-view) 在`AutoCompleteTextView`中显示建议项目。为此，我们首先需要创建一个名为`restaurants`的数组，并添加各种餐厅的名称以显示它们作为建议。
然后我们将实现`AdapterView.OnItemClickListener`并在自动完成`TextView`上设置`onItemClickListener()`，以从列表中获取用户选择的项目值。
然后我们将实现`AdapterView.OnItemClickListener`并在`AutoCompleteTextView`上设置`onItemClickListener()`，以从列表中获取用户选择的项目值。
以下是上述逻辑的代码:
......
docs/mobi/046.md
浏览文件 @ b26ae976
......@@ -2,7 +2,7 @@
> 原文：<https://www.studytonight.com/android/fragments-in-android>
安卓中的**片段**是一个组件，可以在活动中使用，定义一个独立的模块化用户界面组件，并附加到活动中。它独立运行，但由于它与[活动](activity-in-android)相关联，当一个活动被破坏时，碎片也会被破坏。
安卓中的**片段**是一个组件，可以在活动中使用，定义一个独立的模块化用户界面组件，并附加到活动中。它独立运行，但由于它与[活动](activity-in-android)相关联，当一个活动被破坏时，片段也会被破坏。
如果你懂生物，知道**宿主**和**寄生虫**的概念，那么在安卓系统中，`Activity`是宿主，而一个**片段**是寄生虫。
......@@ -12,25 +12,25 @@
此外，一个片段是一个可重用的组件，因此，如果需要，单个片段可以包含在多个活动中。
一般来说，在安卓应用中，碎片被用来创建多窗格用户界面。
一般来说，在安卓应用中，片段被用来创建多窗格用户界面。
一个片段对于 UI(用户界面)有它自己的[布局](introduction-to-layouts)，但是我们甚至可以定义一个没有任何布局的片段，来实现一个没有用户界面的行为，更像是一个后台服务。
因此，碎片是安卓操作系统中一个非常有趣的组件，它可以在一个安卓应用中以多种方式使用。
因此，片段是安卓操作系统中一个非常有趣的组件，它可以在一个安卓应用中以多种方式使用。
* * *
### 为什么我们需要安卓中的碎片？
### 为什么我们需要安卓中的片段？
如果我们已经有了[活动](activity-in-android)，一个片段就像是一个**子活动**，那么在安卓中再多一个组件又有什么用呢？
嗯，在碎片引入之前(碎片是在 Android 的蜂巢版即 API 版本 11 中添加的)，我们在给定的时间点只能在一个屏幕上有一个活动，没有办法划分屏幕，单独控制不同的部分。
嗯，在片段引入之前(片段是在 Android 的蜂巢版即 API 版本 11 中添加的)，我们在给定的时间点只能在一个屏幕上有一个活动，没有办法划分屏幕，单独控制不同的部分。
随着移动设备屏幕尺寸的增加，在屏幕上同时显示更多的内容更有意义，因此碎片非常有用，在安卓开发者社区中非常受欢迎。
随着移动设备屏幕尺寸的增加，在屏幕上同时显示更多的内容更有意义，因此片段非常有用，在安卓开发者社区中非常受欢迎。
![Android Fragment example](img/8e3706de8634ebf6dd6ad2c83c65013c.png)
安卓应用中碎片的使用完全取决于应用所使用的设备的屏幕大小。如果屏幕尺寸大，那么我们可以很容易地在屏幕上显示 2 个或者更多的片段，但是如果显示尺寸较小，建议在单独的活动中使用片段。
安卓应用中片段的使用完全取决于应用所使用的设备的屏幕大小。如果屏幕尺寸大，那么我们可以很容易地在屏幕上显示 2 个或者更多的片段，但是如果显示尺寸较小，建议在单独的活动中使用片段。
![Android Fragment example for Tablet and Mobile](img/a9fdccf4cbb8fb6b5b42ce3121f3069b.png)
......@@ -38,23 +38,23 @@
* * *
#### 碎片在安卓系统中的主要用途
#### 片段在安卓系统中的主要用途
下面是碎片在安卓系统中的 3 种主要用法，碎片就是针对这 3 种用法介绍的:
下面是片段在安卓系统中的 3 种主要用法，片段就是针对这 3 种用法介绍的:
1. **模块化**:如果一个活动有太多的功能组件，最好将其分成独立的片段，从而使代码更有组织性和更容易维护。
2. **可重用性**:如果我们在一个片段中定义了一个特定的特性，那么这个特性或多或少会变成一个可重用的组件，可以很容易地被引入到任何活动中。
3. **适应性**:如果我们把一个应用屏幕的 UI 组件拆分成碎片，那么根据屏幕大小等改变它们的方向和位置就变得更容易了。
3. **适应性**:如果我们把一个应用屏幕的 UI 组件拆分成片段，那么根据屏幕大小等改变它们的方向和位置就变得更容易了。
* * *
### 碎片生命周期
### 片段生命周期
片段生命周期从它附加到一个活动开始。下面我们以流程图的形式展示了片段的完整生命周期。
![Fragment Lifecycle in Android](img/20be8172791c8ed95c36dbee986e0eab.png)
#### 碎片的生命周期方法
#### 片段的生命周期方法
This is called when the fragment becomes active or interactive.
......@@ -67,11 +67,11 @@ This is called when the fragment becomes active or interactive.
| onResume（） | |
| onpause() | 当一个片段不再是交互式的，并且用户即将离开该片段时，就会调用这个函数。此时，如果需要，建议保存现有用户会话的任何数据。 |
| onStop() | 当片段不再可见时，调用此方法。 |
| onDestroyView() | 当碎片要被销毁时，就调用这个函数。在这里，您可以在碎片被销毁之前清理资源。 |
| onDestroy() | 这是对碎片状态的最后清理。 |
| onDestroyView() | 当片段要被销毁时，就调用这个函数。在这里，您可以在片段被销毁之前清理资源。 |
| onDestroy() | 这是对片段状态的最后清理。 |
| 底部() | 就在片段从宿主活动分离之前调用它。 |
在我们的下一个教程中，我们将学习如何在 android 中实现碎片。
在我们的下一个教程中，我们将学习如何在 android 中实现片段。
* * *
......
docs/mobi/047.md
浏览文件 @ b26ae976
# 在安卓系统中处理碎片
# 在安卓系统中处理片段
> 原文：<https://www.studytonight.com/android/working-with-android-fragments>
既然我们已经理解了什么是碎片，现在是时候举一个实际的例子了。为了创建一个片段，我们必须定义一个片段类，它扩展了类`Fragment`并覆盖了创建片段所必需的方法。
既然我们已经理解了什么是片段，现在是时候举一个实际的例子了。为了创建一个片段，我们必须定义一个片段类，它扩展了类`Fragment`并覆盖了创建片段所必需的方法。
```
import android.os.Bundle;
......
docs/mobi/051.md
浏览文件 @ b26ae976
# 科学问答安卓应用
# 科学测验安卓应用
> 原文：<https://www.studytonight.com/android/second-android-application-1>
......
docs/mobi/052.md
浏览文件 @ b26ae976
# 科学问答安卓应用-第 2 部分
# 科学测验安卓应用——第 2 部分
> 原文：<https://www.studytonight.com/android/second-android-application-2>
正如我们所知，一个活动的默认布局由一个`RelativeLayout`和一个带有文本 Hello World 的`TextView`组成！，因此我们将不得不改变 ti，因为我们正在构建一个科学问答应用。对于我们的应用，我们将设置如下图所示的屏幕，为此，我们需要:
正如我们所知，一个活动的默认布局由一个`RelativeLayout`和一个带有文本 Hello World 的`TextView`组成！，因此我们将不得不改变 ti，因为我们正在构建一个科学测验应用。对于我们的应用，我们将设置如下图所示的屏幕，为此，我们需要:
* [`LinearLayout`](linear-layout-in-android) 一纵
* 一 [`TextView`](android-textview)
......
docs/mobi/053.md
浏览文件 @ b26ae976
# 科学问答安卓应用-大结局
# 科学测验安卓应用——大结局
> 原文：<https://www.studytonight.com/android/second-android-application-3>
......
docs/mobi/054.md
浏览文件 @ b26ae976
# 秒表安卓应用项目-第 1 部分
# 秒表安卓应用项目——第 1 部分
> 原文：<https://www.studytonight.com/android/stopwatch-android-app-project-part-1>
......
docs/mobi/055.md
浏览文件 @ b26ae976
# 秒表安卓应用项目-第 2 部分
# 秒表安卓应用项目——第 2 部分
> 原文：<https://www.studytonight.com/android/stopwatch-android-app-project-part-2>
......
docs/mobi/056.md
浏览文件 @ b26ae976
# 秒表安卓应用项目-第 3 部分
# 秒表安卓应用项目——第 3 部分
> 原文：<https://www.studytonight.com/android/stopwatch-android-app-project-part-3>
......
docs/mobi/057.md
浏览文件 @ b26ae976
# 我的天啊！我的天啊！我的天啊！我的天啊！我的天啊！我的天啊！我的天啊！我的天啊！我的天啊！我的天啊！我的天啊！我的天啊
\ No newline at end of file
# Kotlin
\ No newline at end of file
docs/mobi/058.md
浏览文件 @ b26ae976
# 科特林基础知识
\ No newline at end of file
# Kotlin基础知识
\ No newline at end of file
docs/mobi/059.md
浏览文件 @ b26ae976
# 柯特林简介
# Kotlin简介
> 原文：<https://www.studytonight.com/kotlin/introduction-to-kotlin>
欢迎来到科特林教程系列。Kotlin 是一种针对 Java 平台的相对较新的编程语言。我们几乎可以在 Java 的任何地方使用 Kotlin。Kotlin 可用于开发服务器端应用、安卓应用、数据科学领域等。Kotlin 代码也可以转换成 JavaScript 代码。有一些 Java 的背景知识是好的，但是如果你没有 Java 的任何先验知识，那就不成问题了。
欢迎来到Kotlin教程系列。Kotlin 是一种针对 Java 平台的相对较新的编程语言。我们几乎可以在 Java 的任何地方使用 Kotlin。Kotlin 可用于开发服务器端应用、安卓应用、数据科学领域等。Kotlin 代码也可以转换成 JavaScript 代码。有一些 Java 的背景知识是好的，但是如果你没有 Java 的任何先验知识，那就不成问题了。
Kotlin 具有代码简洁、零安全、实用等特点。它也完全可以与 Java 互操作。因此，它也支持所有现有的 Java 库和框架。
## 科特林历史
## Kotlin历史
Kotlin 语言是由 JetBrains(开发著名的 Java IDE IntelliJ IDEA 的同一家公司)在 2010 年创建的。自 2012 年以来，它一直是开源的。
科特林得名于俄罗斯一个名叫[科特林岛](http://en.wikipedia.org/wiki/Kotlin_Island)的岛屿。kotlin 的第一个版本于 2016 年发布，最新版本(2020 年)是 Kotlin v1.3。
Kotlin得名于俄罗斯一个名叫[Kotlin岛](http://en.wikipedia.org/wiki/Kotlin_Island)的岛屿。kotlin 的第一个版本于 2016 年发布，最新版本(2020 年)是 Kotlin v1.3。
科特林版本简史:
Kotlin版本简史:
* Kotlin v1.0，Kotlin 的第一个版本于 2016 年 2 月发布。它正式成为 Kotlin 的第一个稳定版本。
......@@ -26,7 +26,7 @@ Kotlin 语言是由 JetBrains(开发著名的 Java IDE IntelliJ IDEA 的同一
2017 年，由于越来越受欢迎，谷歌宣布对 Kotlin 提供一流的支持。2019 年，谷歌将 Kotlin 编程语言作为安卓应用开发的首选语言。
## 科特林的特点
## Kotlin的特点
Kotlin 提供了比 Java 更多的特性。Kotlin 优于其他语言的主要特点是:
......@@ -38,11 +38,11 @@ Kotlin 确保每一行代码都带有某种意义。在 Java 中需要的所有
### 2.空保险箱
Kotlin 确保我们的程序在运行时不会抛出 *NullPointerException* 。Kotlin 的类型系统跟踪可以为空的值。如果对该值执行任何操作，这可能导致*空指针异常，*科特林禁止该操作，并给出错误以避免该错误。我们将在单独的章节中讨论更多关于 null 安全性的内容。
Kotlin 确保我们的程序在运行时不会抛出 *NullPointerException* 。Kotlin 的类型系统跟踪可以为空的值。如果对该值执行任何操作，这可能导致*空指针异常，*Kotlin禁止该操作，并给出错误以避免该错误。我们将在单独的章节中讨论更多关于 null 安全性的内容。
### 3.彼此协作的
这是柯特林最令人钦佩的特征之一。Kotlin 与 Java 完全互操作。这意味着你可以在你的 Kotlin 代码库中使用 Java 库，调用 Java 方法，扩展 Java 类，实现 Java 接口等等。您可以用 Java 编写项目的一个类，用 Kotlin 编写另一个类。他们都将能够使用彼此的功能。
这是Kotlin最令人钦佩的特征之一。Kotlin 与 Java 完全互操作。这意味着你可以在你的 Kotlin 代码库中使用 Java 库，调用 Java 方法，扩展 Java 类，实现 Java 接口等等。您可以用 Java 编写项目的一个类，用 Kotlin 编写另一个类。他们都将能够使用彼此的功能。
### 4.JavaScript 透明
......
docs/mobi/060.md
浏览文件 @ b26ae976
# 科特林环境设置
# Kotlin环境设置
> 原文：<https://www.studytonight.com/kotlin/kotlin-environment-setup>
......@@ -78,7 +78,7 @@
* 按照相同的步骤将此路径设置为环境变量。
现在我们已经成功地设置了柯特林编译器。要检查是否一切正常，请打开命令提示符，并键入以下命令:
现在我们已经成功地设置了Kotlin编译器。要检查是否一切正常，请打开命令提示符，并键入以下命令:
```
kotlinc -help
......
docs/mobi/061.md
浏览文件 @ b26ae976
# 柯特林第一个使用 IntelliJ IDEA 的程序
# Kotlin第一个使用 IntelliJ IDEA 的程序
> 原文：<https://www.studytonight.com/kotlin/first-program-in-kotlin-using-intellij-idea>
......@@ -24,14 +24,14 @@
* 在左侧可以看到这样的项目结构:
![First program in Kotlin](img/1c98d3353e247e3ce61c8091f569f504.png)
* 右键点击 **src** 文件夹，选择**新建>柯特林文件/类**，点击回车。你会看到:
* 右键点击 **src** 文件夹，选择**新建>Kotlin文件/类**，点击回车。你会看到:
![First program in Kotlin](img/066085e7c038e375dd5bb940d1c84991.png)
* 输入文件名“ **HelloWorld** ，点击回车。
您已经成功创建了一个新的 Kotlin 项目，并在其中创建了一个 Kotlin 文件。现在我们将在其中创建我们的第一个 Kotlin 程序。
## 科特林的第一个节目
## Kotlin的第一个节目
编写以下程序的是 **HelloWorld.kt** 文件:
......@@ -43,7 +43,7 @@ fun main() {
**说明:**
* 第 1 行:每个 Kotlin 程序都以`main()`函数开始。使用柯特林中的`fun`关键字创建函数。我们将在后面的章节中阅读更多关于函数的内容。
* 第 1 行:每个 Kotlin 程序都以`main()`函数开始。使用Kotlin中的`fun`关键字创建函数。我们将在后面的章节中阅读更多关于函数的内容。
* 第 2 行:`println()`功能用于在控制台上打印字符串。
......@@ -57,7 +57,7 @@ fun main() {
## 摘要
在本文中，我们创建了一个科特林项目，并在科特林运行了我们的第一个程序。在下一个教程中，我们将看到如何通过命令行运行相同的程序。
在本文中，我们创建了一个Kotlin项目，并在Kotlin运行了我们的第一个程序。在下一个教程中，我们将看到如何通过命令行运行相同的程序。
* * *
......
docs/mobi/062.md
浏览文件 @ b26ae976
......@@ -4,7 +4,7 @@
在本教程中，我们将看到如何使用编译器运行 Kotlin 程序。确保您已经在前面[设置了 Kotlin 编译器](https://www.studytonight.com/kotlin/kotlin-environment-setup)。
## 科特林的第一个节目
## Kotlin的第一个节目
打开任何文本编辑器(记事本、崇高等)。)并创建一个 **HelloWorld.kt** 文件。确保该文件的扩展名为“**”。kt** ”。编写以下程序的是 **HelloWorld.kt** 文件:
......@@ -48,7 +48,7 @@ java -jar HelloWorld.jar
## 摘要
在本教程中，我们看到了如何通过命令行运行程序。基本设置已经完成，我们将从下一个教程开始详细学习柯特林的概念。
在本教程中，我们看到了如何通过命令行运行程序。基本设置已经完成，我们将从下一个教程开始详细学习Kotlin的概念。
* * *
......
docs/mobi/063.md
浏览文件 @ b26ae976
# 柯特林关键字和标识符
# Kotlin关键字和标识符
> 原文：<https://www.studytonight.com/kotlin/kotlin-keywords-and-identifiers>
......@@ -32,7 +32,7 @@ Kotlin 中有两种类型的关键字:
val fun = 5   // Error
```
柯特林的硬关键词是:
Kotlin的硬关键词是:
<caption>**Hard keywords**</caption>
| 为 | 断开 | 级 | 继续 |
......@@ -70,7 +70,7 @@ Kotlin 中的软关键词是:
在本教程中，我们研究了关键字和标识符。我们将使用和研究本教程系列中的大多数关键词。
接下来，我们将研究柯特林中的变量。
接下来，我们将研究Kotlin中的变量。
* * *
......
docs/mobi/064.md
浏览文件 @ b26ae976
# 柯特林变量和常数
# Kotlin变量和常数
> 原文：<https://www.studytonight.com/kotlin/kotlin-variables-and-constants>
......@@ -37,7 +37,7 @@ println(name)
你好
世界！！
## 柯特林常数
## Kotlin常数
Kotlin 常量用于定义具有常量值的变量。`const`关键字用于定义常量变量。`const` 关键字只能与`val`关键字一起使用，不能与`var`关键字一起使用。
......@@ -78,7 +78,7 @@ fun sayHello():String{
## 摘要
在本教程中，我们讨论了柯特林中的变量类型。我们也看到了`const`关键词的使用以及`val`和`const`关键词的区别。在下一个教程中，我们将讨论 Kotlin 中的数据类型。
在本教程中，我们讨论了Kotlin中的变量类型。我们也看到了`const`关键词的使用以及`val`和`const`关键词的区别。在下一个教程中，我们将讨论 Kotlin 中的数据类型。
* * *
......
docs/mobi/065.md
浏览文件 @ b26ae976
# 科特林数据类型
# Kotlin数据类型
> 原文：<https://www.studytonight.com/kotlin/kotlin-data-types>
......@@ -54,11 +54,11 @@ println("Data type of name: " + name::class.simpleName)
val variable_name: datatype = value
```
因此，我们在柯特林中主要使用`val`关键字来声明变量，我们可以在变量名后面使用**冒号来指定数据类型。我们将在下面讨论各种数据类型时看到示例。**
因此，我们在Kotlin中主要使用`val`关键字来声明变量，我们可以在变量名后面使用**冒号来指定数据类型。我们将在下面讨论各种数据类型时看到示例。**
### 1.科特林数字
### 1.Kotlin数字
Kotlin 提供了一些内置的数据类型来表示数字。柯特林数可以是**整数值或浮点数值**。
Kotlin 提供了一些内置的数据类型来表示数字。Kotlin数可以是**整数值或浮点数值**。
对于整数，数据类型为:
......@@ -126,7 +126,7 @@ val percentage: Double = 1.0
对于分数数据类型，编译器默认推断**双**数据类型。要明确指定**浮动**，请在值中添加后缀 **f** 或 **F** 作为后缀。
### 2.柯特林字符
### 2.Kotlin字符
Kotlin 中的字符使用 **Char** 关键字声明。字符应该放在单引号中，如**‘a’**。一个字符的大小是 **4 位**。
......
docs/mobi/066.md
浏览文件 @ b26ae976
# 柯特林算子
# Kotlin算子
> 原文：<https://www.studytonight.com/kotlin/kotlin-operators>
......@@ -15,7 +15,7 @@ println(sum)
在上面的代码示例中，`num1`和`num2`是**操作数**，而`+`是**运算符**。
科特林有各种类型的运营商。它们分为以下几类:
Kotlin有各种类型的运营商。它们分为以下几类:
* 算术运算符
......@@ -254,7 +254,7 @@ println(message!!.length)
### 3.安全呼叫操作员(`?.`)
这个算子是柯特林中最重要的算子之一。它**将我们从空指针异常**中拯救出来。顾名思义，它通过检查对象是否为空来帮助我们安全地调用对象的任何变量或方法。
这个算子是Kotlin中最重要的算子之一。它**将我们从空指针异常**中拯救出来。顾名思义，它通过检查对象是否为空来帮助我们安全地调用对象的任何变量或方法。
```
val message: String? = null
......
docs/mobi/067.md
浏览文件 @ b26ae976
# 柯特林输入和输出
# Kotlin输入和输出
> 原文：<https://www.studytonight.com/kotlin/kotlin-input-and-output>
在本教程中，我们将讨论如何将输出打印到控制台或屏幕，并在 Kotlin 中接受用户的输入。用户输入和输出是任何程序的重要部分。它们将有助于用户交互。
## 在科特林显示输出
## 在Kotlin显示输出
对于输出到控制台窗口的打印，我们可以使用`print()`和`println()`功能。当`print()`功能继续将输出添加到同一行时，`println()`将打印输出并将光标移动到下一行。让我们用一个例子来看看:
......@@ -54,7 +54,7 @@ println("Character is: $character")
数字为:25
字符为:a
## 在科特林获取用户输入
## 在Kotlin获取用户输入
为了获取用户的输入，我们使用`readline()`功能。默认情况下，它会将输入作为**字符串**。如果我们需要任何其他类型的输入，如数字、布尔值等。，则需要将其转换为特定的类型，这意味着显式地指定输入并将输入从字符串转换为其他数据类型，如 Integer 等。
......
docs/mobi/068.md
浏览文件 @ b26ae976
# 科特林评论
# Kotlin评论
> 原文：<https://www.studytonight.com/kotlin/kotlin-comments>
......@@ -14,7 +14,7 @@ Kotlin 中有两种类型的注释:
现在我们将看到如何在 Kotlin 中使用它们。
## 柯特林的单行注释
## Kotlin的单行注释
顾名思义，单行注释用于在单行中编写注释。它们是使用`//`(双斜线)创建的。单行注释应该只跨越一行，而不是多行，否则我们会得到一个错误。
......@@ -29,7 +29,7 @@ println("Input in string format is: $inputString") // Input is printed here
在上面的代码中，有三个注释(在第 1、2 和 4 行)。
## 多行注释柯特林
## 多行注释Kotlin
多行注释跨越多行。以`/*`开始，以`*/`结束。
......@@ -48,7 +48,7 @@ println("Input in string format is: $inputString")
## 摘要
在本教程中，我们讨论了柯特林中的注释。注释是有用的工具，我们应该明智地使用它，使我们的代码更易读，并记录代码在程序中的作用。
在本教程中，我们讨论了Kotlin中的注释。注释是有用的工具，我们应该明智地使用它，使我们的代码更易读，并记录代码在程序中的作用。
* * *
......
docs/mobi/069.md
浏览文件 @ b26ae976
# 科特林控制流程
\ No newline at end of file
# Kotlin控制流程
\ No newline at end of file
docs/mobi/070.md
浏览文件 @ b26ae976
# 柯特林 if else 表达式
# Kotlin if else 表达式
> 原文：<https://www.studytonight.com/kotlin/kotlin-if-else-expression>
......@@ -24,7 +24,7 @@ fun main() {
在这里，因为学生的**分大于 33，所以通过了**考试。
但在科特林，如果-else 不是**陈述**，而是**表达**。这意味着 if-else 块可以返回一个语法略有变化的值。
但在Kotlin，如果-else 不是**陈述**，而是**表达**。这意味着 if-else 块可以返回一个语法略有变化的值。
让我们看看下面的代码:
......@@ -192,7 +192,7 @@ fun main() {
## 摘要
在本教程中，我们讨论了柯特林中的`if`和`else`表达式。在下一个教程中，我们将讨论柯特林中的`when`表达。
在本教程中，我们讨论了Kotlin中的`if`和`else`表达式。在下一个教程中，我们将讨论Kotlin中的`when`表达。
* * *
......
docs/mobi/071.md
浏览文件 @ b26ae976
# 科特林当表情
# Kotlin当表情
> 原文：<https://www.studytonight.com/kotlin/kotlin-when-expression>
在本教程中，我们将讨论柯特林`when`表达式。当我们使用**根据变量**的不同值来选择特定的语句时，会用到 Kotlin `when`表达式。它类似于其他编程语言中的**开关盒**。
在本教程中，我们将讨论Kotlin`when`表达式。当我们使用**根据变量**的不同值来选择特定的语句时，会用到 Kotlin `when`表达式。它类似于其他编程语言中的**开关盒**。
使用`when`表达式打印字母表类型的简单程序是:
......@@ -59,7 +59,7 @@ fun main() {
## `when`表达式中的代码块
一段代码也可以放在柯特林`when`的表达式条件里面:
一段代码也可以放在Kotlin`when`的表达式条件里面:
```
fun main() {
......@@ -131,7 +131,7 @@ fun main() {
## 摘要
在本教程中，我们介绍了柯特林中的`when`表达式。这在编写 Kotlin 代码时非常有用，在那里你必须创建一个类似功能的菜单。在下一个教程中，我们将介绍 Kotlin 中不同类型的循环。
在本教程中，我们介绍了Kotlin中的`when`表达式。这在编写 Kotlin 代码时非常有用，在那里你必须创建一个类似功能的菜单。在下一个教程中，我们将介绍 Kotlin 中不同类型的循环。
* * *
......
docs/mobi/072.md
浏览文件 @ b26ae976
......@@ -4,7 +4,7 @@
在本教程中，我们将从 Kotlin 中的循环开始。我们将介绍 Kotlin 中不同类型的循环，这些循环用于一次又一次地执行一段代码，直到满足某个条件。
## 科特林环路
## Kotlin环路
Kotlin 中的循环用于**一次又一次地执行一段特定的代码**。我们可以通过指定某个条件来打破循环。如果达到给定的**条件，执行将结束循环**。让我们用一个例子来理解循环。
......@@ -44,7 +44,7 @@ while(condition){
如果条件从未失效，它**将进入无限循环。我们在使用循环时应该注意这一点。**
## 科特林`while`循环示例
## Kotlin`while`循环示例
让我们举一个例子，我们将使用`while`循环打印一个 2 的数学表。
......
docs/mobi/073.md
浏览文件 @ b26ae976
# 科特林边做边循环
# Kotlin边做边循环
> 原文：<https://www.studytonight.com/kotlin/kotlin-dowhile-loop>
在本教程中，我们将介绍柯特林中的`do-while`循环。do-while 循环就像 [Kotlin `while`循环](https://www.studytonight.com/kotlin/kotlin-while-loop)一样，只有一个区别，那就是无论您在`do-while`循环中提供什么条件，l **oop 都将执行一次**，因为条件是在循环代码执行后检查的。
在本教程中，我们将介绍Kotlin中的`do-while`循环。do-while 循环就像 [Kotlin `while`循环](https://www.studytonight.com/kotlin/kotlin-while-loop)一样，只有一个区别，那就是无论您在`do-while`循环中提供什么条件，l **oop 都将执行一次**，因为条件是在循环代码执行后检查的。
## kot Lin〔t0〕回圈:
......@@ -22,7 +22,7 @@ do {
* 如果条件为**真**，再次执行`do`块。否则，循环的执行结束。
## 科特林`do-while`循环示例
## Kotlin`do-while`循环示例
让我们举个例子**打印所有从 1 到 10 的偶数**:
......@@ -69,7 +69,7 @@ fun main() {
## 摘要
在本教程中，我们通过代码示例介绍了 Kotlin `do-while`循环，我们还看到了它与 Kotlin `while`循环的不同之处。在下一个教程中，我们将介绍柯特林`for`循环。
在本教程中，我们通过代码示例介绍了 Kotlin `do-while`循环，我们还看到了它与 Kotlin `while`循环的不同之处。在下一个教程中，我们将介绍Kotlin`for`循环。
* * *
......
docs/mobi/074.md
浏览文件 @ b26ae976
# 科特林代表回路
# Kotlin代表回路
> 原文：<https://www.studytonight.com/kotlin/kotlin-for-loop>
在本教程中，我们将讨论柯特林中的`for`循环。Kotlin 不像 C、C++、Java 等，没有传统的`for`循环。，它将执行，直到条件返回**假**。科特林中的`for`循环类似于 Java 中的 [`forEach`循环。](https://www.studytonight.com/java-8/java-8-foreach)
在本教程中，我们将讨论Kotlin中的`for`循环。Kotlin 不像 C、C++、Java 等，没有传统的`for`循环。，它将执行，直到条件返回**假**。Kotlin中的`for`循环类似于 Java 中的 [`forEach`循环。](https://www.studytonight.com/java-8/java-8-foreach)
`for`循环用于迭代任何可以迭代的柯特林对象。我们可以迭代一个数组、集合、字符串、范围，或者任何可以借助`for`循环迭代的东西。
`for`循环用于迭代任何可以迭代的Kotlin对象。我们可以迭代一个数组、集合、字符串、范围，或者任何可以借助`for`循环迭代的东西。
## kot Lin〔t0〕回圈
......@@ -16,13 +16,13 @@ for (item in collection){
}
```
这里的`item`是变量，每个循环执行的值将存储在其中，而`collection`是我们正在迭代的柯特林对象。
这里的`item`是变量，每个循环执行的值将存储在其中，而`collection`是我们正在迭代的Kotlin对象。
柯特林中的`for`循环并不用于一次又一次地执行操作，而是用于迭代任何柯特林对象，如数组、列表或任何集合对象，以使用它们的元素执行一些操作。
Kotlin中的`for`循环并不用于一次又一次地执行操作，而是用于迭代任何Kotlin对象，如数组、列表或任何集合对象，以使用它们的元素执行一些操作。
## 科特林`for`循环示例
## Kotlin`for`循环示例
让我们看一个例子，在这个例子中，我们将在柯特林中迭代一个标记的**数组**:
让我们看一个例子，在这个例子中，我们将在Kotlin中迭代一个标记的**数组**:
```
fun main() {
......@@ -80,7 +80,7 @@ a
## 摘要
在本教程中，我们介绍了柯特林中的`for`循环。在下一个教程中，我们将讨论柯特林中的`range`以及如何在柯特林循环中使用`range`。
在本教程中，我们介绍了Kotlin中的`for`循环。在下一个教程中，我们将讨论Kotlin中的`range`以及如何在Kotlin循环中使用`range`。
* * *
......
docs/mobi/075.md
浏览文件 @ b26ae976
# 科特林山脉
# Kotlin山脉
> 原文：<https://www.studytonight.com/kotlin/kotlin-range>
在本教程中，我们将讨论柯特林中的`range`。在数学意义上，一个**范围是一系列数字、字符等。在限定的边界内**。边界点为**起点** & **终点**，两者都包含在范围内。`range`也可以有一个`step`(步骤用于**跳转数字**或字符，同时定义从开始到结束边界的范围)。
在本教程中，我们将讨论Kotlin中的`range`。在数学意义上，一个**范围是一系列数字、字符等。在限定的边界内**。边界点为**起点** & **终点**，两者都包含在范围内。`range`也可以有一个`step`(步骤用于**跳转数字**或字符，同时定义从开始到结束边界的范围)。
我们可以借助 Kotlin 中的`rangeTo()`功能或者使用`..`运算符来创建一个范围。
## 科特林:创建一个范围
## Kotlin:创建一个范围
如上所述，我们可以使用`..`运算符和`rangeTo()`函数，让我们一个接一个地讨论它们。
### 使用`..`运算符的柯特林范围:
### 使用`..`运算符的Kotlin范围:
让我们使用`..`操作符创建一个从 **1 到 9 的**。
......@@ -22,7 +22,7 @@ val range = 1..9
唯一的缺点是，我们不能用我们跳过/跳转数字的模式创建一个范围，例如，如果您想创建一个 1、3、5、7 等数字的**范围。跳一号**，或者 **1、4、7、10 等。跳跃两个数字**。
### 使用`rangeTo()`运算符的柯特林范围:
### 使用`rangeTo()`运算符的Kotlin范围:
我们也可以使用`rangeTo()`功能来创建范围。这是一个基本的例子:
......@@ -60,7 +60,7 @@ var digit = 0..9 // Range for digits
这样我们就可以根据我们的要求轻松地定义不同类型的范围。
## 科特林步幅
## Kotlin步幅
要定义一个范围内两个连续值之间的距离，我们可以使用`step()`函数。例如，要用 2 的`step`打印 1 到 10 的数字，我们可以将范围写成:
......@@ -86,7 +86,7 @@ fun main() {
同样，我们可以为`step`函数提供任何数字作为参数，并基于此创建我们的范围变量。
## 柯特林`downTo()`功能
## Kotlin`downTo()`功能
如果我们想按**相反的顺序**打印数字，即从 10 到 1，我们**不能使用** `rangeTo()`功能或`..`运算符。如果我们试着像下面的代码一样使用它们，它不会打印任何东西，因为默认步骤是 **1** ，并且它只会向前进行。
......
docs/mobi/076.md
浏览文件 @ b26ae976
# 科特林继续，打破和重复声明
# Kotlin继续，打破和重复声明
> 原文：<https://www.studytonight.com/kotlin/kotlin-continue-break-and-repeat-statement>
在本教程中，我们将讨论柯特林中的`continue`、`break`和`repeat`语句。这些语句在 Kotlin 循环中用于管理循环的执行流程，例如，如果您想跳过一个迭代，或脱离循环或重复一个迭代，那么可以使用这些语句。
在本教程中，我们将讨论Kotlin中的`continue`、`break`和`repeat`语句。这些语句在 Kotlin 循环中用于管理循环的执行流程，例如，如果您想跳过一个迭代，或脱离循环或重复一个迭代，那么可以使用这些语句。
在本教程中，我们将通过示例介绍所有这三个方面。
## 科特林`continue`声明
## Kotlin`continue`声明
`continue`语句用于**跳过循环**的当前迭代，**从下一个**迭代开始。它主要与`if`表达式一起使用，根据条件决定是否跳过循环的当前迭代。
......@@ -42,7 +42,7 @@ fun main() {
在嵌套循环的情况下，最里面的循环将遵循`continue`语句。
## 科特林`break`声明
## Kotlin`break`声明
`break`语句用于**停止循环**的执行，执行退出或跳出循环。它还与`if`表达式一起使用，根据特定条件中断循环。
......@@ -83,7 +83,7 @@ fun main() {
*在嵌套循环的情况下，`break`语句将断开最里面的循环。因此，您将需要多个`break`语句来分解或嵌套循环，这取决于循环的数量。
## 科特林`repeat`声明
## Kotlin`repeat`声明
`repeat`语句类似于 Kotlin 中的循环。它被用来重复一个任务多次，就像循环一样。
......
docs/mobi/078.md
浏览文件 @ b26ae976
# 科特林字符串
# Kotlin字符串
> 原文：<https://www.studytonight.com/kotlin/kotlin-string>
在本教程中，我们将向您介绍柯特林字符串，包括柯特林字符串类、其属性和函数以及代码示例。
在本教程中，我们将向您介绍Kotlin字符串，包括Kotlin字符串类、其属性和函数以及代码示例。
字符串是组合在一起的**字符数组**。字符串通常使用**双引号** **`""`** 创建。我们也可以使用**三重引号** **`"""`** 创建**多行字符串**。这根弦也被称为**生**弦。
......@@ -26,13 +26,13 @@ fun main() {
String 类包含许多属性和方法，用于管理 Kotlin 字符串并对其执行操作。一些重要的属性和功能是:
### 科特林字符串属性:
### Kotlin字符串属性:
* `length`:表示字符串的长度。
* `lastIndex`:表示字符串中最后一个字符的索引。
### 柯特林字符串方法:
### Kotlin字符串方法:
* `get(index)`:返回字符串中**指定索引**处的**字符**或者抛出`IndexOutOfBoundsException`。
......@@ -99,7 +99,7 @@ fun main() {
小写留言:你好世界！！
大写信息:你好世界！！
不要被语法`${ .. }`搞糊涂了，它是用来在柯特林的 println [输出中追加一个变量值的。](https://www.studytonight.com/kotlin/kotlin-input-and-output)
不要被语法`${ .. }`搞糊涂了，它是用来在Kotlin的 println [输出中追加一个变量值的。](https://www.studytonight.com/kotlin/kotlin-input-and-output)
## 字符串模板
......@@ -127,7 +127,7 @@ fun main() {
## 摘要
在本教程中，我们讨论了柯特林字符串、它的属性和方法。当我们编写实际程序时，字符串非常有用，当您使用 Kotlin 开发您的安卓应用时，所有这些方法都会派上用场。在下一个教程中，我们将讨论科特林阵列。
在本教程中，我们讨论了Kotlin字符串、它的属性和方法。当我们编写实际程序时，字符串非常有用，当您使用 Kotlin 开发您的安卓应用时，所有这些方法都会派上用场。在下一个教程中，我们将讨论Kotlin阵列。
* * *
......
docs/mobi/079.md
浏览文件 @ b26ae976
# 科特林阵列
# Kotlin阵列
> 原文：<https://www.studytonight.com/kotlin/kotlin-array>
在本教程中，我们将讨论科特林阵列。**数组是数据类型**的集合。在大多数语言中，数组元素应该是相同的数据类型，但是在科特林中，我们可以有包含不同数据类型的数据的**数组。意思是，我们可以存储**整数、字符串、字符等。在同一个阵列中**。**
在本教程中，我们将讨论Kotlin阵列。**数组是数据类型**的集合。在大多数语言中，数组元素应该是相同的数据类型，但是在Kotlin中，我们可以有包含不同数据类型的数据的**数组。意思是，我们可以存储**整数、字符串、字符等。在同一个阵列中**。**
数组的属性有:
......@@ -12,7 +12,7 @@
* 数组是**可变的**，因为数组元素在声明后可以改变。
在柯特林中，可以使用`Array<T>`类和一些柯特林函数来创建数组。我们将首先看到如何使用函数创建**数组，然后我们将看到如何使用`Array`类创建。**
在Kotlin中，可以使用`Array<T>`类和一些Kotlin函数来创建数组。我们将首先看到如何使用函数创建**数组，然后我们将看到如何使用`Array`类创建。**
## 使用函数创建数组
......@@ -77,7 +77,7 @@ var booleanArray = booleanArrayOf(true, false, true)
## 使用数组类创建数组
可以使用`Array`类的构造函数创建柯特林数组。构造函数需要两个参数:第一个是数组的`size`，第二个是`init`函数。`init`功能用于初始化阵列:
可以使用`Array`类的构造函数创建Kotlin数组。构造函数需要两个参数:第一个是数组的`size`，第二个是`init`函数。`init`功能用于初始化阵列:
```
var numbers = Array(3, init = {
......@@ -131,7 +131,7 @@ fun main() {
### 获取数组的大小
柯特林数组的大小可以通过其`size`属性找到:
Kotlin数组的大小可以通过其`size`属性找到:
```
fun main() {
......
docs/mobi/080.md
浏览文件 @ b26ae976
# 柯特林函数
\ No newline at end of file
# Kotlin函数
\ No newline at end of file
docs/mobi/081.md
浏览文件 @ b26ae976
# 科特林用户定义函数
# Kotlin用户定义函数
> 原文：<https://www.studytonight.com/kotlin/kotlin-userdefined-functions>
在本教程中，我们将讨论柯特林函数，包括柯特林库函数和用户定义函数。函数用于将巨大的单片代码分解成可重用的更小的代码块。理想情况下，我们应该**为单个任务**创建一个函数。函数也**增加了代码的可重用性**因为一旦被编写，函数可以在需要的时候被多次调用。
在本教程中，我们将讨论Kotlin函数，包括Kotlin库函数和用户定义函数。函数用于将巨大的单片代码分解成可重用的更小的代码块。理想情况下，我们应该**为单个任务**创建一个函数。函数也**增加了代码的可重用性**因为一旦被编写，函数可以在需要的时候被多次调用。
功能可以有两种类型:
......@@ -10,9 +10,9 @@
2. 用户定义的函数
标准库函数由 Kotlin 标准库提供，可以直接使用。我们已经使用了许多标准库函数，如:`print()`、`println()`、`main()`、`arrayOf()`等。您可以在这里探索更多关于科特林标准库[的信息。现在，我们将看到如何创建用户定义的函数。](https://kotlinlang.org/api/latest/jvm/stdlib/)
标准库函数由 Kotlin 标准库提供，可以直接使用。我们已经使用了许多标准库函数，如:`print()`、`println()`、`main()`、`arrayOf()`等。您可以在这里探索更多关于Kotlin标准库[的信息。现在，我们将看到如何创建用户定义的函数。](https://kotlinlang.org/api/latest/jvm/stdlib/)
## 科特林用户定义函数
## Kotlin用户定义函数
顾名思义，用户定义的功能是由**用户**创建的。Kotlin 中的函数是使用`fun`关键字创建的。函数的语法是:
......@@ -66,11 +66,11 @@ fun getSquare(number: Int): Int {
* 我们还可以定义不返回任何内容的函数，这将在本教程的下一节中介绍。
## 不返回任何内容的柯特林函数
## 不返回任何内容的Kotlin函数
我们可以定义在柯特林中返回任何东西的函数。有三种不同的方法。
我们可以定义在Kotlin中返回任何东西的函数。有三种不同的方法。
### 无返回类型的柯特林函数:
### 无返回类型的Kotlin函数:
如果函数没有返回任何东西，那么就不需要提到返回类型:
......@@ -88,7 +88,7 @@ fun getSquare(number: Int) {
}
```
### 带有`Unit`返回类型的柯特林函数:
### 带有`Unit`返回类型的Kotlin函数:
如果我们想指定返回类型，我们可以添加`Unit`作为不返回任何有意义的函数的返回类型。类似于 Java 中的**虚空。如果没有提到任何返回类型，也没有从函数中返回任何值，那么默认情况下，返回类型被认为是`Unit`。**
......@@ -100,7 +100,7 @@ fun sayHello(): Unit{
}
```
### 带有`Nothing`返回类型的柯特林函数:
### 带有`Nothing`返回类型的Kotlin函数:
在 Kotlin 中，Nothing 是一种特殊类型，它也可以用作用户定义函数的返回类型，用于不返回任何内容的函数。或者，我们可以说，以`Nothing`为返回类型的函数，**从不返回任何东西**，甚至不是默认的`Unit`类型。
......@@ -143,7 +143,7 @@ fun setReturnTypeVoid() : Void {
错误:Kotlin: Null 不能是非 Null 类型的值 Void
看这也行不通。为什么呢？因为柯特林没有将`Void`视为**空类型**，所以提供`return null`语句会产生编译错误。\
看这也行不通。为什么呢？因为Kotlin没有将`Void`视为**空类型**，所以提供`return null`语句会产生编译错误。\
但是在 Kotlin 中，我们可以通过使用`?`运算符使函数返回类型为可空的。
......
docs/mobi/082.md
浏览文件 @ b26ae976
# 柯特林递归函数
# Kotlin递归函数
> 原文：<https://www.studytonight.com/kotlin/kotlin-recursive-functions>
在本教程中，我们将讨论柯特林递归函数。柯特林中的一个[函数**不断地调用自己**被称为**递归函数**。这个概念并不是科特林的母语，而是存在于所有语言中。递归函数可以看作一个循环，但两者并不完全相同。](https://www.studytonight.com/kotlin/kotlin-userdefined-functions)
在本教程中，我们将讨论Kotlin递归函数。Kotlin中的一个[函数**不断地调用自己**被称为**递归函数**。这个概念并不是Kotlin的母语，而是存在于所有语言中。递归函数可以看作一个循环，但两者并不完全相同。](https://www.studytonight.com/kotlin/kotlin-userdefined-functions)
递归函数必须有**中断条件**才能停止递归；**否则它将无限期运行**。中断条件主要基于传递给函数的参数。
......@@ -70,7 +70,7 @@ fun factorial(n: Int): Int{
## 摘要
在本教程中，我们讨论了递归函数以及如何在 Kotlin 中实现同样的功能。您可以搜索更多关于递归函数及其用法的信息。在下一个教程中，我们将讨论柯特林中的参数类型。
在本教程中，我们讨论了递归函数以及如何在 Kotlin 中实现同样的功能。您可以搜索更多关于递归函数及其用法的信息。在下一个教程中，我们将讨论Kotlin中的参数类型。
* * *
......
docs/mobi/083.md
浏览文件 @ b26ae976
......@@ -2,9 +2,9 @@
> 原文：<https://www.studytonight.com/kotlin/kotlin-positional-default-and-named-function-arguments>
在本教程中，我们将讨论柯特林函数中不同类型的参数。参数是调用函数时传递给函数的值。
在本教程中，我们将讨论Kotlin函数中不同类型的参数。参数是调用函数时传递给函数的值。
在柯特林中，有多种类型的参数可以在声明和调用[柯特林用户定义函数](https://www.studytonight.com/kotlin/kotlin-userdefined-functions)时使用。它们是:
在Kotlin中，有多种类型的参数可以在声明和调用[Kotlin用户定义函数](https://www.studytonight.com/kotlin/kotlin-userdefined-functions)时使用。它们是:
1. 位置参数
......@@ -14,7 +14,7 @@
最后我们还会看到什么是`vararg`。
## 柯特林位置论点
## Kotlin位置论点
这些是任何语言中存在的基本类型的参数。这些是基于位置的参数。第一个参数对应函数定义中的第一个参数，第二个参数对应第二个参数，依此类推。
......@@ -31,7 +31,7 @@ fun printInfo(name: String, age: Int) {
在上面的代码中，`"Groot"`和`2`是`name`和`age`功能参数的位置参数。如果我们先试着颠倒他们的位置，即`2`后试着颠倒`"Groot"`，这在位置论证中是行不通的。我们可以通过使用命名参数来实现这一点。
## 科特林默认参数
## Kotlin默认参数
默认参数用于为函数参数提供**默认值。考虑这样一种情况:如果用户在调用函数时没有传递任何值，我们希望为函数参数指定一个默认值，那么将使用默认值。我们可以使用默认参数来实现这一点。**
......@@ -84,7 +84,7 @@ printInfo(10) // ERROR
这是因为编译器会尝试将第一个参数即`10`与**第一个参数** `name`进行映射。为了实现这种功能，我们将使用命名参数。
## 柯特林命名论证
## Kotlin命名论证
在调用函数时，我们可以使用参数的名称来指定特定参数的特定参数。这些类型的参数被称为**命名参数**。
......@@ -143,7 +143,7 @@ fun findSum(vararg numbers: Int): Int {
## 摘要
在本教程中，我们讨论了各种类型的参数及其用法。我们还讨论了科特林中的 **varargs。在下一个教程中，我们将讨论 Kotlin 中的 Lambda 函数/表达式。**
在本教程中，我们讨论了各种类型的参数及其用法。我们还讨论了Kotlin中的 **varargs。在下一个教程中，我们将讨论 Kotlin 中的 Lambda 函数/表达式。**
* * *
......
docs/mobi/084.md
浏览文件 @ b26ae976
......@@ -2,7 +2,7 @@
> 原文：<https://www.studytonight.com/kotlin/kotlin-lambda-expression>
在本教程中，我们将讨论柯特林中的**λ表达式**。Lambda 函数或表达式在 Kotlin 中并不新鲜，在 Python、Java 和 Javascript 等许多其他语言中都存在。
在本教程中，我们将讨论Kotlin中的**λ表达式**。Lambda 函数或表达式在 Kotlin 中并不新鲜，在 Python、Java 和 Javascript 等许多其他语言中都存在。
Lambda 函数类似于匿名函数。一个**匿名函数**是一个没有名字的函数。基本上，Lambda 表达式是一种简洁地创建函数并将它们作为参数传递、返回等的方式。我们可以称它们为简单函数。
......@@ -32,7 +32,7 @@ val nameOfLambda : DataType = { argruments -> bodyOfLambdaFunction }
让我们举几个代码示例。
### 柯特林λ表达式-示例 1:
### Kotlinλ表达式-示例 1:
让我们从创建一个简单的 lambda 开始，它打印一个字符串:
......@@ -52,7 +52,7 @@ fun main() {
在这个例子中，参数和返回类型被删除了。
### 柯特林λ表达式-示例 2:
### Kotlinλ表达式-示例 2:
让我们创建另一个寻找矩形区域的例子:
......@@ -73,9 +73,9 @@ fun main() {
这里返回类型自动推断为`Int`。
## *它在柯特林λ表达式中*
## *它在Kotlinλ表达式中*
如果 lambda 表达式中只有一个参数，则可以用`it`关键字替换它。这是柯特林使用的速记，非常有用。`it`关键字将代表传递给 lambda 函数的单个参数。
如果 lambda 表达式中只有一个参数，则可以用`it`关键字替换它。这是Kotlin使用的速记，非常有用。`it`关键字将代表传递给 lambda 函数的单个参数。
让我们创建一个数组，并使用`forEach`循环打印其中元素的方块:
......
docs/mobi/085.md
浏览文件 @ b26ae976
# 柯特林高阶函数
# Kotlin高阶函数
> 原文：<https://www.studytonight.com/kotlin/kotlin-higher-order-function>
在上一个教程中，我们讨论了 Kotlin lambda 函数。在本教程中，我们将前进一步，讨论柯特林中的**高阶函数。**
在上一个教程中，我们讨论了 Kotlin lambda 函数。在本教程中，我们将前进一步，讨论Kotlin中的**高阶函数。**
科特林认为它的功能是作为一级公民。它允许一个函数被**用作变量**。因此，一个函数可以作为参数传递给另一个函数，从一个函数返回，存储在变量或数据结构中，等等。
Kotlin认为它的功能是作为一级公民。它允许一个函数被**用作变量**。因此，一个函数可以作为参数传递给另一个函数，从一个函数返回，存储在变量或数据结构中，等等。
## 柯特林高阶函数
## Kotlin高阶函数
将另一个函数作为自变量或返回一个函数的函数称为**高阶函数**。lambda 表达式通常作为参数传递给高阶函数，或者从高阶函数返回。匿名函数也可以用于同样的目的。
我们将看到一些例子，其中我们将传递函数和 lambdas 作为参数，或者从另一个函数返回它们。
## 柯特林函数作为参数
## Kotlin函数作为参数
在本例中，函数`sayHello()`作为参数传递给`higherOrderFunction()`，并从`main()`函数调用:
......@@ -54,7 +54,7 @@ fun main() {
* T **o 传递一个函数作为参数**我们使用`::`运算符。我们从`main()`调用`higherOrderFunction()`函数，并通过`sayHello()`作为参数。
## 作为返回值的柯特林函数
## 作为返回值的Kotlin函数
在本例中，我们将从`higherOrderFunction()`函数返回`sayHello()`函数。
......@@ -90,7 +90,7 @@ fun main() {
* 返回的函数存储在`functionName`变量中。用`functionName("Ninja")`叫，和叫`sayHello("Ninja")`一样。
## 柯特林·拉姆达作为论据
## Kotlin·拉姆达作为论据
大多数情况下，我们传递[λ表达式](https://www.studytonight.com/kotlin/kotlin-lambda-expression)作为参数或者返回它，而不是函数。让我们看看我们讨论过的相同的例子，但这次我们将使用 lambdas。
......@@ -139,7 +139,7 @@ fun main() {
## 摘要
在本教程中，我们用多个例子讨论了柯特林高阶函数。在下一个教程中，我们将讨论柯特林中的内联函数。
在本教程中，我们用多个例子讨论了Kotlin高阶函数。在下一个教程中，我们将讨论Kotlin中的内联函数。
* * *
......
docs/mobi/086.md
浏览文件 @ b26ae976
# 柯特林内嵌关键字
# Kotlin内嵌关键字
> 原文：<https://www.studytonight.com/kotlin/kotlin-inline-keyword>
在本教程中，我们将使用`inline`关键字讨论柯特林中的内联函数。内联函数帮助我们在运行时节省内存，从而提高应用的性能。
在本教程中，我们将使用`inline`关键字讨论Kotlin中的内联函数。内联函数帮助我们在运行时节省内存，从而提高应用的性能。
在之前的教程中，我们讨论了 lambda 表达式和高阶函数。让我们举同一个例子:
......@@ -20,13 +20,13 @@ fun main() {
}
```
在 IntelliJ 中，我们可以生成我们的 Kotlin 程序的字节码。为此，请转到**工具>科特林>显示科特林字节码**。我们可以反编译这个字节码，生成等价的 Java 代码。
在 IntelliJ 中，我们可以生成我们的 Kotlin 程序的字节码。为此，请转到**工具>Kotlin>显示Kotlin字节码**。我们可以反编译这个字节码，生成等价的 Java 代码。
我们将观察到，对于λ表达式，创建了一个新的函数对象。但这不是我们想要的。
每个高阶函数将**创建一个新对象，并为其分配内存**。这会**增加运行时间开销**。为了克服这个问题，我们**使用内联函数**。
## 柯特林内联函数
## Kotlin内联函数
为了避免为每个高阶函数创建新对象，我们可以使用`inline`关键字。它将帮助我们提高代码的性能。`inline`关键字不是为高阶函数创建新对象，而是将内联函数内部的代码复制到调用它的地方。
......
docs/mobi/088.md
浏览文件 @ b26ae976
# 柯特林类和对象
# Kotlin类和对象
> 原文：<https://www.studytonight.com/kotlin/kotlin-class-and-object>
......@@ -24,7 +24,7 @@
该类用于创建对象的**蓝图。让我们继续这个例子，下面我们将定义一个名为**移动**的类，在其中我们将定义它的所有属性和方法，然后我们将创建该类的对象，这些属性有不同的值。把对象看成不同公司提供的手机，或者不同型号的手机，像 **iPhone 11 Pro** 可以是一个对象，**三星 Galaxy S 20** 可以是另一个有自己配置的对象，然后**一加 7** 等等。**
## 科特林班
## Kotlin班
使用`class`关键字定义一个类。创建类的语法是:
......@@ -35,7 +35,7 @@ class <class-name> // class header
}
```
柯特林课程有两个主要部分:
Kotlin课程有两个主要部分:
* **类头**:包含类名、主构造函数、父构造函数等。(我们将在后续教程中了解构造函数)
......@@ -87,13 +87,13 @@ class Mobile {
我们已经创建了一个包含属性和方法的基本类。
关于科特林课程的要点是:
关于Kotlin课程的要点是:
* 属性必须在创建对象时**初始化。我们已经将`brand` & `model`初始化为空字符串，并将`mrp` & `discount`初始化为 **0** 作为默认值。**
* 默认情况下，科特林中的类是**公共的**。
* 默认情况下，Kotlin中的类是**公共的**。
## 柯特林类对象
## Kotlin类对象
对象是真实世界的实体。它拥有类中声明的所有属性和方法。声明类的对象的语法是:
......
docs/mobi/089.md
浏览文件 @ b26ae976
# 柯特林构造函数-主构造函数和辅助构造函数
# Kotlin构造函数-主构造函数和辅助构造函数
> 原文：<https://www.studytonight.com/kotlin/kotlin-constructor-primary-and-secondary-constructor>
......@@ -12,9 +12,9 @@ Kotlin 中有两种类型的构造函数:
只能有**一个一级建造师****多个二级建造师**。
## 柯特林主构造函数
## Kotlin主构造函数
柯特林最重要的特点之一是简洁。从主构造函数的声明可以看出。主构造函数是类头的一部分。类的所有属性也成为了主构造函数的一部分。
Kotlin最重要的特点之一是简洁。从主构造函数的声明可以看出。主构造函数是类头的一部分。类的所有属性也成为了主构造函数的一部分。
通过在类名末尾添加`constructor()`来创建主构造函数:
......@@ -141,7 +141,7 @@ MRP: 100000.0
* 一个类可以有多个`init`块。
## 科特林二级建造师
## Kotlin二级建造师
辅助构造函数用于初始化一组值。使用`constructor`关键字创建辅助构造函数。一个类可以有**一个或多个二级构造函数**。
......
docs/mobi/090.md
浏览文件 @ b26ae976
# 柯特林伴物体
# Kotlin伴物体
> 原文：<https://www.studytonight.com/kotlin/kotlin-companion-object>
......@@ -60,7 +60,7 @@ I 值:2
## 摘要
在本教程中，我们讨论了 Kotlin 中的伴随对象。它们可以被认为是 Java `static`关键字的替换。它们在创建类时会派上用场。在下一个教程中，我们将讨论科特林中的获取者和设置者。
在本教程中，我们讨论了 Kotlin 中的伴随对象。它们可以被认为是 Java `static`关键字的替换。它们在创建类时会派上用场。在下一个教程中，我们将讨论Kotlin中的获取者和设置者。
* * *
......
docs/mobi/091.md
浏览文件 @ b26ae976
......@@ -32,7 +32,7 @@ Getter 和 Setter 是由 Kotlin 为每个类属性默认生成的函数**。它
最好不要将类的变量暴露在它之外。如果您来自 Java，那么您必须已经将类属性声明为私有，并为其创建了 getter 和 setter 方法。默认情况下，Kotlin 提供此功能。
## 科特林的吸气剂和设置剂
## Kotlin的吸气剂和设置剂
默认`get()`和`set()`功能如下:
......@@ -50,7 +50,7 @@ class Person{
用`var`声明的属性同时具有`get()`和`set()`功能。但是用`val`声明的属性只有`get()`功能。这是因为`val`的值不能重新分配。
`field`关键字用于表示变量。`value`用于表示要分配给变量的值。它也可以改变。这些`get()`和`set()`功能是多余的，因为科特林默认提供它们。
`field`关键字用于表示变量。`value`用于表示要分配给变量的值。它也可以改变。这些`get()`和`set()`功能是多余的，因为Kotlin默认提供它们。
## 定义自定义获取器和设置器
......
docs/mobi/092.md
浏览文件 @ b26ae976
# 柯特林访问修饰符
# Kotlin访问修饰符
> 原文：<https://www.studytonight.com/kotlin/kotlin-access-modifiers>
在本教程中，我们将介绍柯特林中的可见性修改器或访问修改器。访问修饰符或可见性修饰符用于定义类、函数、字段、接口等的范围。可见性修饰符关键字限制类、函数、属性等的使用，并声明它们是否在它们的子类、其他文件、类、其他包中可用。
在本教程中，我们将介绍Kotlin中的可见性修改器或访问修改器。访问修饰符或可见性修饰符用于定义类、函数、字段、接口等的范围。可见性修饰符关键字限制类、函数、属性等的使用，并声明它们是否在它们的子类、其他文件、类、其他包中可用。
在 Kotlin 中，可见性修饰符可以应用于类、构造函数、对象、接口、函数、属性及其设置器。Getters 与属性具有相同的可见性。
......@@ -22,7 +22,7 @@ Kotlin 中有四个可见性修饰符:
## 顶级字段的可见性修饰符
顶级字段是放置在类或接口之外的字段。它们直接存在于任何科特林文件中。
顶级字段是放置在类或接口之外的字段。它们直接存在于任何Kotlin文件中。
对于顶级字段，不同的可见性修饰符意味着:
......
docs/mobi/093.md
浏览文件 @ b26ae976
# 科特林遗产
# Kotlin遗产
> 原文：<https://www.studytonight.com/kotlin/kotlin-inheritance>
......@@ -14,9 +14,9 @@
继承允许新类继承现有类的属性和方法。现有类或继承新类的类称为**基类**或**父类**或**超类**。继承已有类特征的新类称为**派生类**或**子类**或**子类**。
## 科特林的遗产
## Kotlin的遗产
科特林的所有职业默认都是**`final`。这意味着这些**职业是不可继承的**。为了使类可继承，我们在类头中添加`open`关键字。**
Kotlin的所有职业默认都是**`final`。这意味着这些**职业是不可继承的**。为了使类可继承，我们在类头中添加`open`关键字。**
**子类使用`:`运算符继承父类。继承类的**语法是:**
......@@ -134,11 +134,11 @@ fun main() {
在本例中，`Truck`类的二级构造函数使用`super`关键字调用`Vehicle`类的二级构造函数。通过`super`调用时，会提供父类所需的所有参数。
## 柯特林函数覆盖
## Kotlin函数覆盖
在继承中，我们可以在派生类中提供基类函数的具体实现。这意味着如果一个函数存在于父类中，那么我们可以**在子类**中提供相同函数的不同实现。被称为**功能超越**。
在科特林中，默认情况下功能也是`final`**。要覆盖一个函数，它必须在父类中标记为`open`(就像类一样)，在子类中，我们必须使用关键字`override`而不是`open`来指定我们已经覆盖了该函数。**
在Kotlin中，默认情况下功能也是`final`**。要覆盖一个函数，它必须在父类中标记为`open`(就像类一样)，在子类中，我们必须使用关键字`override`而不是`open`来指定我们已经覆盖了该函数。**
****功能名称和参数应相同**。
......@@ -184,7 +184,7 @@ fun main() {
我们也可以使用`super`关键字在子类内部调用父类函数。
## 柯特林覆盖属性
## Kotlin覆盖属性
同样，我们也可以覆盖属性并**在子类**中更改它们的值。属性应该标记为`open`以便覆盖它们，并且当我们覆盖属性时，在子类中使用`override`关键字，就像我们覆盖类函数一样。
......@@ -216,7 +216,7 @@ fun main() {
## 摘要
在本教程中，我们讨论了 Kotlin 中的继承、如何在类中创建父子关系、构造函数在 inheritance 期间的行为以及方法和属性重写。在下一个教程中，我们将讨论科特林中的抽象类。
在本教程中，我们讨论了 Kotlin 中的继承、如何在类中创建父子关系、构造函数在 inheritance 期间的行为以及方法和属性重写。在下一个教程中，我们将讨论Kotlin中的抽象类。
* * *
......
docs/mobi/094.md
浏览文件 @ b26ae976
# 柯特林抽象类
# Kotlin抽象类
> 原文：<https://www.studytonight.com/kotlin/kotlin-abstract-class>
......@@ -14,7 +14,7 @@
然后如果类像`Square`、`Rectangle`、`Circle`等。继承`Shape`类，这些类必须覆盖`area()`函数，否则编译器会抛出错误。
## 科特林抽象类
## Kotlin抽象类
如果一个类的任何功能都标有`abstract`关键字，那么这个类也应该标有`abstract`关键字。让我们首先看一个抽象类的基本例子:
......
docs/mobi/095.md
浏览文件 @ b26ae976
# 科特林界面
# Kotlin界面
> 原文：<https://www.studytonight.com/kotlin/kotlin-interface>
......@@ -12,7 +12,7 @@
这使得接口和抽象类非常相似。抽象类和接口的关键区别是:**一个类只能继承一个抽象类**，但是它**可以继承很多接口**。如果需要继承多个类，那么我们可以选择接口。
## 科特林界面
## Kotlin界面
在 Kotlin 中定义接口的语法是:
......@@ -28,7 +28,7 @@ interface A{
默认情况下，接口的所有属性和功能都是抽象的，除非我们提供它们的实现。
## 科特林:实现接口
## Kotlin:实现接口
接口也是使用用于继承类的相同`:`运算符继承的。让我们创建一个继承接口`A`和`B`的类`C`:
......
docs/mobi/096.md
浏览文件 @ b26ae976
# 科特林嵌套类和内部类
# Kotlin嵌套类和内部类
> 原文：<https://www.studytonight.com/kotlin/kotlin-nested-and-inner-class>
在本教程中，我们将讨论在科特林的另一个类中**创建类的两种方法，第一种是科特林**嵌套类**，另一种是科特林**内部类**。**
在本教程中，我们将讨论在Kotlin的另一个类中**创建类的两种方法，第一种是Kotlin**嵌套类**，另一种是Kotlin**内部类**。**
## 科特林嵌套类
## Kotlin嵌套类
我们可以直接在另一个类中创建一个嵌套类。默认情况下，嵌套类本质上是**静态的**。这意味着我们可以使用嵌套类的属性和函数，而无需创建外部类的对象。可以使用`.`运算符直接访问它们。
......@@ -33,7 +33,7 @@ val obj = Outer.Nested()
我们可以使用外部类名创建嵌套类的对象。
### 科特林嵌套类示例:
### Kotlin嵌套类示例:
让我们举个例子，
......@@ -63,7 +63,7 @@ fun main() {
狗有尾巴:真
狗说:汪汪
## 科特林内班
## Kotlin内班
Kotlin 内部类是使用`inner`关键字创建的。可以认为是**特殊嵌套类**。
......@@ -96,7 +96,7 @@ val innerObj = outerObj.Inner()
正如您在上面的语法中看到的，我们首先创建外部类的对象，然后使用它来创建内部类的对象。
### 柯特林内部类示例:
### Kotlin内部类示例:
让我们举个例子，
......@@ -136,7 +136,7 @@ fun main() {
## 摘要
在本教程中，我们讨论了 Kotlin 嵌套类和内部类。我们还介绍了如何从`main()`功能访问他们的成员。在下一个教程中，我们将介绍科特林的数据类。
在本教程中，我们讨论了 Kotlin 嵌套类和内部类。我们还介绍了如何从`main()`功能访问他们的成员。在下一个教程中，我们将介绍Kotlin的数据类。
* * *
......
docs/mobi/097.md
浏览文件 @ b26ae976
# 科特林数据类
# Kotlin数据类
> 原文：<https://www.studytonight.com/kotlin/kotlin-data-class>
在本教程中，我们将介绍柯特林中**数据类**的概念。在每个项目中，我们需要一些类，它们的**唯一目的是存储数据**。这些类被称为**数据类**或**数据访问对象**或**数据传输对象**等。
在本教程中，我们将介绍Kotlin中**数据类**的概念。在每个项目中，我们需要一些类，它们的**唯一目的是存储数据**。这些类被称为**数据类**或**数据访问对象**或**数据传输对象**等。
数据类主要包含:
......@@ -63,7 +63,7 @@ public class Person {
写这段代码真的很烦人，因为它只是保存数据并提供管理数据的实用功能。Kotlin 通过引入**数据类**解决了这个问题。
## 科特林数据类
## Kotlin数据类
使用`data`关键字创建数据类。默认情况下，Kotlin 数据类提供:
......@@ -83,7 +83,7 @@ public class Person {
data class Person(var name: String, var gender: String, var age: Int)
```
仅此而已。这是柯特林简洁的一个很好的例子。
仅此而已。这是Kotlin简洁的一个很好的例子。
让我们**创建一个这个类的对象**并打印出来:
......@@ -126,7 +126,7 @@ fun main() {
当我们使用`copy()`函数从任何对象复制单个属性值时，我们应该使用[命名参数](https://www.studytonight.com/kotlin/kotlin-positional-default-and-named-function-arguments)，否则该值可能会被分配给其他变量。
## 柯特林数据类:`hashCode`和`equals`函数
## Kotlin数据类:`hashCode`和`equals`函数
`equals()`和`hashCode()`功能用于检查**两个物体是否相等**。`hashCode()`生成一个对象的哈希值。如果两个对象的所有对应值相等，则两个对象的哈希值相同。`equals()`功能也用于检查两个物体是否相等。
......@@ -153,7 +153,7 @@ fun main() {
## 析构数据类对象- `componentN()`函数
如果我们想把一个对象的属性映射成独立变量，那么这是一个乏味的任务。在柯特林中，我们可以使用 ***销毁声明*** 来销毁一个对象并获取其在自变量中的属性。让我们把`man`物体破坏成独立的变量:
如果我们想把一个对象的属性映射成独立变量，那么这是一个乏味的任务。在Kotlin中，我们可以使用 ***销毁声明*** 来销毁一个对象并获取其在自变量中的属性。让我们把`man`物体破坏成独立的变量:
```
fun main() {
......@@ -179,7 +179,7 @@ man.component3() // 18
## 摘要
至此，本教程结束。在本教程中，我们了解了 Kotlin 数据类及其提供的功能。Kotlin 数据类减少了样板代码，并提供了 getter、setter、toString、equals 等。自动通用功能。在下一个教程中，我们将讨论科特林中的枚举。
至此，本教程结束。在本教程中，我们了解了 Kotlin 数据类及其提供的功能。Kotlin 数据类减少了样板代码，并提供了 getter、setter、toString、equals 等。自动通用功能。在下一个教程中，我们将讨论Kotlin中的枚举。
* * *
......
docs/mobi/098.md
浏览文件 @ b26ae976
# 科特林枚举
# Kotlin枚举
> 原文：<https://www.studytonight.com/kotlin/kotlin-enum>
在本教程中，我们将了解 Kotlin Enum。在开发应用时，可能会出现这样一种情况，即我们希望一个变量只具有一组给定的允许值，例如，如果我们有一个变量`pizzaSize`，那么它应该具有以下值:小、中、大。
在科特林和 Java 中，枚举帮助我们实现了这一点。
在Kotlin和 Java 中，枚举帮助我们实现了这一点。
在 Kotlin 中，我们可以借助`enum`关键字创建一个**枚举类**。Kotlin 枚举可以有**属性**、**功能**，可以**实现接口**等。
## 科特林枚举类
## Kotlin枚举类
让我们创建一个包含比萨饼大小的简单枚举类:
......@@ -31,7 +31,7 @@ fun main() {
每个枚举常数充当一个单独的对象。它们用逗号隔开。在上例中，`SMALL`、`MEDIUM`和`LARGE`为对象。
## 科特林枚举:初始化常数
## Kotlin枚举:初始化常数
在 Kotlin 枚举中可以有**主构造函数**。因为枚举中的常量是实例，所以可以通过向构造函数传递值来初始化它们:
......@@ -58,7 +58,7 @@ fun main() {
正如您在上面的示例中所看到的，我们在枚举类中包含了更多的数据，并将其与枚举实例相关联。同样，如果我们愿意，我们可以添加更多的信息。
## 科特林枚举:实现接口
## Kotlin枚举:实现接口
在 Kotlin 中，我们甚至可以在枚举类中实现一个接口。**常量分别覆盖**界面功能**:**
......
docs/mobi/099.md
浏览文件 @ b26ae976
# 科特林密封班
# Kotlin密封班
> 原文：<https://www.studytonight.com/kotlin/kotlin-sealed-class>
在本教程中，我们将学习**科特林密封类**。密封类在 Kotlin 中是新的，在 Java 中不存在。
在本教程中，我们将学习**Kotlin密封类**。密封类在 Kotlin 中是新的，在 Java 中不存在。
密封类用于**表示受限类层次结构**。这意味着密封类的对象只能有一个定义的类型。让我们借助一个例子来理解它。
......@@ -20,7 +20,7 @@
* 密封类的子类可以是不同的类型，如:数据类、对象类或普通类。
## 创建科特林密封类
## 创建Kotlin密封类
使用`sealed`关键字创建密封类。需要注意的是，密封类的所有子类都必须在同一个 Kotlin 文件中声明。如果我们试图在其他 Kotlin 文件中创建一个密封类的子类，我们会得到一个错误。**封存类默认为`abstract`**。意思是**我们不能实例化密封类**。
......@@ -45,7 +45,7 @@ fun main() {
正如您在上面的示例中看到的，我们可以将密封类用于这样的用例，在这些用例中，我们知道所有子类都需要什么，并且创建的类严格地服务于一个目的，就像在上面的代码示例中，我们有一个由 3 个子类继承的 Question 类，就是这样。
## 科特林密封类:`when`表达式
## Kotlin密封类:`when`表达式
我们经常使用带有`when`表达式的密封类。因为`when`表达式保证了**密封类的所有子类都被**处理。如果我们忘记处理密封类的一个特定子类，它会给出一个错误。现在没有必要有一个`else`街区。但是只有当你把`when`作为一个表达而不是一个陈述时，它才会起作用。
......
docs/mobi/100.md
浏览文件 @ b26ae976
......@@ -50,7 +50,7 @@ fun main(){
忍者等级为 12
新忍者等级为第一
## 柯特林参数化函数
## Kotlin参数化函数
同样，我们也可以创建通用函数:
......@@ -74,7 +74,7 @@ fun main(){
## 摘要
在本教程中，我们学习了 Kotlin 中泛型的基础知识。在下一个教程中，我们将学习柯特林中的扩展函数。
在本教程中，我们学习了 Kotlin 中泛型的基础知识。在下一个教程中，我们将学习Kotlin中的扩展函数。
* * *
......
docs/mobi/101.md
浏览文件 @ b26ae976
# 柯特林扩展函数
# Kotlin扩展函数
> 原文：<https://www.studytonight.com/kotlin/kotlin-extension-function>
在本教程中，我们将讨论柯特林中的扩展函数。Kotlin 提供了向现有类添加新功能的功能。为此，没有必要继承它们。可以通过名为**扩展**的特殊声明来实现。
在本教程中，我们将讨论Kotlin中的扩展函数。Kotlin 提供了向现有类添加新功能的功能。为此，没有必要继承它们。可以通过名为**扩展**的特殊声明来实现。
## 柯特林扩展函数
## Kotlin扩展函数
Kotlin Extensions 提供了向现有类添加新函数的功能。该功能称为**扩展功能**。我们可以向**用户定义类**以及**库类**添加扩展函数。
......
docs/mobi/102.md
浏览文件 @ b26ae976
# 科特林异常处理
\ No newline at end of file
# Kotlin异常处理
\ No newline at end of file
docs/mobi/103.md
浏览文件 @ b26ae976
# 科特林异常处理
# Kotlin异常处理
> 原文：<https://www.studytonight.com/kotlin/kotlin-exception-handling>
在本教程中，我们将学习科特林中的**异常处理。几乎所有的编程语言都提供了处理异常的机制。在开始异常处理之前，让我们先讨论什么是异常。**
在本教程中，我们将学习Kotlin中的**异常处理。几乎所有的编程语言都提供了处理异常的机制。在开始异常处理之前，让我们先讨论什么是异常。**
## **什么是例外？**
......@@ -38,11 +38,11 @@ Kotlin 中的所有异常类都是类**可投掷**的后代。
* **未检查的异常:**编译时不检查这些异常。即使我们不处理这些异常，程序也会编译成功。
在科特林，我们只有**未检查的异常**，即**检查的异常在科特林**中不存在。消除检查异常背后的原因之一是，很大一部分开发人员认为检查异常会增加不必要的代码。
在Kotlin，我们只有**未检查的异常**，即**检查的异常在Kotlin**中不存在。消除检查异常背后的原因之一是，很大一部分开发人员认为检查异常会增加不必要的代码。
如果我们想让调用者知道函数可能抛出的异常，我们可以在 Kotlin 中添加`@Throws`注释。
## 柯特林中的异常处理
## Kotlin中的异常处理
Kotlin 中的异常处理可以用四个关键词来理解。它们是:
......
docs/mobi/104.md
浏览文件 @ b26ae976
# 科特林试捕
# Kotlin试捕
> 原文：<https://www.studytonight.com/kotlin/kotlin-try-catch>
......@@ -20,7 +20,7 @@ try {
在上面的语法中， **SomeException** 是异常类的名称。您可以提供父类的名称来捕获单个 catch 块中的多个子类异常类，或者提供某个特定异常类的名称来处理单个异常。
### 科特林`try`&`catch`——例子
### Kotlin`try`&`catch`——例子
让我们首先看看一个会抛出异常的程序，如果我们不处理它会发生什么:
......@@ -62,7 +62,7 @@ fun main() {
## Kotlin `try` & `catch`的表达
柯特林`try-catch`区块的独特之处在于可以**作为表达**。这意味着它将返回值。`try`和`catch`块的最后语句被认为是返回值。
Kotlin`try-catch`区块的独特之处在于可以**作为表达**。这意味着它将返回值。`try`和`catch`块的最后语句被认为是返回值。
让我们编写一个程序，将两个数字相除，并将结果赋给`res`变量。如有异常，我们将`-1`分配给`res`:
......
docs/mobi/105.md
浏览文件 @ b26ae976
# 柯特林多重捕捉区块
# Kotlin多重捕捉区块
> 原文：<https://www.studytonight.com/kotlin/kotlin-multiple-catch-blocks>
......@@ -20,7 +20,7 @@ try {
如上所述，我们为每个`catch`块指定了不同的异常类型。多个`catch`块用于不同地处理不同类型的异常，例如，在不同的异常情况下为用户打印不同的消息。
### 柯特林多重`catch`块-示例
### Kotlin多重`catch`块-示例
让我们首先看一个例子，在这个例子中，我们将捕捉多个异常。我们将从用户那里获得两个数字作为输入，并对它们进行划分:
......@@ -66,7 +66,7 @@ fun main() {
## 摘要
在本教程中，我们学习了如何在 Kotlin 中使用多个`catch`块来处理多个不同的异常类型。在下一个教程中，我们将讨论柯特林中嵌套的`catch`块。
在本教程中，我们学习了如何在 Kotlin 中使用多个`catch`块来处理多个不同的异常类型。在下一个教程中，我们将讨论Kotlin中嵌套的`catch`块。
* * *
......
docs/mobi/106.md
浏览文件 @ b26ae976
# 科特林嵌套试捕
# Kotlin嵌套试捕
> 原文：<https://www.studytonight.com/kotlin/kotlin-nested-try-catch>
......@@ -21,7 +21,7 @@ try {
如果内部`try`块出现异常，则首先用内部`catch`块进行检查。如果没有在那里处理，那么将使用外部`catch`块进行检查，以此类推。
## 科特林嵌套试捕-示例:
## Kotlin嵌套试捕-示例:
让我们使用嵌套的`try-catch`块编写一个程序:
......
docs/mobi/107.md
浏览文件 @ b26ae976
# 柯特林终于挡住了
# Kotlin终于挡住了
> 原文：<https://www.studytonight.com/kotlin/kotlin-finally-block>
......@@ -41,7 +41,7 @@ finally {
让我们看看他们每个人的例子。
### 柯特林`finally`:完全没有异常发生
### Kotlin`finally`:完全没有异常发生
在这种情况下，异常不会发生，但将执行`finally`块:
......@@ -63,7 +63,7 @@ fun main() {
10 和 5 的除法结果为:2
最终总是执行块。
### 柯特林`finally`:异常发生并处理
### Kotlin`finally`:异常发生并处理
在这种情况下，异常发生并由`catch`块处理。最后，执行`finally`块:
......@@ -85,7 +85,7 @@ fun main() {
除以零！！
最终始终执行块。
### 科特林`finally`:？？？？？？？异常发生并且没有被处理
### Kotlin`finally`:？？？？？？？异常发生并且没有被处理
出现异常，但没有处理。程序将停止工作，但将执行`finally`块:
......
docs/mobi/108.md
浏览文件 @ b26ae976
# 柯特林抛出关键词
# Kotlin抛出关键词
> 原文：<https://www.studytonight.com/kotlin/kotlin-throw-keyword>
在本教程中，我们将了解 Kotlin 中的`throw`关键字，以及如何使用它抛出异常。
柯特林`throw`关键字明确用于抛出异常。我们也可以创建自己的自定义异常，并使用 Kotlin `throw`关键字抛出它。
Kotlin`throw`关键字明确用于抛出异常。我们也可以创建自己的自定义异常，并使用 Kotlin `throw`关键字抛出它。
## 盆地 `throw` 关键词
......@@ -16,7 +16,7 @@ throw SomeException("Custom Exception Message")
正如您在上面的例子中所看到的，我们可以抛出一个异常以及一些传播到`catch`块的异常消息，在那里我们可以使用它向最终用户显示消息。
## 科特林`throw`示例
## Kotlin`throw`示例
当用户输入的密码长度小于 3:
......
docs/mobi/109.md
浏览文件 @ b26ae976
# 科特林收藏
\ No newline at end of file
# Kotlin收藏
\ No newline at end of file
docs/mobi/110.md
浏览文件 @ b26ae976
# 科特林收藏
# Kotlin收藏
> 原文：<https://www.studytonight.com/kotlin/kotlin-collections>
在本节中，我们将向您简要介绍科特林的收藏。收藏的概念对柯特林来说并不陌生。它已经存在于许多其他编程语言中。Kotlin 标准库提供了一套创建和管理集合的工具。
在本节中，我们将向您简要介绍Kotlin的收藏。收藏的概念对Kotlin来说并不陌生。它已经存在于许多其他编程语言中。Kotlin 标准库提供了一套创建和管理集合的工具。
## 什么是收藏？
......@@ -14,7 +14,7 @@
## 集合类型
科特林有三种类型的收藏:
Kotlin有三种类型的收藏:
1. 目录
......
docs/mobi/111.md
浏览文件 @ b26ae976
......@@ -2,7 +2,7 @@
> 原文：<https://www.studytonight.com/kotlin/kotlin-list>
在本教程中，我们将讨论科特林列表。列表包括:
在本教程中，我们将讨论Kotlin列表。列表包括:
* 元素的有序集合。
......@@ -12,9 +12,9 @@
* 可变列表可以被认为是一个动态数组，其大小可以改变。
在科特林，我们可以有一个**可变**列表和一个**不可变**列表。
在Kotlin，我们可以有一个**可变**列表和一个**不可变**列表。
## 科特林不可变列表
## Kotlin不可变列表
使用`List`界面创建不可变列表。`List`界面继承了`Collection`界面。它包含许多有用的功能，如`contains()`、`indexOf()`、`isEmpty()`等。我们将借助一个例子来看它们。
......@@ -51,9 +51,9 @@ fun main() {
今晚学习
忍者
科特林
Kotlin
## 科特林列表函数和属性
## Kotlin列表函数和属性
`List`界面提供的一些重要功能和属性有:
......@@ -128,7 +128,7 @@ fun main() {
列表是否为空:假
从索引 1 到 3 的子列表【今晚学习】
## 科特林可变列表
## Kotlin可变列表
使用`MutableList`界面创建可变列表。`MutableList`界面也继承了`Collection`界面。可变列表本质上是动态的。在可变列表声明之后，我们可以在可变列表**中添加或删除元素。因此可变列表的大小不是固定的。**
......@@ -183,16 +183,16 @@ fun main() {
}
```
【忍者，学习，今晚，忍者，柯特林，Java】
【忍者，学习，C++，今晚，忍者，柯特林，Java】
【学习，C++，今晚，忍者，柯特林，Java】
【学习，今晚，忍者，柯特林，Java】
【学习，PHP，忍者，柯特林，Java】
【忍者，学习，今晚，忍者，Kotlin，Java】
【忍者，学习，C++，今晚，忍者，Kotlin，Java】
【学习，C++，今晚，忍者，Kotlin，Java】
【学习，今晚，忍者，Kotlin，Java】
【学习，PHP，忍者，Kotlin，Java】
【】
## 摘要
在本教程中，我们学习了不可变和可变列表，它们的创建使用了`listOf()`和`mutableListOf()`函数以及提供的一些重要函数。在下一个教程中，我们将讨论科特林的地图。
在本教程中，我们学习了不可变和可变列表，它们的创建使用了`listOf()`和`mutableListOf()`函数以及提供的一些重要函数。在下一个教程中，我们将讨论Kotlin的地图。
* * *
......
docs/mobi/112.md
浏览文件 @ b26ae976
......@@ -2,7 +2,7 @@
> 原文：<https://www.studytonight.com/kotlin/kotlin-map>
在本教程中，我们将讨论柯特林地图。映射用于存储**键和值对**。键和值都是用户定义的。在地图中:
在本教程中，我们将讨论Kotlin地图。映射用于存储**键和值对**。键和值都是用户定义的。在地图中:
* 密钥应该是唯一的，并且每个唯一的密钥只能存储一个值。
......@@ -14,13 +14,13 @@
* 键值对也称为条目。
在科特林，我们既可以有一张**可变**地图，也可以有一张**不可变**地图。
在Kotlin，我们既可以有一张**可变**地图，也可以有一张**不可变**地图。
## 科特林不可变地图
## Kotlin不可变地图
使用`Map<K, V>`界面创建不可变地图。我们只能从不可变的地图中阅读。
在柯特林中，不可变地图是使用`mapOf()`和`mapOf<K, V>()`函数创建的。与列表类似，`mapOf()`函数用于创建一个通用映射，其中键和值可以是任何数据类型。`mapOf<K, V>()`用于创建一个特定的地图，分别具有 K 和 V 数据类型的键和值。
在Kotlin中，不可变地图是使用`mapOf()`和`mapOf<K, V>()`函数创建的。与列表类似，`mapOf()`函数用于创建一个通用映射，其中键和值可以是任何数据类型。`mapOf<K, V>()`用于创建一个特定的地图，分别具有 K 和 V 数据类型的键和值。
让我们使用这两个函数创建不可变的映射:
......@@ -58,7 +58,7 @@ fun main() {
键为:数学和值为 97
键为:C++和值为 89
## 柯特林映射的性质和函数
## Kotlin映射的性质和函数
`Map`界面提供的一些重要功能和属性有:
......@@ -126,7 +126,7 @@ fun main() {
地图是否包含 C++:真
地图是否包含
## 科特林可变地图
## Kotlin可变地图
可变地图使用`MutableMap` 界面创建。可变地图支持动态特性。在可变地图声明之后，我们可以在其中添加、删除或更新条目。因此可变映射的大小不是固定的。
......@@ -198,7 +198,7 @@ fun main() {
## 摘要
在本教程中，我们讨论了不可变和可变映射，它们的创建使用了`mapOf()`和`mutableMapOf()`函数以及提供的一些重要函数。在下一个教程中，我们将讨论柯特林中的集合。
在本教程中，我们讨论了不可变和可变映射，它们的创建使用了`mapOf()`和`mutableMapOf()`函数以及提供的一些重要函数。在下一个教程中，我们将讨论Kotlin中的集合。
* * *
......
docs/mobi/113.md
浏览文件 @ b26ae976
# 科特林集
# Kotlin集
> 原文：<https://www.studytonight.com/kotlin/kotlin-set>
在本教程中，我们将讨论柯特林集。集合有:
在本教程中，我们将讨论Kotlin集。集合有:
* 元素的无序集合。
* 集合中不允许有重复的元素。
在科特林，我们既可以有一个**可变**集，也可以有一个**不可变**集。
在Kotlin，我们既可以有一个**可变**集，也可以有一个**不可变**集。
## 柯特林不变集
## Kotlin不变集
使用`Set`界面创建不可变集。`Set`界面继承了`Collection`界面。
......@@ -47,7 +47,7 @@ fun main() {
再见
A
## 柯特林集的性质和函数
## Kotlin集的性质和函数
`Set`界面提供的一些重要功能和属性有:
......@@ -128,7 +128,7 @@ Kotlin 的最后一个索引为:0
集合中的元素个数:4
集合中的 Max 元素:
## 柯特林可变集
## Kotlin可变集
使用`MutableSet`界面创建可变集。`MutableSet`界面也继承了`Collection`界面。可变集合本质上是动态的。我们可以在可变集合声明之后，在可变集合**中添加或移除元素。因此可变集合的大小不是固定的。**
......
docs/mobi/114.md
浏览文件 @ b26ae976
# 柯特林杂项
\ No newline at end of file
# Kotlin杂项
\ No newline at end of file
docs/mobi/115.md
浏览文件 @ b26ae976
# 科特林文件处理
# Kotlin文件处理
> 原文：<https://www.studytonight.com/kotlin/kotlin-file-handling>
......@@ -39,7 +39,7 @@ fun main() {
我们也可以使用`file.exists()`方法检查文件的存在
## 科特林写文件
## Kotlin写文件
我们可以使用`writeText()`方法将数据写入文件。
......@@ -65,7 +65,7 @@ fun main() {
如果我们查看 **Demo.txt** 文件，我们将只能在其中看到*再见世界*。因为`writeText()`会替换文件中存在的所有内容。如果想防止现在的数据丢失，可以用`appendText()`功能代替`writeText()`功能。
## 科特林从文件中读取
## Kotlin从文件中读取
对于逐行阅读内容，我们可以使用`forEachLine()`方法。它将从文件中逐行读取数据。
......
docs/mobi/116.md
浏览文件 @ b26ae976
# 科特林零安全
# Kotlin零安全
> 原文：<https://www.studytonight.com/kotlin/kotlin-null-safety>
在本教程中，我们将讨论柯特林最重要的特性之一:**零安全。**在编程世界中，当一个变量不引用任何东西时，它被认为是`null`。如果我们尝试使用这个变量，那么我们将得到`NullPointerException`或 NPE。
在本教程中，我们将讨论Kotlin最重要的特性之一:**零安全。**在编程世界中，当一个变量不引用任何东西时，它被认为是`null`。如果我们尝试使用这个变量，那么我们将得到`NullPointerException`或 NPE。
让我们看一个 Java 中发生`NullPointerException`的小例子:
......@@ -21,11 +21,11 @@ public class Student {
`NullPointerException` 被认为是一个[十亿美元的错误](https://en.wikipedia.org/wiki/Tony_Hoare#Apologies_and_retractions)，因为它导致程序突然终止。由于疏忽，`NullPointerException`可以出现在代码中的任何地方。
柯特林通过提供一种机制来处理`NullPointerException`来解决这个问题。科特林的目标是从我们的整个代码中删除 NPE。让我们讨论一下它的功能。
Kotlin通过提供一种机制来处理`NullPointerException`来解决这个问题。Kotlin的目标是从我们的整个代码中删除 NPE。让我们讨论一下它的功能。
## 可空和非空引用
在柯特林中，类型系统区分两种类型的引用:
在Kotlin中，类型系统区分两种类型的引用:
1. **可空引用:**这些引用可以保存空值。
......@@ -62,7 +62,7 @@ fun main() {
}
```
错误:(3，17)科特林:只安全(？。)或非空断言(！！。)字符串类型的可空接收器上允许调用？
错误:(3，17)Kotlin:只安全(？。)或非空断言(！！。)字符串类型的可空接收器上允许调用？
这里编译器不允许我们直接找到字符串的长度，因为它可能会抛出空指针异常。
......@@ -177,7 +177,7 @@ fun main() {
## 摘要
在本教程中，我们讨论了 Kotlin 中的 Null 安全性。空安全是 Kotlin 的一个重要特性，它将我们从空指针异常中拯救出来。在下一个教程中，我们将讨论柯特林中的正则表达式。
在本教程中，我们讨论了 Kotlin 中的 Null 安全性。空安全是 Kotlin 的一个重要特性，它将我们从空指针异常中拯救出来。在下一个教程中，我们将讨论Kotlin中的正则表达式。
* * *
......
docs/mobi/117.md
浏览文件 @ b26ae976
# 柯特林正则表达式
# Kotlin正则表达式
> 原文：<https://www.studytonight.com/kotlin/kotlin-regular-expression>
在本教程中，我们将讨论柯特林中的正则表达式。正则表达式是用来定义模式的字符序列。这种模式也被称为正则表达式。
在本教程中，我们将讨论Kotlin中的正则表达式。正则表达式是用来定义模式的字符序列。这种模式也被称为正则表达式。
正则表达式可以用于很多事情，比如字符串中的模式匹配，字符串中的查找和替换等等。在 Kotlin 中，`Regex`类用于创建和管理正则表达式。
......
docs/mobi/118.md
浏览文件 @ b26ae976
# 柯特林运算符重载
# Kotlin运算符重载
> 原文：<https://www.studytonight.com/kotlin/kotlin-operator-overloading>
在本教程中，我们将学习科特林的**运算符重载**。我们使用的每个操作符，如`+`、`-`、`++`等，都转化为一个功能。例如，以下算术函数转换为:
在本教程中，我们将学习Kotlin的**运算符重载**。我们使用的每个操作符，如`+`、`-`、`++`等，都转化为一个功能。例如，以下算术函数转换为:
| 操作员 | 表示 | 基础函数 |
| --- | --- | --- |
......@@ -13,7 +13,7 @@
此外，对于不同的数据类型，所有这些函数也可能被重载。例如，`plus()`函数为`Int`类型添加两个数字，为`String`类型连接两个字符串。
## 柯特林运算符重载
## Kotlin运算符重载
运算符重载可以通过重载该运算符的基础函数来实现。意思是过载`+`操作符，我们要过载`plus()`功能。
......@@ -48,7 +48,7 @@ fun main() {
* [釜底医生](https://kotlinlang.org/docs/reference/)
* [科顿医生 PDF](https://kotlinlang.org/docs/kotlin-docs.pdf)
* [科特林手控](https://play.kotlinlang.org/koans/overview)
* [Kotlin手控](https://play.kotlinlang.org/koans/overview)
* * *
......
docs/mobi/124.md
浏览文件 @ b26ae976
......@@ -156,7 +156,7 @@ bin 的位置将是 user/[system _ name]/Apache _ ant _ x . y . z/bin(x . y . z
![Tools Installation](img/d15cc3b1ad0536802103fbe64e6de8cc.png)
在新窗口中，勾选(勾选)复选框，仅下载安卓SDK工具、安卓SDK平台工具、工具面板中的SDK构建工具以及下载SDK平台等。
在新窗口中，勾选(勾选)`CheckBox`，仅下载安卓SDK工具、安卓SDK平台工具、工具面板中的SDK构建工具以及下载SDK平台等。
从下一课开始，我们将从应用的开发开始。
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或