2019-10-15 11:51:50

docs/kotlin/21.md

-# Kotlin 功能与例子
+# Kotlin 函数
 
 > 原文： [https://beginnersbook.com/2019/02/kotlin-function/](https://beginnersbook.com/2019/02/kotlin-function/)
 
@@ -13,9 +13,9 @@ Kotlin 中有两种类型的函数：
 
 ![Kotlin function](img/016dcd9b5901dab16ba41b5453668f7c.jpg)
 
-## 1.标准库功能
+## 1.标准库函数
 
-已经存在于 Kotlin 标准库中的函数称为标准库函数或内置函数或预定义函数。例如，当我们需要使用 Math.floor（）函数时，我们不定义函数，因为它已经存在，我们可以在代码中直接调用它。
+已经存在于 Kotlin 标准库中的函数称为标准库函数或内置函数或预定义函数。例如，当我们需要使用`Math.floor()`函数时，我们不定义函数，因为它已经存在，我们可以在代码中直接调用它。
 
 ### 标准库函数示例
 
@@ -32,13 +32,13 @@ fun main(args : Array<String>){
 
 ![Kotlin standard library function](img/4b1e8361262d49130d5851a18b7989e7.jpg)
 
-## 2.用户定义的功能
+## 2.用户定义的函数
 
 我们在调用它们之前在程序中定义的函数称为用户定义的函数。例如，假设我们想要一个函数在我们的程序中检查偶数或奇数，然后我们可以为此任务创建一个函数，然后调用我们需要执行检查的函数。
 
 ### 用户定义的函数示例
 
-我们使用`fun`关键字创建一个函数。让我们创建一个打印“Hello”的函数。
+我们使用`fun`关键字创建一个函数。让我们创建一个打印`"Hello"`的函数。
 
 ```kotlin
 //Created the function
@@ -90,9 +90,9 @@ fun main(args : Array<String>){
 
 ![Kotlin user defined function](img/280a1e7be4fa8b06a1a64f4b08d9d3ca.jpg)
 
-## Kotlin 内联功能
+## Kotlin 内联函数
 
-可以在 main（）函数内定义内联函数。让我们举一个内联函数的例子。在下面的例子中，我们定义了一个内联函数`sum`，它接受两个整数参数`num1`和`num2`，返回类型是整数。
+可以在`main()`函数内定义内联函数。让我们举一个内联函数的例子。在下面的例子中，我们定义了一个内联函数`sum`，它接受两个整数参数`num1`和`num2`，返回类型是整数。
 
 ```kotlin
 fun main(args : Array<String>){

docs/kotlin/22.md

-# Kotlin 递归和尾递归与示例
+# Kotlin 递归和尾递归
 
 > 原文： [https://beginnersbook.com/2019/03/kotlin-recursion-and-tail-recursion/](https://beginnersbook.com/2019/03/kotlin-recursion-and-tail-recursion/)
 
@@ -23,7 +23,7 @@ fun myfunction(){
 
 这是阶乘的一个简单例子。这里我们定义了一个函数`fact()`来计算它作为参数传递给该函数的数字的阶乘。在函数体中我们再次调用此函数，此过程称为递归。
 
-要求用户输入正整数，并根据输入，程序通过将输入数作为参数传递给[用户定义函数](https://beginnersbook.com/2019/02/kotlin-function/) `fact()`来查找输入数的阶乘。
+要求用户输入正整数，并根据输入，程序通过将输入数作为参数传递给[用户定义函数](https://beginnersbook.com/2019/02/kotlin-function/)`fact()`来查找输入数的阶乘。
 
 ```kotlin
 fun main(args: Array<String>) {
@@ -51,9 +51,9 @@ fun fact(num: Int): Int {
 
 ## 尾递归
 
-在递归中，计算在递归调用之后完成，我们在上面看到的阶乘的例子是递归或头递归的一个例子，其中计算 n 的阶乘，我们需要 n-1 的阶乘。
+在递归中，计算在递归调用之后完成，我们在上面看到的阶乘的例子是递归或头递归的一个例子，其中计算`n`的阶乘，我们需要`n-1`的阶乘。
 
-在 **Tail 递归**中，计算在递归调用之前的开始处完成。在尾递归中，递归函数的调用发生在函数的末尾。这意味着首先完成计算，然后传递给下一个递归调用。
+在**尾递归**中，计算在递归调用之前的开始处完成。在尾递归中，递归函数的调用发生在函数的末尾。这意味着首先完成计算，然后传递给下一个递归调用。
 
 让我们举一个尾递归的例子。
 

docs/kotlin/23.md

@@ -63,7 +63,7 @@ fun demo(number:Int= 100, ch: Char ='A'){
 Number is: 99 and Character is: Z
 ```
 
-## Kotlin 被命名为争论
+## Kotlin 命名参数
 
 在上面的例子中，我们学习了如何设置参数的默认值。在第二个例子中我们了解到我们可以在传递几个值时调用函数，我们在第二个例子`demo(99)`中进行了这样的函数调用，它会覆盖第一个默认值。但是，如果我们只想覆盖第二个默认值，那么我们可以在**命名参数**的帮助下完成。
 
@@ -79,4 +79,5 @@ fun demo(number:Int= 100, ch: Char ='A'){
 **输出：**
 
 ![Kotlin named arguments](img/c790097fbcc593496c60a3f490986e69.jpg)
+
 如您所见，我们在函数调用`demo(ch='Z')`期间使用参数名称覆盖了第二个参数的默认值。如果我们在没有像`demo('Z')`这样的命名参数的情况下完成此操作，则会抛出错误，因为它会尝试使用此值覆盖第一个整数参数。
\ No newline at end of file

docs/kotlin/24.md

-# Kotlin Lambda 功能示例
+# Kotlin Lambda 函数
 
 > 原文： [https://beginnersbook.com/2019/03/kotlin-lambda-function/](https://beginnersbook.com/2019/03/kotlin-lambda-function/)
 

docs/kotlin/25.md

@@ -32,9 +32,9 @@ fun demo(str: String) {
 
 在以下示例中，自定义函数`func`正在返回另一个函数。
 
-要理解这段代码，让我们首先看一下函数`func`，它接受一个整数参数`num`，在返回区域我们定义了一个函数`(Int) -> Int = {num2 -> num2 + num}`，所以这是另一个接受整数参数的函数并返回该参数和`num`的总和。
+要理解这段代码，让我们首先看一下函数`func`，它接受一个整数参数`num`，在返回区域我们定义了一个函数`(Int) -> Int = {num2 -> num2 + num}`，所以这是另一个接受整数参数的函数并返回该参数和`num`的总和。
 
-您可能想知道为什么我们将值 20 作为`sum`中的参数传递，这是因为函数`func`返回了函数，因此`sum`是接受 int 参数的函数。这与我们在函数`func`的返回区域中定义的函数相同。
+您可能想知道为什么我们将值 20 作为`sum`中的参数传递，这是因为函数`func`返回了函数，因此`sum`是接受`int`参数的函数。这与我们在函数`func`的返回区域中定义的函数相同。
 
 ```kotlin
 fun main(args: Array<String>) {

docs/kotlin/26.md

-# Kotlin 异常处理示例
+# Kotlin 异常处理
 
 > 原文： [https://beginnersbook.com/2019/03/kotlin-exception-handling/](https://beginnersbook.com/2019/03/kotlin-exception-handling/)
 
-例外是在程序运行时可能发生的不必要的问题，并突然终止您的程序。异常处理是一个过程，使用它可以防止程序出现可能破坏我们代码的异常。
+异常是在程序运行时可能发生的不必要的问题，并突然终止您的程序。异常处理是一个过程，使用它可以防止程序出现可能破坏我们代码的异常。
 
 有两种类型的异常：
 
-1.  已检查的异常声明为方法签名的一部分，并在编译时检查，例如 IOException
-2.  未经检查的异常不需要作为方法的一部分添加签名，并在运行时检查它们，例如 NullPointerException。
+1.  受检的异常声明为方法签名的一部分，并在编译时检查，例如`IOException`
+2.  非受检的异常不需要作为方法的一部分添加签名，并在运行时检查它们，例如`NullPointerException`。
 
-**注意：在 Kotlin 中，所有例外情况都未经检查。**
+**注意：在 Kotlin 中，所有异常情况都非受检。**
 
-处理 Kotlin 中的异常与 [Java](https://beginnersbook.com/2013/04/java-exception-handling/) 相同。我们使用 try，catch 和 finally 块来处理 kotlin 代码中的异常。
+处理 Kotlin 中的异常与 [Java](https://beginnersbook.com/2013/04/java-exception-handling/) 相同。我们使用`try`，`catch`和`finally`块来处理 kotlin 代码中的异常。
 
 ## Kotlin 异常处理示例
 
-在下面的例子中，我们将一个数字除以 0（零），这应该抛出 ArithmeticException。由于此代码在`try`块中，因此将执行相应的 catch 块。
+在下面的例子中，我们将一个数字除以 0（零），这应该抛出`ArithmeticException`。由于此代码在`try`块中，因此将执行相应的`catch`块。
 
-在这种情况下，发生了 ArithmeticException，因此执行了 ArithmeticException 的 catch 块，并在输出中打印了“Arithmetic Exception”。
+在这种情况下，发生了`ArithmeticException`，因此执行了`ArithmeticException`的`catch`块，并在输出中打印了`"Arithmetic Exception"`。
 
-当发生异常时，它会忽略该点之后的所有内容，并且控件会立即跳转到 catch 块（如果有的话）。无论是否发生异常，始终执行 finally 块。
+当发生异常时，它会忽略该点之后的所有内容，并且控制流会立即跳转到`catch`块（如果有的话）。无论是否发生异常，始终执行`finally`块。
 
 ```kotlin
 fun main(args: Array<String>) {
@@ -63,7 +63,7 @@ fun main(args: Array<String>) {
 
 ## 如何在 Kotlin 中抛出异常
 
-我们也可以使用`throw`关键字抛出异常。在下面的示例中，我们使用 throw 关键字抛出异常。异常执行前的语句已执行，但异常后的语句未执行，因为控件已转移到 catch 块。
+我们也可以使用`throw`关键字抛出异常。在下面的示例中，我们使用`throw`关键字抛出异常。异常执行前的语句已执行，但异常后的语句未执行，因为控制流已转移到`catch`块。
 
 ```kotlin
 fun main(args: Array<String>) {

docs/kotlin/27.md

-# Kotlin 尝试捕获示例
+# Kotlin `try-catch`
 
 > 原文： [https://beginnersbook.com/2019/03/kotlin-try-catch/](https://beginnersbook.com/2019/03/kotlin-try-catch/)
 
-在上一个教程中，我们学习了什么是[异常处理](https://beginnersbook.com/2019/03/kotlin-exception-handling/)。在本指南中，我们将看到 try catch 块的各种示例。我们还将看到如何使用 try 作为表达式。
+在上一个教程中，我们学习了什么是[异常处理](https://beginnersbook.com/2019/03/kotlin-exception-handling/)。在本指南中，我们将看到`try catch`块的各种示例。我们还将看到如何使用`try`作为表达式。
 
-## try catch 块的语法
+## `try catch`块的语法
 
 ```kotlin
 try {
@@ -18,13 +18,13 @@ finally {
 }
 ```
 
-try 块可以与多个 catch 块相关联，但是只能存在一个 finally 块。
+`try`块可以与多个`catch`块相关联，但是只能存在一个`finally`块。
 
-## Kotlin 试试 catch 块示例
+## Kotlin `try catch`块示例
 
-在这个例子中，我们放置了可能导致 try 块内异常的代码。一旦异常发生在 try 块内，它就会查找处理发生的异常的相应 catch 块。由于在代码中发生了 ArithmeticException 并且在 catch 块中处理了相同的异常，因此执行 catch 块中的代码。
+在这个例子中，我们放置了可能导致`try`块内异常的代码。一旦异常发生在`try`块内，它就会查找处理发生的异常的相应`catch`块。由于在代码中发生了`ArithmeticException`并且在`catch`块中处理了相同的异常，因此执行`catch`块中的代码。
 
-异常处理的主要优点是程序不会突然终止。在以下示例中，最后一个 println 语句`println("Out of try catch block")`在 catch 块之后执行。如果我们没有进行异常处理，则不会执行此语句，因为程序将在行`var num = 100/0`上终止
+异常处理的主要优点是程序不会突然终止。在以下示例中，最后一个`println`语句`println("Out of try catch block")`在`catch`块之后执行。如果我们没有进行异常处理，则不会执行此语句，因为程序将在行`var num = 100/0`上终止
 
 ```kotlin
 fun main(args: Array<String>) {
@@ -44,9 +44,9 @@ fun main(args: Array<String>) {
 
 ![Kotlin try catch block example](img/ee113c9723e5af73128efc8600b6fc17.jpg)
 
-## Kotlin 尝试阻止没有捕获块
+## Kotlin 没有`catch`块的`try`块
 
-try 块可以没有 catch 块，但在这种情况下必须存在 finally 块。 **总之，你可以说至少应该有一个捕获或最后一个阻塞**。最后块是可选的，但是当没有 catch 块时，必须有一个 finally 块。
+`try`块可以没有`catch`块，但在这种情况下必须存在`finally`块。 **总之，你可以说至少应该有一个`catch`或`finally`块**。`finally`块是可选的，但是当没有`catch`块时，必须有一个`finally`块。
 
 ```kotlin
 fun main(args: Array<String>) {

docs/kotlin/28.md

-# Kotlin Multiple Catch Blocks 示例
+# Kotlin 多个`catch`块
 
 > 原文： [https://beginnersbook.com/2019/03/kotlin-multiple-catch-blocks/](https://beginnersbook.com/2019/03/kotlin-multiple-catch-blocks/)
 
-try 块可以有多个 catch 块。当我们不确定 try 块内是否会发生所有异常时，为潜在的异常设置多个 catch 块总是一个好主意，并且在最后一个 catch 块中有父异常类来处理未指定的剩余异常通过 catch 块。
+`try`块可以有多个`catch`块。当我们不确定`try`块内是否会发生所有异常时，为潜在的异常设置多个`catch`块总是一个好主意，并且在最后一个 catch 块中有父异常类来处理未指定的剩余异常通过`catch`块。
 
-## Kotlin 多个捕获块的例子
+## Kotlin 多个`catch`块的例子
 
-在下面的示例中，我们有多个 catch 块，但是当发生异常时，它会查找该特定异常的处理程序。
+在下面的示例中，我们有多个`catch`块，但是当发生异常时，它会查找该特定异常的处理程序。
 
-这里发生的异常是算术异常，但是前两个 catch 块没有处理算术异常，这就是为什么执行第三个 catch 块的代码。第三个块处理所有异常，因为它使用 Exception 类，它是所有异常类的父类。
+这里发生的异常是算术异常，但是前两个`catch`块没有处理算术异常，这就是为什么执行第三个`catch`块的代码。第三个块处理所有异常，因为它使用`Exception`类，它是所有异常类的父类。
 
 ```kotlin
 fun main(args: Array<String>) {
@@ -34,9 +34,9 @@ fun main(args: Array<String>) {
 
 ![Kotlin multiple catch blocks](img/d69d9fa0cf38234c1284829394f9785c.jpg)
 
-## 多个 catch 块的另一个例子
+## 多个`catch`块的另一个例子
 
-下面是多个 catch 块的另一个例子，这里发生了 ArrayIndexOutOfBoundsException，因为这个异常存在一个处理程序（catch 块），执行处理程序内部的代码。
+下面是多个`catch`块的另一个例子，这里发生了`ArrayIndexOutOfBoundsException`，因为这个异常存在一个处理程序（`catch`块），执行处理程序内部的代码。
 
 ```kotlin
 fun main(args: Array<String>) {
@@ -65,13 +65,13 @@ fun main(args: Array<String>) {
 
 ![Kotlin multiple catch blocks example](img/50f96d4d8d867745c1504fca1af1e054.jpg)
 
-## 为什么在最后一个 catch 块中使用父 Exception 类是个好主意
+## 为什么在最后一个`catch`块中使用父`Exception`类是个好主意
 
-让我们采用我们上面的相同示例，但在此代码中，我们做了一个小改动。这里我们首先得到父 Exception 类的处理程序（catch 块）。
+让我们采用我们上面的相同示例，但在此代码中，我们做了一个小改动。这里我们首先得到父`Exception`类的处理程序（`catch`块）。
 
-在代码中发生了 ArrayIndexOutOfBoundsException 并且我们有这个特殊异常的处理程序，但是因为我们首先有一般的 Exception 类，它处理所有异常所以它被执行而不是处理 ArrayIndexOutOfBoundsException 的 catch 块。
+在代码中发生了`ArrayIndexOutOfBoundsException`并且我们有这个特殊异常的处理程序，但是因为我们首先有一般的`Exception`类，它处理所有异常所以它被执行而不是处理`ArrayIndexOutOfBoundsException`的`catch`块。
 
-以顺序方式检查 catch 块，以便执行第一个 catch 块，实际上在任何异常的情况下，第一个 catch 将执行，这是一个糟糕的编程习惯，因为我们想要一个特定的消息而不是一般化的消息。因此，解决方案是在最后一个位置使用此默认处理程序，就像我们在上面的示例中所做的那样。
+以顺序方式检查`catch`块，以便执行第一个`catch`块，实际上在任何异常的情况下，第一个`catch`将执行，这是一个糟糕的编程习惯，因为我们想要一个特定的消息而不是一般化的消息。因此，解决方案是在最后一个位置使用此默认处理程序，就像我们在上面的示例中所做的那样。
 
 ```kotlin
 fun main(args: Array<String>) {

docs/kotlin/29.md

-# Kotlin Nested Try-Catch Block 示例
+# Kotlin 嵌套`Try-Catch`块
 
 > 原文： [https://beginnersbook.com/2019/03/kotlin-nested-try-catch-block/](https://beginnersbook.com/2019/03/kotlin-nested-try-catch-block/)
 
-当 try catch 块出现在另一个 try catch 块中时，它被称为嵌套的 try catch 块。如果在内部 try catch 块中没有处理内部 try catch 块中发生任何异常，则检查外部 try catch 块的 catch 块是否存在该异常。
+当`try catch`块出现在另一个`try catch`块中时，它被称为嵌套的`try catch`块。如果在内部`try catch`块中没有处理内部`try catch`块中发生任何异常，则检查外部`try catch`块的`catch`块是否存在该异常。
 
-## 嵌套 try catch 块的语法
+## 嵌套`try catch`块的语法
 
 ```kotlin
 try{
@@ -24,11 +24,11 @@ catch
 
 ```
 
-## 嵌套的 Try-Catch Block 示例
+## 嵌套的`Try-Catch`块示例
 
-在下面的示例中，内部 try 块中存在异常，但是在内部 catch 块中未处理发生的异常（ArithmeticException），因此检查外部 catch 块是否存在此异常，因为外部 catch 块正在处理此异常，代码对于 ArithmeticException，执行 inside external catch 块。
+在下面的示例中，内部`try`块中存在异常，但是在内部`catch`块中未处理发生的异常（`ArithmeticException`），因此检查外部`catch`块是否存在此异常，因为外部`catch`块正在处理此异常，代码对于`ArithmeticException`，执行外部的`catch`块。
 
-try 块中可以有多个 try catch 块，内部 try 块内也可以有 try catch 块。这里要注意的唯一事情是，如果在子 try try 块中没有处理异常，那么将检查父 try catch 块的处理程序是否发生了异常。
+`try`块中可以有多个`try catch`块，内部`try`块内也可以有`try catch`块。这里要注意的唯一事情是，如果在子`try`块中没有处理异常，那么将检查父`try catch`块的处理程序是否发生了异常。
 
 ```kotlin
 fun main(args: Array<String>) {

docs/kotlin/30.md

-# Kotlin 抛出关键字示例
+# Kotlin `throw`关键字
 
 > 原文： [https://beginnersbook.com/2019/03/kotlin-throw-keyword-with-example/](https://beginnersbook.com/2019/03/kotlin-throw-keyword-with-example/)
 
-在这个简短的指南中，我们将学习如何在 Kotlin 中使用 throw 关键字抛出异常。
+在这个简短的指南中，我们将学习如何在 Kotlin 中使用`throw`关键字抛出异常。
 
-## Kotlin throw 关键字示例
+## Kotlin `throw`关键字示例
 
-在下面的示例中，我们使用 throw 关键字抛出异常。在这里我抛出了父 Exception 类，你可以抛出任何异常，如 ArithmeticException，ArrayIndexOutOfBoundsException 等。
+在下面的示例中，我们使用`throw`关键字抛出异常。在这里我抛出了父`Exception`类，你可以抛出任何异常，如`ArithmeticException`，`ArrayIndexOutOfBoundsException`等。
 
 ```kotlin
 fun main(args: Array<String>) {