BeginnersBook-Kotlin-教程-一-

BeginnersBook Kotlin 教程（一）

原文：BeginnersBook

协议：CC BY-NC-SA 4.0

Kotlin 注释

原文： https://beginnersbook.com/2018/09/kotlin-comments/

注释是程序的重要组成部分，它提高了代码的可读性，使其更易于理解。在代码中编写有意义的注释被认为是一种很好的编程实践。与 Java 类似，Kotlin 也支持单行和多行注释。 Kotlin 中注释的语法与 Java 相同。

什么是注释？

注释是程序员在代码的各个位置编写的有意义的文本，用于解释代码的目的和逻辑。编写注释是为了提高代码的可读性，它们在程序的编译和执行中不起作用，编译器在编译期间完全忽略它们。

Kotlin 中的注释类型

Kotlin 有两种类型的注释 - 1）单行注释 2）多行注释

kotlin comments

1）单行注释

顾名思义，这种注释是写一行注释。单行注释以双斜杠开始，编译器忽略双斜杠后写入的任何文本。

fun main(args: Array<String>) {
    //This is a single line comment
    println("Hello World!")
}

双斜线后面的文本“这是单行注释”是注释。我已经写了这篇文章来演示注释的使用，但是文本应该解释代码的行或块的目的是什么，所以有意义的注释应该如下所示：

fun main(args: Array<String>) {
    //This displays the "Hello World!" message on the output screen
    println("Hello World!")
}

2）多行注释

在某些情况下，我们需要在几行中解释这段代码，在这种情况下，我们使用多行注释。我们用/*开始注释并以*/结束注释。

例如：

fun main(args: Array<String>) {
    /* This is a multi-line comment. I'm writing this 
     * text to show you that we can write the comments
     * in multiple lines
     */
    println("Hello World!")
}

Kotlin 字符串

原文： https://beginnersbook.com/2019/02/kotlin-string/

字符串是一系列字符。在本指南中，我们将了解如何在 Kotlin 中声明，使用和操作字符串。

在 Kotlin 中声明一个`String`

我们可以在 Kotlin 中定义一个String。让我们看一下下面的例子，这里我们已经声明了两个不可变的字符串website和longString我们还声明了两个可变字符串name和lName。这个例子还展示了一种简单的字符串连接方式，在 Kotlin 指南中阅读更多参考字符串连接。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    /**
     * These Strings are Immutable which
     * means they are read-only and
     * unchangeable
     */
    val website = "BeginnersBook"

    /**
     * This is how we declare long strings
     */
    val longString = """Welcome to
        Beginnersbook.com"""

    /**
     * Mutable Strings
     */
    var name = "Chaitanya"
    var lName = "Singh"
    name = name + " " + lName
    println("Name is: $name")
}

输出：

Kotlin String

在 Kotlin 中获取字符串长度

让我们看看我们如何在 Kotlin 中获得String长度。在下面的示例中，我们有一个String firstName，我们正在显示该字符串的长度。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var firstName = "Chaitanya"

    /**
     * String interpolation
     */
    println("String Length: ${firstName.length}")

    /**
     * Or you can display like this
     */
    println("String Length: " + firstName.length)
}

输出：

String Length: 9
String Length: 9

比较 Kotlin 中的`String`

让我们举一个例子来比较 Kotlin 中的两个字符串。有两种比较字符串的方法，使用equals()方法或使用compareTo()方法。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var str1 = "BeginnersBook"
    var str2 = "beginnersbook"

    /**
     * true if equals, otherwise false
     */
    println("String Equals? : ${str1.equals(str2)}")

    /**
     * 0 if equals, otherwise false
     */
    println("String Equals? : ${str1.compareTo(str2)}")
}

输出：

Compare Strings in Kotlin

访问特定索引处的字符串中的字符

我们可以使用get()方法从字符串中的特定索引获取字符，该方法等同于 Java 的charAt()方法

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var str = "BeginnersBook"

    println("3rd Index: ${str.get(3)}")

    /**
     * Another way of doing the same
     * This is the recommended way
     */
    println("3rd Index: ${str[3]}")
}

输出：

3rd Index: i
3rd Index: i

子串

我们可以使用subSequence()方法在 Kotlin 中显示子字符串。我们可以在subSequence(fromIndex, toIndex)方法中提供fromIndex和toIndex，其中fromIndex是包含性的，toIndex是排他性的。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var str = "BeginnersBook"

    /**
     * Here fromIndex is inclusive and
     * toIndex is exclusive which means
     * 5th index char will not be included
     */
    println("Index from 2 to 5: " +
    str.subSequence(2,5))
}

输出：

Index from 2 to 5: gin

检查`String`是否包含另一个`String`

我们可以使用contains()方法来检查给定的字符串是否包含指定的字符串。让我们举个例子来理解contains()的用法

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var str = "beginnersbook.com"

    println("Contains .com: ${str.contains(".com")}")
}

输出：

Kotlin string contains

Kotlin 数组

原文： https://beginnersbook.com/2019/02/kotlin-array/

Kotlin 中的数组能够存储不同数据类型的多个值。当然，如果我们想要，我们可以限制数组保存特定数据类型的值。在本指南中，我们将讨论 Kotlin 中的数组。

Kotlin 数组声明

包含多种不同数据类型的数组。

var arr = arrayOf(10, "BeginnersBook", 10.99, 'A')

只能保存整数的数组

var arr = arrayOf<Int>(1, 22, 55)

只能保存字符串的数组

var arr2 = arrayOf<String>("ab", "bc", "cd")

访问 Kotlin 中的数组元素

在下面的例子中，我们有一个数组arr，它有多个不同数据类型的元素，我们使用索引（arr[3]）显示数组的第四个元素。由于数组是可变的，我们可以更改元素的值，我们在下面的示例中显示了该值。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    /**
     * Array that holds multiple different data types
     */
    var arr = arrayOf(10, "BeginnersBook", 10.99, 'A')

    /**
     * Displaying 4th element
     */
    println(arr[3])

    /**
     * modifying 4th element
     */
    arr[3] = 100

    /**
     * Displaying 4th element again
     */
    println(arr[3])

}

输出：

Kotlin Array

Kotlin 数组`set()`和`get()`函数

`get()`

在上面的例子中，我们使用以下语句来访问数组的第 4 个元素的值。

arr[3]

我们可以使用get函数重写相同的语句，如下所示：

arr.get(3)

`set()`

在上面的例子中，我们使用以下语句来修改数组中第 4 个元素的值。

arr[3] = 100

我们可以使用set()函数重写相同的语句，如下所示：

arr.set(3,100)

数组的大小

我们可以很容易地找到这样的数组的大小：

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var arr = arrayOf(1, 2, 3, 4, 5)

    println("Size of Array arr is: ${arr.size}")

}

输出：

Size of Array arr is: 5

检查数组中的元素

我们还可以使用contains()检查数组中是否存在元素。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var arr = arrayOf(1, 22, "CPS")

    println("Array contains CPS: ${arr.contains("CPS")}")

}

输出：

Kotlin Array Contains

Kotlin `Array first()`和`last()`函数

我们可以使用first()和last()函数轻松找出数组的第一个和最后一个元素。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var arr = arrayOf(1, 22, "CPS")

    println("First Element: ${arr.first()}")
    println("Last Element: ${arr.last()}")

}

输出：

First Element: 1
Last Element: CPS

查找数组中元素的索引

我们可以使用indexOf()函数找出数组中特定元素的索引。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var arr = arrayOf(1, 22, "CPS")

    println("Index of 22: ${arr.indexOf(22)}")

}

输出：

Index of 22: 1

Kotlin 范围

原文： https://beginnersbook.com/2019/02/kotlin-ranges/

在本指南中，我们将讨论 Kotlin 的非常酷的特征，即范围。借助 Kotlin 中的范围，我们可以通过指定起始值和结束值轻松创建序列列表。例如，1..5的范围将创建一系列值1,2,3,4,5。类似地，我们可以创建字符范围，例如'A'..'D'，它将创建一系列值 A, B, C, D。我们也可以按相反顺序创建范围，并使用范围创建其他几个范围。让我们开始吧。

Kotlin 范围的一个简单例子

在下面的示例中，我们创建了两个范围，一个是整数范围，另一个是字符范围。我们使用for循环遍历范围的元素。

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    println("Number range:")

    for(num in 1..4){
        println(num)
    }

    println("Character range:")

    for(ch in 'A'..'E'){
        println(ch)
    }
}

输出：

Kotlin Ranges

检查范围中的元素

我们还可以检查范围内是否存在特定元素。让我们看一下如何借助一个简单的例子来做到这一点。

package beginnersbook

fun main(args : Array<String>){

    val oneToTen = 1..10

    println("3 in oneToTen: ${3 in oneToTen}")
    println("11 in oneToTen: ${11 in oneToTen}")
}

输出：

3 in oneToTen: true
11 in oneToTen: false

Kotlin 范围：`rangeTo()`和`downTo()`函数

而不是..我们可以使用这些函数rangeTo()和downTo()，rangeTo()用于递增顺序而downTo()用于递减顺序。

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    val oneToFive = 1.rangeTo(5)
    val sixToThree = 6.downTo(3)

    println("rangeTo:")
    for(x in oneToFive){
        println(x)
    }

    println("downTo")
    for(n in sixToThree){
        println(n)
    }
}

输出：

Kotlin rangeTo() and downTo() ranges

Kotlin 范围步长

在step()函数的帮助下，我们可以定义值之间的间隔。默认情况下，step的值为 1，因此当我们创建范围1..10时，它是1,2,3，... 10。但是如果我们想要一个像 3 这样的特定区间，那么我们可以像这样定义1..10.step(3)这样的范围，这样的值就是1 4 7 10。让我们举一个例子。

package beginnersbook

fun main(args : Array<String>){

    val oneToTen = 1..10
    val odd = oneToTen.step(2)

    for(n in odd){
        println(n)
    }
}

输出：

Kotlin 范围反转

我们可以使用reverse()函数反转 Kotlin 中的范围。

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    val oneToFive = 1..5
    for (n in oneToFive.reversed()){
        println(n)
    }
}

输出：

Kotlin Range reverse

Kotlin `If - Else`表达式

原文： https://beginnersbook.com/2018/09/kotlin-if-else-expression/

在任何编程语言中，我们需要控制语句来根据条件的输出来控制程序的流程。例如，如果数字是偶数则显示“偶数”但如果数字是奇数则显示“奇数”。为了在编程中实现这一点，我们需要使用控制语句来检查条件是否满足，如果是，则执行此操作，如果没有则跳过此步骤。在 kotlin 中，我们使用表达式来控制程序中的流。在本教程中，我们将学习 Kotlin 中使用的几种表达式。

if表达式
if..else表达式
if..else if..else表达式
嵌套表达式

1. Kotlin - `if`表达

if表达很容易理解。让我们来看看if表达式的语法：

if(condition){  
   // Statements that need to be executed if condition is true 
   ...
}

这里我们在if表达式中有一个条件，如果条件返回true则执行if表达式体内的语句，如果条件返回false则完全忽略它们。让我们举个例子来理解这个：

`if`表达式的例子

在这个例子中，如果给定的数字是偶数，那么我们在输出中显示“偶数”，否则我们跳过if里面的语句。

fun main(args: Array<String>) {

    val number = 100

    // if expression
    if (number%2 == 0)
        println("Even Number")

    println("Out Of If statement")
}

输出：

Even Number
Out Of If statement

让我们改变变量num的值。

fun main(args: Array<String>) {

    val number = 101

    if (number%2 == 0)
        println("Even Number")

    println("Out Of If statement")
}

输出：

Out Of If statement

2. Kotlin - `If..Else`表达式

如果条件为true时，我们需要执行某些操作，并且条件为false时我们需要执行不同的操作，使用if else表达式。例如：如果我通过考试，我父亲会给我钱，否则他们会生气。如果我必须在编程中写这个，那么我会这样做：

fun main(args: Array<String>) {
    // Marks out of 100
    val marks = 90
    if (marks < 30) {
        println("Father will get angry")
    }
    else {
        println("Father will give me money")
    }
}

输出：

Father will give me money

由于条件返回false，因此跳过if中的语句并执行else中的语句。

if..else表达式的语法：

if(condition){  
   // Statements that will be executed if the condition returns true 
   ...
}  
else{  
   // Statements that will be executed if the condition returns false 
   ...
}

`if..else`表达式示例

在这个例子中，我们正在检查一个数字，看它是正面的还是负面的。

fun main(args: Array<String>) {
    // Traditional usage
    val num = -101
    if (num < 0) {
        println("Negative number")
    }
    else {
        println("Positive number")
    }
    println("Out of if else statement")
}

输出：

Negative number
Out of if else statement

3. Kotlin - `if..else if..else`阶梯表达式

在这个表达式中，我们有一个if块，一个else块和一个或多个else if块。这用于检查多个条件。

`if..else if..else`表达式示例

在这个例子中，我们有一个数字，我们正在检查它是负数，单位数，两位数还是多位数。我们使用if..else if..else表达式检查这些多个条件。当条件都不返回true时，else块内的语句将被执行。

fun main(args: Array<String>) {
    val num = 99
    if(num<0)
        println("Number is Negative")
    else if (num>0 && num<10)
        println("Single digit number")
    else if (num>=10 && num <100)
        println("Double digit number")
    else
        println("Number has 3 or more digits")
}

输出：

Double digit number

4. Kotlin - 嵌套表达式

当一个表达式存在于另一个表达式主体内时，它被称为表达式的嵌套。例如，如果if表达式出现在另一个if中，那么它将被称为嵌套if表达式。

例如：

fun main(args: Array<String>) {
    val num = 101
    if(num<0)
        println("Negative Number")
    else {
        //Nested expression
        if(num%2 == 0)
            println("Even Number")
        else
            println("Odd Number")
    }

}

输出：

Odd Number

参考

Kotlin 官方文档

Kotlin `when`表达式

原文： https://beginnersbook.com/2019/02/kotlin-when-expression/

Kotlin 中的when表达与 C，C++ 和 Java 等其他编程语言中的switch-case相同。**

Kotlin `when`表达式的简单的例子

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var ch = 'A'

    when(ch){

        'A' -> println("A is a Vowel")
        'E' -> println("E is a Vowel")
        'I' -> println("I is a Vowel")
        'O' -> println("O is a Vowel")
        'U' -> println("U is a Vowel")

        else -> println("$ch is a Consonant")
    }
}

输出：

A is a Vowel

我们也可以用更清洁的方式重写相同的代码，如下所示：

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    var ch = 'A'

    when(ch){

        'A', 'E', 'I', 'O', 'U' -> println("$ch is a Vowel")

        else -> println("$ch is a Consonant")
    }
}

Kotlin `when`表达式的范围

我们也可以在when中使用范围。在下面的示例中，我们在when表达式中使用了多个范围来查找给定数字中的数字。

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    var num = 78

    when(num) {
        in 1..9 -> println("$num is a single digit number")
        in 10..99 -> println("$num is a two digit number")
        in 100..999 -> println("$num is a three digit number")
        else -> println("$num has more than three digits")
    }
}

输出：

Kotlin when expression

表达式里面的算术运算

我们还可以对我们在when表达式中传递的变量执行操作。

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    var age = 16

    when(age) {
        in 1..17 -> {
            val num = 18 - age
            println("You will be eligible for voting in $num years")
        }
        in 18..100 -> println("You are eligible for voting")
    }
}

输出：

Kotlin when expression with ranges example

Kotlin `for`循环

原文： https://beginnersbook.com/2019/02/kotlin-for-loop/

Kotlin 中的for循环用于迭代或循环数组，范围，集合等元素。在本指南中，我们将学习如何在 Kotlin 中使用for循环各种例子的帮助。

Kotlin 中`for`循环的一个简单例子

在下面的示例中，我们使用 for 循环遍历整数范围。

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    for(n in 10..15){
        println("Loop: $n")
    }
}

输出：

Kotlin for loop

Kotlin `for`循环遍历`Array`

在下面的例子中，我们声明了一个数组myArray，我们使用for循环显示数组的元素。

package beginnersbook

fun main(args : Array<String>){

    val myArray = arrayOf("ab", "bc", "cd", "da")
    for (str in myArray){
        println(str)
    }
}

输出：

ab
bc
cd
da

Kotlin `for`循环遍历数组索引

我们还可以使用数组索引来遍历数组。

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    val myArray = arrayOf("Steve", "Robin", "Kate", "Lucy")
    for (n in myArray.indices){
        println("myArray[$n]: ${myArray[n]}")
    }
}

输出：

Kotlin array loop through collection

在`for`循环中使用`withIndex()`函数

在上面的例子中，我们使用数组索引遍历数组。另一种方法是使用withIndex()函数。

package beginnersbook

fun main(args : Array<String>){

    val myArray = arrayOf("Steve", "Robin", "Kate", "Lucy")
    for((index, value) in myArray.withIndex()){
        println("Value at Index $index is: $value")
    }
}

输出：

Value at Index 0 is: Steve
Value at Index 1 is: Robin
Value at Index 2 is: Kate
Value at Index 3 is: Lucy

Kotlin `while`循环

原文： https://beginnersbook.com/2019/02/kotlin-while-loop/

while循环用于重复迭代代码块，只要给定条件返回true即可。在本指南中，我们将学习如何在示例的帮助下使用while循环。

Kotlin 中的一个简单的循环

在下面的示例中，我们使用while循环显示 10 到 5 之间的值。这里需要注意的重点是计数器，在下面的例子中是变量num，对于上升循环，计数器值应该增加以满足给定条件，对于下降循环，计数器值应该在每次迭代中减少，就像我们在以下示例。

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    var num = 10

    while(num>=5){
        println("Loop: $num")
        num--
    }
}

输出：

Kotlin while loop

无限循环

如果while循环中指定的条件永远不会返回false，那么循环无限迭代并且永远不会停止，而while循环被称为无限循环。在编写代码时我们应该始终避免这种情况。让我们看几个无限while循环的例子。

由于条件始终为真，因此无限运行。

while (true){  
   println("loop")  
}

在这个while循环中，我们递增计数器num，计数器初始值为 10，并且我们在每次迭代时增加它，这意味着指定的条件num >= 5将始终保持为真并且循环将永远不会停止。

var num = 10

while(num>=5){
   println("Loop: $num")
   num++
}

以下循环也将是无限循环，因为条件将始终保持为真，因为我们正在减小num的值，这意味着将始终满足条件num <= 10。

var num = 5

while(num<=10){
   println("Loop: $num")
   num--
}

Kotlin `do-while`循环

原文： https://beginnersbook.com/2019/02/kotlin-do-while-loop/

do-while循环类似于while循环，除了它在迭代结束时检查条件。即使给定条件为假，do-while循环也至少会运行一次。

Kotlin `do-while`循环示例

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    var num = 100
    do {
        println("Loop: $num")
        num++
    }
    while (num<=105)
}

输出：

Kotlin do while loop

`do-while`循环至少运行一次

正如我在本指南开头所提到的，即使给定条件返回false，do-while循环也至少会运行一次。发生这种情况是因为do-while循环在执行循环体之后检查条件。

/**
 * created by Chaitanya for Beginnersbook.com
 */

package beginnersbook

fun main(args : Array<String>){

    var num = 100
    do {
        println("Loop: $num")
        num++
    }
    while (false)
}

输出：

do while loop with false condition

Kotlin 无限循环

一个无限运行且永不停止的while循环称为无限循环。让我们看一下无限循环的几个例子。

例 1：

var num = 100
do {
    println("Loop: $num")
    num++   
}
while (true)

例 2：

var num = 100
do {
    println("Loop: $num")
    num--  
}
while (num<=105)

例 3：

var num = 105
do {
    println("Loop: $num")
    num++
}
while (num>=100)

Kotlin `continue`表达式

原文： https://beginnersbook.com/2019/02/kotlin-continue-expression-with-examples/

continue构造跳过循环的当前迭代并将控制流跳转到循环结束以进行下一次迭代。continue通常与if表达式一起使用，以跳过指定条件的循环的当前迭代。在本指南中，我们将学习cintinue构造和标签。

Kotlin `continue`循环示例

fun main(args : Array<String>){

    for (n in 1..5){
        println("before continue, Loop: $n")
        if(n==2||n==4)
            continue

        println("after continue, Loop: $n")

    }
}

输出：

Kotlin continue example

正如您在输出中看到的那样println("after continue, Loop: $n")语句没有为循环迭代n == 2和n == 4执行，因为在这些迭代中我们使用了此语句之前的continue，它跳过了这些n值的迭代。

但是，您可以观察到在每次迭代时执行的println("before continue, Loop: $n")语句，因为它在遇到Continue之前执行。

基于此，您可以得出结论continue跳过迭代，但它无法跳过continue之前遇到的语句。一旦遇到continue，控制流就跳转到循环的末尾，跳过其余的语句。

让我们再看一个例子

Kotlin `continue`：显示偶数

fun main(args : Array<String>){

    for (n in 1..10){
        if(n%2!=0)
            continue

        println("$n")

    }
}

输出：

Kotlin continue example

`continue`标签

直到现在我们已经学会了continue。让我们了解continue标签。这些标签很酷，基本上它们在我们处理嵌套循环时给予我们更多的控制。

让我们举一个例子，我们首先不使用continue标签，然后我们将采用与continue标签相同的例子。

没有continue标签的嵌套循环示例

在这个例子中，我们有一个嵌套的for循环，我们没有使用标签。当我们不使用标签时，我们没有任何控制，一旦遇到continue，就会跳过内循环的当前迭代。

fun main(args : Array<String>){

    for (x in 'A'..'D'){
        for (n in 1..4){
            if (n==2||n==4)
                continue

            println("$x and $n")
        }

    }
}

输出：

A and 1
A and 3
B and 1
B and 3
C and 1
C and 3
D and 1
D and 3

带有continue标签的嵌套循环示例

您可以在上面的示例输出中看到，对于n值 2 和 4，内循环将跳过迭代。让我们说我们想跳过外部for循环的迭代，我们可以在continue标签的帮助下这样做。

fun main(args : Array<String>){

    mtloop@ for (x in 'A'..'D'){
        for (n in 1..4){
            if (n==2||n==4)
                continue @myloop

            println("$x and $n")
        }

    }
}

输出：

A and 1
B and 1
C and 1
D and 1

基本上这里发生的是，一旦n值达到 2，控制流就会因为标签而跳到外循环的末尾，并且每次迭代都会发生这种情况。continue 标签的语法非常简单，因为您只需要在标签后附加@符号，并且需要在continue语句后附加相同的名称，如上例所示。

在 Eclipse IDE 中创建并运行您的第一个 Kotlin 项目

原文： https://beginnersbook.com/2017/12/kotlin-in-eclipse-ide/

在本教程中，我们将了解如何在 Eclipse IDE 中安装 Kotlin 插件，以在 Eclipse IDE 中创建和运行第一个 Kotlin 应用。

安装 Kotlin 插件

第 1 步：如果你没有安装了 Eclipse IDE ，你可以从这个链接下载它： https://www.eclipse.org/downloads/ Be 一定要抓住“Eclipse IDE for Java Developers”捆绑包。要在 Eclipse IDE 中运行 Kotlin，您必须具有 Eclipse Neon 或更高版本的 IDE。我正在使用 Elipse Oxygen。

第 2 步：要在 Eclipse 中安装 Kotlin 插件，请转到 Eclipse IDE 菜单中的 Help 部分，然后单击“Eclipse Marketplace”。在搜索字段中键入“Kotlin”搜索 kotlin 插件，然后单击“go”。单击安装以安装 Kotlin 插件，如下面的屏幕截图所示。

Eclipse MarketPlace For Kotlin Installation

Install Kotlin Plugin Eclipse IDE

步骤 3：安装完成后，接受协议并单击“完成”。

在 Eclipse IDE 中打开 Kotlin 透视图

单击下面屏幕截图中显示的图标，打开 Eclipse IDE 中的透视窗口。您可以在 Eclipse IDE 的右上角找到此图标。或者，您可以从菜单“窗口 -> 开放视角 -> 其他”打开透视窗口。

选择 Kotlin 并单击“打开”。

Eclipse Perspective Kotlin

在 Eclipse 中创建第一个 Kotlin 项目

“文件 -> 新建 -> Kotlin 项目”。提供项目名称并单击“完成”。

Kotlin Project

在 Kotlin 项目中创建项目文件

“项目 -> 右键单击 src -> 新建 -> Kotlin 文件”。提供有意义的文件名并单击“完成”。 Kotlin 文件的扩展名为.kt。

Kotlin File in Kotlin Project
在文件中输入以下代码：

fun main(args : Array) {
    println("Hello, World!")
}

运行第一个程序

“右键单击文件 -> 运行为 -> Kotlin 应用”

hello world kotlin program

输出：

Output First Kotlin Project

Kotlin `break`语句

原文： https://beginnersbook.com/2019/02/kotlin-break/

break语句用于在不评估循环条件的情况下立即终止循环。一旦在循环内遇到break语句，循环就立即终止而不执行break语句之后的其余语句。在本指南中，我们将了解break如何工作，我们还将讨论break标签。

Kotlin `break`示例

break语句通常与if表达式一起使用。

fun main(args : Array<String>){

    for(n in 1..10){
        println("before break, Loop: $n")
        if (n==5) {
            println("I am terminating loop")
            break
        }
    }
}

输出：

Kotlin break example

正如您可以在输出中观察到，一旦遇到中断，循环就会终止。

Kotlin 打破了嵌套循环中的示例

当在嵌套循环中使用 break 时，它会在遇到内部循环时终止它。

fun main(args : Array<String>){

    for(ch in 'A'..'C'){
        for (n in 1..4){
            println("$ch and $n")
            if(n==2)
                break
        }
    }
}

输出：

Kotlin break nested loop

正如您可以在输出中观察到外部循环永远不会终止，但内部循环终止了 3 次。

Kotlin `break`标签

让我们谈谈标签吧。与继续标签类似，break标签使我们能够更好地控制在遇到中断时终止哪个循环。

在上面的嵌套循环示例中，内部循环在遇到中断时终止。让我们在标签的帮助下编写一个程序来终止外循环而不是内循环。

fun main(args : Array<String>){

    myloop@ for(ch in 'A'..'C'){
        for (n in 1..4){
            println("$ch and $n")
            if(n==2)
                break @myloop
        }
    }
}

输出：

A and 1
A and 2

标签的语法很简单，我们只需要在循环前面使用我们想要break的任何名称后跟@，以及在break关键字后面附加前缀为@的同一名称，如上例所示。

Kotlin 函数

原文： https://beginnersbook.com/2019/02/kotlin-function/

函数是一起执行特定任务的相关语句块。例如，假设我们必须编写三行代码来查找两个数字的平均值，如果我们创建一个函数来查找平均值，那么我们可以只调用我们创建的函数，而不是一次又一次地写这三行。

Kotlin 中的函数类型

Kotlin 中有两种类型的函数：

标准库函数
用户定义的函数

Kotlin function

1.标准库函数

已经存在于 Kotlin 标准库中的函数称为标准库函数或内置函数或预定义函数。例如，当我们需要使用Math.floor()函数时，我们不定义函数，因为它已经存在，我们可以在代码中直接调用它。

标准库函数示例

fun main(args : Array<String>){

    var num = 16
    println("Square root of $num is: ${Math.sqrt(num.toDouble())}")

}

输出：

Kotlin standard library function

2.用户定义的函数

我们在调用它们之前在程序中定义的函数称为用户定义的函数。例如，假设我们想要一个函数在我们的程序中检查偶数或奇数，然后我们可以为此任务创建一个函数，然后调用我们需要执行检查的函数。

用户定义的函数示例

我们使用fun关键字创建一个函数。让我们创建一个打印"Hello"的函数。

//Created the function
fun sayHello(){
    println("Hello")
}
fun main(args : Array<String>){

    //Calling the function
    sayHello()

}

输出：

Hello

用户定义的函数，带参数和返回类型

语法：

fun function_name(param1: data_type, param2: data_type, ...): return_type

让我们创建一个用户定义的函数，接受参数并具有返回类型。在下面的程序中，我们声明了一个函数sum。这个函数接受可变数量的参数，这就是我们使用vararg的原因，这些参数是整数类型，函数的返回类型也是整数。

//Created the function
fun sum(vararg numbers: Int): Int
{
    var sum = 0
    numbers.forEach {num -> sum +=  num}

    return sum
}
fun main(args : Array<String>){

    println("Sum: ${sum(10, 20, 30, 40)}")

}

输出：

Kotlin user defined function

Kotlin 内联函数

可以在main()函数内定义内联函数。让我们举一个内联函数的例子。在下面的例子中，我们定义了一个内联函数sum，它接受两个整数参数num1和num2，返回类型是整数。

fun main(args : Array<String>){

    val sum = {num1: Int, num2: Int -> num1 + num2}

    println("6 + 4 = ${sum(6,4)}")

}

输出：

6 + 4 = 10

Kotlin 递归和尾递归

原文： https://beginnersbook.com/2019/03/kotlin-recursion-and-tail-recursion/

如果函数调用自身，则该函数称为递归函数，此过程称为递归。

递归函数如何看起来像？

这里函数myfunction()调用自身，这是一个递归函数。

fun myfunction(){    
  //some code  
  ....
  //myfunction() calling myfunction()
  myfunction()   
}

让我们举个例子来理解递归。

Kotlin 递归示例

这是阶乘的一个简单例子。这里我们定义了一个函数fact()来计算它作为参数传递给该函数的数字的阶乘。在函数体中我们再次调用此函数，此过程称为递归。

要求用户输入正整数，并根据输入，程序通过将输入数作为参数传递给用户定义函数fact()来查找输入数的阶乘。

fun main(args: Array<String>) {
    print("Enter a positive integer number: ")
    val number: Int =Integer.valueOf(readLine())
    val factorial = fact(number)
    println("Factorial of $number = $factorial")
}

//recursive function
fun fact(num: Int): Int {
    return if(num == 1){
        num
    }
    else{
        //function fact() calling itself
        num*fact(num-1)
    }
}

输出：

Kotlin Recursion example

尾递归

在递归中，计算在递归调用之后完成，我们在上面看到的阶乘的例子是递归或头递归的一个例子，其中计算n的阶乘，我们需要n-1的阶乘。

在尾递归中，计算在递归调用之前的开始处完成。在尾递归中，递归函数的调用发生在函数的末尾。这意味着首先完成计算，然后传递给下一个递归调用。

让我们举一个尾递归的例子。

尾递归示例

要声明尾递归函数，我们在函数之前使用tailrec修饰符。

fun main(args: Array<String>) {
    val number = 6
    val factorial = fact(number)
    println("Factorial of $number = $factorial")
}

tailrec fun fact(n: Int, temp: Int = 1): Int {
    return if (n == 1){
        temp
    } else {
        fact(n-1, temp*n)
    }
}

输出：

Tail Recursion

Kotlin 默认和命名参数

原文： https://beginnersbook.com/2019/03/kotlin-default-and-named-argument/

在本指南中，我们将学习在 Kotlin 函数中使用的默认和命名参数。

Kotlin 默认参数

我们已经学习了函数如何具有参数，并且我们可以在调用函数时传递这些参数的值，通过使用默认参数，我们可以在定义函数时设置这些参数的默认值。让我们举个例子来理解默认参数。

默认参数示例

函数调用期间未传递任何值

fun main(args: Array<String>) {
    demo()
}
fun demo(number:Int= 100, ch: Char ='A'){
    print("Number is: $number and Character is: $ch")
}

输出：

Number is: 100 and Character is: A

在上面的例子中，我们在调用函数demo()时没有传递任何值，让我们看看当我们将值传递给已经为其参数设置了默认值的函数时会发生什么。

在函数调用期间传递一些参数值

fun main(args: Array<String>) {
    demo(99)
}
fun demo(number:Int= 100, ch: Char ='A'){
    print("Number is: $number and Character is: $ch")
}

输出：

Kotlin default arguments

正如您在输出中看到的那样，当我们在调用函数时传递值时，它会覆盖默认值。在上面的例子中，我在调用函数时传递了一个值，这就是为什么它只覆盖第一个默认值，但是我们也可以为所有参数传递值，这将覆盖所有默认值。

在函数调用期间传递所有参数的值

fun main(args: Array<String>) {
    demo(99, 'Z')
}
fun demo(number:Int= 100, ch: Char ='A'){
    print("Number is: $number and Character is: $ch")
}

输出：

Number is: 99 and Character is: Z

Kotlin 命名参数

在上面的例子中，我们学习了如何设置参数的默认值。在第二个例子中我们了解到我们可以在传递几个值时调用函数，我们在第二个例子demo(99)中进行了这样的函数调用，它会覆盖第一个默认值。但是，如果我们只想覆盖第二个默认值，那么我们可以在命名参数的帮助下完成。

fun main(args: Array<String>) {
    demo(ch='Z')
}
fun demo(number:Int= 100, ch: Char ='A'){
    print("Number is: $number and Character is: $ch")
}

输出：

Kotlin named arguments

如您所见，我们在函数调用demo(ch='Z')期间使用参数名称覆盖了第二个参数的默认值。如果我们在没有像demo('Z')这样的命名参数的情况下完成此操作，则会抛出错误，因为它会尝试使用此值覆盖第一个整数参数。

Kotlin Lambda 函数

原文： https://beginnersbook.com/2019/03/kotlin-lambda-function/

Lambda 函数也称为匿名函数，因为它没有名称。参数位于箭头的左侧，实际代码位于箭头的右侧。别担心，我们会举一个例子来解释这一点。

Lambda 函数的外观如何？

{my_var -> actual_code_implementation}

Kotlin Lambda 函数示例

在下面的示例中，我们定义了一个 lambda 函数来添加两个整数。 lambda 函数用花括号定义，箭头的左边是我们的数据类型的参数，箭头的右边是函数体。

fun main(args: Array<String>){
    //lambda function
    val sum = {num1: Int, num2: Int -> num1 + num2}
    println("10+5: ${sum(10,5)}")
}

输出：

Kotlin Lambda function

Kotlin 高阶函数

原文： https://beginnersbook.com/2019/03/kotlin-higher-order-function/

高阶函数或更高阶函数可以将另一个函数作为参数或返回函数，或者可以同时执行这两个函数。到目前为止我们已经看到如何将整数，字符串等作为参数传递给函数，但在本指南中，我们将学习如何将函数传递给另一个函数。我们还将看到函数如何返回另一个函数。

Kotlin 高阶函数示例：将函数传递给另一个函数

在下面的例子中，我们将函数demo()传递给另一个函数func()。要将函数作为参数传递给其他函数，我们在函数之前使用::运算符，如下例所示。

fun main(args: Array<String>) {

    func("BeginnersBook", ::demo)

}

fun func(str: String, myfunc: (String) -> Unit) {
    print("Welcome to Kotlin tutorial at ")
    myfunc(str)
}
fun demo(str: String) {
    println(str)
}

输出：

Kotlin Higher order function

Kotlin 高阶函数示例：函数返回另一个函数

在以下示例中，自定义函数func正在返回另一个函数。

要理解这段代码，让我们首先看一下函数func，它接受一个整数参数num，在返回区域我们定义了一个函数(Int) -> Int = {num2 -> num2 + num}，所以这是另一个接受整数参数的函数并返回该参数和num的总和。

您可能想知道为什么我们将值 20 作为sum中的参数传递，这是因为函数func返回了函数，因此sum是接受int参数的函数。这与我们在函数func的返回区域中定义的函数相同。

fun main(args: Array<String>) {

    val sum = func(10)
    println("10 + 20: ${sum(20)}")

}

fun func(num: Int): (Int) -> Int = {num2 -> num2 + num}

输出：

Kotlin higher order function returns another function

Kotlin 异常处理

原文： https://beginnersbook.com/2019/03/kotlin-exception-handling/

异常是在程序运行时可能发生的不必要的问题，并突然终止您的程序。异常处理是一个过程，使用它可以防止程序出现可能破坏我们代码的异常。

有两种类型的异常：

受检的异常声明为方法签名的一部分，并在编译时检查，例如IOException
非受检的异常不需要作为方法的一部分添加签名，并在运行时检查它们，例如NullPointerException。

注意：在 Kotlin 中，所有异常情况都非受检。

处理 Kotlin 中的异常与 Java 相同。我们使用try，catch和finally块来处理 kotlin 代码中的异常。

Kotlin 异常处理示例

在下面的例子中，我们将一个数字除以 0（零），这应该抛出ArithmeticException。由于此代码在try块中，因此将执行相应的catch块。

在这种情况下，发生了ArithmeticException，因此执行了ArithmeticException的catch块，并在输出中打印了"Arithmetic Exception"。

当发生异常时，它会忽略该点之后的所有内容，并且控制流会立即跳转到catch块（如果有的话）。无论是否发生异常，始终执行finally块。

fun main(args: Array<String>) {
    try {

        var num = 10/0
        println("BeginnersBook.com")
        println(num)

    } catch (e: ArithmeticException) {
        println("Arithmetic Exception")
    } catch (e: Exception) {
        println(e)
    } finally {
        println("It will print in any case.")
    }
}

输出：

Kotlin exception handling

如果我们不处理异常会怎么样？

假设我们在上面的例子中没有处理异常，那么程序会突然终止。
这里我们没有处理异常，所以程序因错误而终止。

fun main(args: Array<String>) {

        var num = 10/0
        println("BeginnersBook.com")
        println(num)
}

输出：

Kotlin exception handling error when we don't handle them

如何在 Kotlin 中抛出异常

我们也可以使用throw关键字抛出异常。在下面的示例中，我们使用throw关键字抛出异常。异常执行前的语句已执行，但异常后的语句未执行，因为控制流已转移到catch块。

fun main(args: Array<String>) {
    try{
        println("Before exception")
        throw Exception("Something went wrong here")
        println("After exception")
    }
    catch(e: Exception){
        println(e)

    }
    finally{
        println("You can't ignore me")
    }
}

输出：

Kotlin throw keyword

Kotlin `try-catch`

原文： https://beginnersbook.com/2019/03/kotlin-try-catch/

在上一个教程中，我们学习了什么是异常处理。在本指南中，我们将看到try catch块的各种示例。我们还将看到如何使用try作为表达式。

`try catch`块的语法

try {
    //code where an exception can occur
}
catch (e: SomeException) {
    // handle the exception
}
finally {
    // optional block but executes always
}

try块可以与多个catch块相关联，但是只能存在一个finally块。

Kotlin `try catch`块示例

在这个例子中，我们放置了可能导致try块内异常的代码。一旦异常发生在try块内，它就会查找处理发生的异常的相应catch块。由于在代码中发生了ArithmeticException并且在catch块中处理了相同的异常，因此执行catch块中的代码。

异常处理的主要优点是程序不会突然终止。在以下示例中，最后一个println语句println("Out of try catch block")在catch块之后执行。如果我们没有进行异常处理，则不会执行此语句，因为程序将在行var num = 100/0上终止

fun main(args: Array<String>) {
    try{
        var num = 100/0
        println(num)
    }
    catch(e: ArithmeticException){
        println("Arithmetic Error in the code")

    }
    println("Out of try catch block")
}

输出：

Kotlin try catch block example

Kotlin 没有`catch`块的`try`块

try块可以没有catch块，但在这种情况下必须存在finally块。 总之，你可以说至少应该有一个catch或finally块。finally块是可选的，但是当没有catch块时，必须有一个finally块。

fun main(args: Array<String>) {
    try{
        var num = 10/5
        println(num)
    }
    finally{
        println("Finally block")
    }

    println("Out of try catch block")
}

输出：

2
Finally block
Out of try catch block

Kotlin 多个`catch`块

原文： https://beginnersbook.com/2019/03/kotlin-multiple-catch-blocks/

try块可以有多个catch块。当我们不确定try块内是否会发生所有异常时，为潜在的异常设置多个catch块总是一个好主意，并且在最后一个 catch 块中有父异常类来处理未指定的剩余异常通过catch块。

Kotlin 多个`catch`块的例子

在下面的示例中，我们有多个catch块，但是当发生异常时，它会查找该特定异常的处理程序。

这里发生的异常是算术异常，但是前两个catch块没有处理算术异常，这就是为什么执行第三个catch块的代码。第三个块处理所有异常，因为它使用Exception类，它是所有异常类的父类。

fun main(args: Array<String>) {
    try{
        var num = 10/0
        println(num)
    }
    catch(e: NumberFormatException){
        println("Number format exception")
    }
    catch(e: ArrayIndexOutOfBoundsException){
        println("Array index is out of range")
    }
    catch(e: Exception){
        println("Some Exception occurred")
    }

    println("Out of try catch block")
}

输出：

Kotlin multiple catch blocks

多个`catch`块的另一个例子

下面是多个catch块的另一个例子，这里发生了ArrayIndexOutOfBoundsException，因为这个异常存在一个处理程序（catch块），执行处理程序内部的代码。

fun main(args: Array<String>) {
    try{
        val a = IntArray(5)
        a[10] = 99
    }
    catch(e: ArithmeticException){
        println("ArithmeticException occurred")
    }
    catch(e: NumberFormatException){
        println("Number format exception")
    }
    catch(e: ArrayIndexOutOfBoundsException){
        println("Array index is out of range")
    }
    catch(e: Exception){
        println("Some error occurred")
    }

    println("Out of try catch block")
}

输出：

Kotlin multiple catch blocks example

为什么在最后一个`catch`块中使用父`Exception`类是个好主意

让我们采用我们上面的相同示例，但在此代码中，我们做了一个小改动。这里我们首先得到父Exception类的处理程序（catch块）。

在代码中发生了ArrayIndexOutOfBoundsException并且我们有这个特殊异常的处理程序，但是因为我们首先有一般的Exception类，它处理所有异常所以它被执行而不是处理ArrayIndexOutOfBoundsException的catch块。

以顺序方式检查catch块，以便执行第一个catch块，实际上在任何异常的情况下，第一个catch将执行，这是一个糟糕的编程习惯，因为我们想要一个特定的消息而不是一般化的消息。因此，解决方案是在最后一个位置使用此默认处理程序，就像我们在上面的示例中所做的那样。

fun main(args: Array<String>) {
    try{
        val a = IntArray(5)
        a[10] = 99
    }
    catch(e: Exception){
        println("Some error occurred")
    }
    catch(e: ArithmeticException){
        println("ArithmeticException occurred")
    }
    catch(e: NumberFormatException){
        println("Number format exception")
    }
    catch(e: ArrayIndexOutOfBoundsException){
        println("Array index is out of range")
    }
    println("Out of try catch block")
}

输出：

Kotlin general Exception handling in multiple catch blocks

Kotlin 嵌套`Try-Catch`块

原文： 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{
     //code
     try{
           //code
     }
     catch
     {
          //handler
     }
}
catch
{
          //handler
}

嵌套的`Try-Catch`块示例

在下面的示例中，内部try块中存在异常，但是在内部catch块中未处理发生的异常（ArithmeticException），因此检查外部catch块是否存在此异常，因为外部catch块正在处理此异常，代码对于ArithmeticException，执行外部的catch块。

try块中可以有多个try catch块，内部try块内也可以有try catch块。这里要注意的唯一事情是，如果在子try块中没有处理异常，那么将检查父try catch块的处理程序是否发生了异常。

fun main(args: Array<String>) {
    try {
        val num = 100 / 5
        println(num)
        try {
            val num2 = 100 / 0
            println(num2)
        }
        catch(e: NumberFormatException){
            println("Number Format Exception")
        }
    }
    catch(e: ArithmeticException){
        println("Arithmetic Exception")
    }
}

输出：

Kotlin Nested Try Catch example

在 IntelliJ IDEA 中创建并运行您的第一个 Kotlin 项目

原文： https://beginnersbook.com/2017/12/create-and-run-your-first-kotlin-project-in-intellij-idea/

在上一个教程中，我们已经看到如何在 Eclipse IDE 中创建和运行您的第一个 Kotlin 项目。在本指南中，我们将看到如何安装 IntelliJ IDEA ，这是一个由开发 Kotlin 编程语言的 JetBrains 开发的 IDE。我们还将看到如何在 IntelliJ IDEA 中创建和运行第一个 Kotlin 项目。

IntelliJ IDEA 安装

转到官方 Jetbrains 网站的下载页面。选择操作系统并下载社区版。

download IntelliJ IDEA IDE

在 IntelliJ IDEA IDE 中创建您的第一个 Kotlin 项目

第 1 步：选择“创建新项目”。

create new kotlin project

步骤 2：在“Additional Libraries and Frameworks”部分中，选择“Kotlin / JVM”并单击“Next”。

select kotlin JVM

第 3 步：提供项目名称，然后单击“完成”。

Give Kotlin project name

第 4 步：在 Kotlin 项目的“src”文件夹中创建一个新的 Kotlin 文件。

create new kotlin file in project

第 5 步：输入代码

步骤 6：要运行 Kotlin 文件，请单击位于左侧的 Kotlin 图标，如下面的屏幕截图所示。选择“Run'HelloKt'”来运行该文件。

Run Kotlin Project

第 7 步：如果一切顺利，您应该在屏幕底部看到程序的输出。

Output Of First kotlin Project

Kotlin `throw`关键字

原文： https://beginnersbook.com/2019/03/kotlin-throw-keyword-with-example/

在这个简短的指南中，我们将学习如何在 Kotlin 中使用throw关键字抛出异常。

Kotlin `throw`关键字示例

在下面的示例中，我们使用throw关键字抛出异常。在这里我抛出了父Exception类，你可以抛出任何异常，如ArithmeticException，ArrayIndexOutOfBoundsException等。

fun main(args: Array<String>) {
    print("Enter your name: ")
    val name = readLine()

    try{
        if (name == "Chaitanya"){
            throw Exception("You don't have access")
        }
        else
        {
            println("Welcome! You have access")
        }
    }
    catch (e: Exception){
        println(e.message)
    }
}

输出：

Kotlin throw keyword example

Kotlin 异常处理中的`try`表达式

原文： https://beginnersbook.com/2019/03/kotlin-try-as-an-expression/

Kotlin 中的try块可以作为表达式使用。它可以像任何其他表达式一样返回一个值，返回的值可以存储在一个变量中。在本指南中，我们将学习如何在 Kotlin 中使用try作为表达式。

Kotlin `try`表达式的例子

在以下示例中，try块用作表达式，try返回的值可以存储在变量中，如以下示例所示。

fun main(args: Array<String>) {
    var website = "Beginnersbook.com"
    var num = try {
        website.toInt()
    }
    catch (e: NumberFormatException)
    {
        "Cannot convert String to integer"
    }
    println(num)

    var number = "100"
    var num2 = try {
        number.toInt()
    }
    catch (e: NumberFormatException)
    {
        "Cannot convert String to integer"
    }
    println(num2)
}

输出：

Kotlin try expression

Kotlin 类和对象 - 面向对象编程（OOP）

原文： https://beginnersbook.com/2019/03/kotlin-class-and-objects-oop/

Kotlin 是一种面向对象的编程语言，就像 Java 一样。面向对象编程（OOP）允许我们通过使用对象来解决复杂问题。在本指南中，我们将学习什么是类，什么是对象以及面向对象编程（OOP）的其他几个特性。

Kotlin 类

类是任何面向对象编程语言的主要构建块。所有对象都是类的一部分，并分别以数据成员和成员函数的形式共享由类定义的公共属性和行为。

类就像对象的蓝图。

类就像对象的原型，您可以通过对方法和变量进行分组来创建。

如何在 Kotlin 中定义一个类

在 Kotlin 中使用class关键字定义类。例如：

class MyClass {
  // variables or data members
  // member functions
  ..
  ..
}

Kotlin 类示例

在下面的例子中，我们有一个类Example，在该类中我们有一个数据成员number和一个成员函数calculateSquare()。数据成员也称为属性和成员函数，作为面向对象编程语言术语中的行为。此类的对象共享这些属性和行为。

class Example {

    // data member
    private var number: Int = 5

    // member function
    fun calculateSquare(): Int {
        return number*number
    }
}

我没有在上面的类中指定任何访问修饰符。访问修饰符限制访问。默认情况下，访问修饰符为public。在上面的例子中，我们没有指定任何访问修饰符，因此默认情况下public访问修饰符适用于上述类Example

上述类中的数据成员被指定为private，这意味着数据成员number在类Example之外是不可访问的。

如何定义访问修饰符？

访问修饰符在class关键字之前指定。

private class MyClass {

}

其他访问修饰符：

private - 只能在类内访问。
public - 可随处访问。
protected - 只能在类及其子类访问。
internal - 可以在模块内部访问。

Kotlin 对象

对象使用类的属性和行为。如上所述，类只是一个蓝图，没有为类分配内存。一旦创建了类的对象，它们就会占用内存空间，并使用类的数据成员和成员函数对数据执行各种操作。

如何创建类的对象

假设我的类名是Example，这个类的对象可以像这样创建：

Example e = Example()

注意：这里我将对象命名为e，除了 Kotlin 中已定义的关键字外，您可以为对象指定任何名称。这里需要注意的另一点是，与我们使用new关键字来创建对象的 java 不同，我们在这里不使用new关键字，实际上如果你使用它，你将得到一个编译错误。

如何访问数据成员和成员函数

使用对象e访问类Example的数据成员number和成员函数calculateSquare。

//Access data member
e.number

//Access member function
e.calculateSquare()

让我们举一个完整的例子来理解上面讨论过的概念。

Kotlin 对象的例子

class Example {

    // data member
    private var number: Int = 5

    // member function
    fun calculateSquare(): Int {
        return number*number
    }
}

fun main(args: Array<String>) {

    // create obj object of Example class
    val obj = Example()
    println("${obj.calculateSquare()}")
}

输出：

Kotlin class objects

Kotlin 构造器

原文： https://beginnersbook.com/2019/03/kotlin-constructors/

构造器的主要目的是初始化类的属性。在创建类的对象时调用构造器。在 Kotlin 中，我们有两种类型的构造器 - 主构造器和次要构造器。在本指南中，我们将通过示例学习主要和次要构造器，我们还将了解初始化程序块。

Kotlin 中的构造器类型

Kotlin Constructors

主构造器 - 初始化类
的属性
次要构造器 - 初始化类的属性，我们可以在次要构造器中有额外的初始化代码。

1.主构造器

主构造器是初始化类的最简单方法。它被声明为类头的一部分。在下面的示例中，我们将构造器(val name: String, var age: Int)声明为类头的一部分。这是我们的主要构造器，它初始化类Student的name和age属性（数据成员）。

fun main(args: Array<String>) {

    //creating the object of class Student
    val stu = Student("Chaitanya", 31)

    println("Student Name: ${stu.name}")
    println("Student Age: ${stu.age}")
}

class Student(val name: String, var age: Int) {
    //This is my class. For now I am leaving it empty
}

输出：

Kotlin constructor example

Kotlin 构造器中的默认值

我们也可以像在下面的例子中那样在 Kotlin 构造器中指定默认值。在这里，我们将默认学生姓名指定为"Student"，默认学生年龄为 99。

我们创建了这个类的三个对象，一个具有名称和年龄，第二个对象只有名称，第三个对象没有名称和年龄。正如您在输出中所看到的，创建类的对象时默认值被传递的值覆盖。

fun main(args: Array<String>) {

    //creating the object of class Student
    val stu = Student("Chaitanya", 31)
    val stu2 = Student("Chaitanya")
    val stu3 = Student()

    println("Name: ${stu.name} and Age: ${stu.age}")
    println("Name: ${stu2.name} and Age: ${stu2.age}")
    println("Name: ${stu3.name} and Age: ${stu3.age}")

}

class Student(val name: String = "Student", var age: Int = 99) {
    //This is my class. For now I am leaving it empty
}

输出：

Default value in Kotlin constructor

Kotlin 构造器中的初始化程序块

让我们学习在类的构造器中有额外的初始化代码。在下面的例子中，我们有一个初始化块，我们在构造器中使用init声明了它。在这个块中，我们可以有额外的初始化逻辑。

fun main(args: Array<String>) {

    val stu = Student("Chaitanya", 31)
    val stu2 = Student("Chaitanya")
    val stu3 = Student()

}

class Student(val name: String = "Student", var age: Int = 99) {
    val stuName: String
    var stuAge: Int
    init{
        if(name == "Student") {
            stuName = "NA"
            stuAge = 0
        }
        else {
            stuName = name.toUpperCase()
            stuAge = age
        }
        println("Student Name is: $stuName")
        println("Student Age is: $stuAge")
    }
}

输出：

Initializer Block inside Kotlin Constructor

2. Kotlin 次要构造器

Kotlin 中的次要构造器是使用constructor关键字创建的。他们在继承中发挥着重要作用。我建议您在通过次要构造器之前先阅读继承主题。

次要构造器的语法

class Student {
    constructor(name: String) {
        // code inside constructor
    }
    constructor(name: String, age: Int) {
        // code inside constructor
    }
}

次要构造器的示例

这是如何在类中声明次要构造器的简单示例。

fun main(args: Array<String>){
    val obj = Student ("Ajeet", 30)
}

class Student{
    constructor(name: String, age: Int){
        println("Student Name: ${name.toUpperCase()}")
        println("Student Age: $age")
    }
}

输出：

Student Name: AJEET
Student Age: 30

从另一个调用一个次要构造器

在这个例子中，我们有两个次要构造器，一个具有一个参数，另一个具有两个参数。我们使用this关键字从另一个构造器调用构造器。

fun main(args: Array<String>){
    val obj = Student ("Ajeet")
}
class Student{
    constructor(name: String): this(name, 0){
        println("secondary constructor with one param")
    }
    constructor(name: String, age: Int){
        println("secondary constructor with two param")
        println("Student Name: ${name.toUpperCase()}")
        println("Student Age: $age")
    }
}

输出：

Kotlin secondary constructor

带有父类和子类的 Kotlin 次要构造器示例

在下面的例子中，我们有两个类College，它是父类和子类Student。这里子类的次要构造器使用super关键字调用父类的次要构造器。

fun main(args: Array<String>){
    val stu = Student("Harry", 24)
}

open class College{

    constructor(name: String, age: Int){
        println("parent class constructor")
        println("Student Name: ${name.toUpperCase()}")
        println("Student Age: $age")
    }
}
class Student: College{
    constructor(name: String, age: Int): super(name,age){
        println("child class constructor")
        println("Student Name: $name")
        println("Student Age: $age")
    }
}

输出：

parent class constructor
Student Name: HARRY
Student Age: 24
child class constructor
Student Name: Harry
Student Age: 24

Kotlin 继承

原文： https://beginnersbook.com/2019/03/kotlin-inheritance/

继承是一个函数，使用该函数继承另一个类的所有函数。从中继承要素的类称为基类或超类或父类，并且继承要素的类称为派生类或子类或子类。在本指南中，我们将借助示例了解什么是继承以及如何在 Kotlin 中实现它。

什么是继承以及为什么需要它？

假设我们有三个类Dog，Cat和Horse。所有这三个类都有一些属性（数据成员）和一些行为（成员函数）。我们在下图中描述了这些类的属性和行为。

Kotlin Inheritance

我们可以在图中看到这三个类具有很少的属性和行为，为什么不创建具有公共属性和行为的泛化类，让这三个类继承该泛化类。此外，除了继承的类之外，这些类可以具有其独特的属性和行为。

Kotlin inheritance example

所以Dog类现在继承了Animal类的所有函数，并添加了一个额外的函数woof()，同样Cat类继承了Animal类的所有函数，并添加了它的独特函数meow()等等。

让我们在 Kotlin 程序中写下这个逻辑。

注意：默认情况下，Kotlin 中的所有类都是最终的，所以你必须在父类中使用open注释，这告诉编译器这个类可以被其他类继承。

open class Animal(colour: String, age: Int) {
    init {
        println("Color is: $colour.")
        println("Age is: $age")
    }
}

class Dog(colour: String, age: Int): Animal(colour, age) {

    fun woof() {
        println("Dog makes sound of woof")
    }
}

class Cat(colour: String, age: Int): Animal(colour, age) {

    fun meow() {
        println("Cat makes sound of meow")
    }
}

class Horse(colour: String, age: Int): Animal(colour, age) {

    fun neigh() {
        println("Horse makes sound of neigh")
    }
}

fun main(args: Array<String>) {
    val d = Dog("Black",4)
    d.woof()
    val c = Cat("White", 1)
    c.meow()
    val h = Horse("Brown", 8)
    h.neigh()
}

输出：

Kotlin inheritance example

覆盖 Kotlin 中的成员函数和属性

如果子类中存在具有相同名称的函数或属性，则我们需要使用override关键字在子类中覆盖它们。

覆盖成员函数

子类可以使用override关键字覆盖父类的成员函数。通过重写函数，子类为现有的基类代码提供自己的实现。覆盖并不意味着它将更新基类中的代码，该更改仅适用于覆盖函数或其子类的类。让我们举个例子。

open class Animal() {
    open fun sound() {
        println("Animal makes a sound")
    }
}

class Dog: Animal() {
    override fun sound() {
        println("Dog makes a sound of woof woof")
    }
}

fun main(args: Array<String>) {
    val d = Dog()
    d.sound()
}

输出：

Dog makes a sound of woof woof

覆盖基类的属性（数据成员）

我们可以覆盖基类的属性，类似于我们在上面看到的成员函数。在下面的示例中，我们在父类中有一个属性颜色，我们在子类中重写它。

open class Animal() {
    open var colour: String = "White"
}

class Dog: Animal() {
    override var colour: String = "Black"
    fun sound() {
        println("Dog makes a sound of woof woof")
    }
}

fun main(args: Array<String>) {
    val d = Dog()
    d.sound()
    println("${d.colour}")
}

输出：

Dog makes a sound of woof woof
Black

从子类调用基类的数据成员和成员函数

在下面的示例中，我们使用super关键字从Child类调用父类的数据成员num和成员函数demo()。

open class Parent() {
    open var num: Int = 100
    open fun demo(){
        println("demo function of parent class")
    }
}

class Child: Parent() {
    override var num: Int  = 101
    override fun demo() {
        super.demo()
        println("demo function of child class")
    }
    fun demo2(){
        println(super.num)
    }
}

fun main(args: Array<String>) {
    val obj = Child()
    obj.demo()
    obj.demo2()
}

输出：

demo function of parent class
demo function of child class
100

Kotlin 可见性修饰符 - 公共，私有，受保护和内部

原文： https://beginnersbook.com/2019/03/kotlin-visibility-modifiers/

可见性修饰符将类，接口，函数，属性，构造函数等的访问限制到某个级别。在 kotlin 中，我们有四个可见性修饰符 - 公共，私有，受保护和内部。在本指南中，我们将借助示例了解这些可见性修饰符。

Kotlin 可见性修饰符

public：在任何地方都可见，这是 Kotlin 中的默认可见性修饰符，这意味着如果你没有指定修饰符，它默认是公共的。
private：包含声明的文件内可见。如果数据成员或成员函数在类中声明为private，则它们仅在类中可见。
protected：内部类和子类可见。
internal：在同一模块内可见。

让我们举个例子。在下面的示例中，我们有一个文件Example.kt，我们已经在文件中声明了一个数据成员，几个成员函数和一个类。注释中提到了每一个的可见性。

// file name: Example.kt

package beginnersbook.com

// public so visible everywhere
var str = "BeginnersBook"

// By default public so visible everywhere
fun demo() {}

// private so visible inside Example.kt only
private fun demo2() {}

// visible inside the same module
internal fun demo3() {}

// private so visible inside Example.kt
private class MyClass {}

Kotlin 可见性修饰符示例

在这个例子中，我们有两个类Parent类和Child类。我们在示例中使用了所有四种类型的可见性修饰符，请通过注释来了解当前类和子类中每个数据成员和成员函数的可见性。

// file name: Example.kt

package beginnersbook.com

open class Parent() {
    // by default public
    var num = 100

    // visible to this this class only
    private var str = "BeginnersBook"

    // visible to this class and the child class
    protected open val ch = 'A'

    // visible inside the same module
    internal val number = 99

    // visible to this class and child class
    open protected fun demo() { }
}

class Child: Parent() {

    /* num, ch, number and function demo() are
     * visible in this class but str is not visible.
     */
    override val ch = 'Z'
    override fun demo(){
        println("demo function of child class")
    }
}

fun main(args: Array<String>) {
    /* obj.num and obj.number are visible
     * obj.ch, obj.demo() and obj.str not visible
     */
    val obj = Parent()

    /* obj2.ch and obj2.demo() are not visible because if
     * you override protected members in child class without
     * specifying modifier then they are by default protected
     */
    val obj2 = Child()
}

Kotlin 抽象类

原文： https://beginnersbook.com/2019/03/kotlin-abstract-class/

抽象类无法实例化，这意味着我们无法创建抽象类的对象。与其他类不同，抽象类总是打开的，因此我们不需要使用open关键字。

注意事项：

我们无法创建抽象类的对象。
抽象类的属性和成员函数默认为非抽象。如果要在子类中覆盖这些，则需要为它们使用open关键字。
如果成员函数是抽象的，那么它必须在子类中实现。抽象成员函数没有仅主体方法签名，实现在子类中完成。

抽象类示例

在下面的例子中我们有一个抽象类Student，我们不能创建这个类的对象。但是我们可以继承这个类，就像我们在下面的例子中所做的那样。类College继承抽象类Student。

函数func()是一个抽象函数，这意味着它没有正文和唯一的方法签名，但由于它是一个抽象函数，它必须在子类中覆盖。

abstract class Student(name: String, age: Int) {

    init {
        println("Student name is: $name")
        println("Student age is: $age")
    }

    //non-abstract function
    fun demo() {
        println("Non-abstract function of abstract class")
    }

    //abstract function
    abstract fun func(message: String)
}

class College(name: String, age: Int): Student(name, age) {

    override fun func(message: String) {
        println(message)
    }
}

fun main(args: Array<String>) {
    val obj = College("Chaitanya", 31)
    obj.func("I'm a Blogger")
    obj.demo()
}

输出：

Kotlin abstract class

Kotlin 接口

原文： https://beginnersbook.com/2019/03/kotlin-interfaces/

在本指南中，我们将了解接口。与抽象类类似，无法实例化接口，因为它没有任何构造函数。

注意事项：

接口可以同时具有抽象和非抽象函数。
接口只能有抽象属性（数据成员），不允许非抽象属性。
一个类可以实现多个接口。
接口的所有抽象属性和抽象成员函数必须在实现它的类中重写。

Kotlin 接口示例

在下面的例子中，我们有一个接口MyInterface，它包含一个非抽象方法func和抽象属性str和抽象函数demo。

interface MyInterface{
    var str: String

    fun demo()

    fun func(){
        println("Hello")
    }
}

class MyClass: MyInterface{
    override var str: String = "BeginnersBook.com"
    override fun demo() {
        println("demo function")
    }
}
fun main(args: Array<String>) {
    val obj = MyClass()
    obj.demo()
    obj.func()
    println(obj.str)

}

输出：

Kotlin Interfaces

Kotlin - 实现多个接口

在以下示例中，我们有两个接口X和Y。类MyClass实现了接口X和Y。该类为接口X和Y的抽象方法提供了实现。

interface X {

    fun demoX() {
        println("demoX function")
    }
    fun funcX()
}

interface Y  {
    fun demoY() {
        println("demoY function")
    }
    fun funcY()
}

// This class implements X and Y interfaces
class MyClass: X, Y {
    override fun funcX() {
        println("Hello")
    }
    override fun funcY() {
        println("Hi")
    }

}

fun main(args: Array<String>) {
    val obj = MyClass()
    obj.demoX()
    obj.demoY()
    obj.funcX()
    obj.funcY()
}

输出：

Kotlin multiple interfaces example

当多个接口具有相同的方法名称时

在下面的例子中，我们有两个接口X和Y，但这两个接口都具有相同的函数demo()。类MyClass实现了这两个接口，现在当我们尝试使用类的对象调用这个函数demo()时，我们将得到编译错误，因为编译器混淆了调用哪个方法。

interface X {

    fun demo() {
        println("demoX function")
    }
}

interface Y  {
    fun demo() {
        println("demoY function")
    }
}

// This class implements X and Y interfaces
class MyClass: X, Y

fun main(args: Array<String>) {
    val obj = MyClass()
    obj.demo()
}

如何解决相同方法名称的冲突

为了解决上述冲突，我们覆盖了类中的方法，该方法之前导致了冲突。在覆盖方法中，我们使用super关键字确切地指定了要调用的方法。在下面的例子中，我们想调用接口Y的demo()方法，因此我们在覆盖方法中指定了super<Y>.demo()。


interface X {

    fun demo() {
        println("demoX function")
    }
}

interface Y  {
    fun demo() {
        println("demoY function")
    }
}

// This class implements X and Y interfaces
class MyClass: X, Y{
    override fun demo() {
        super<Y>.demo()
    }
}

fun main(args: Array<String>) {
    val obj = MyClass()
    obj.demo()
}

输出：

demoY function

Kotlin 嵌套和内部类

原文： https://beginnersbook.com/2019/03/kotlin-nested-and-inner-class/

在本指南中，您将通过示例了解 Kotlin 中的嵌套和内部类。

Kotlin 嵌套类

当一个类在另一个类中声明时，它被称为嵌套类。嵌套类类似于 Java 中的静态嵌套类。

class OuterClass {
    ....
    class NestedClass {
        ...
    }
}

注意事项：

嵌套类无法访问外部类的成员。
要访问嵌套类的成员，我们将点（.）运算符与外部类一起使用。

Kotlin 嵌套类示例

在下面的示例中，我们有一个外部类和一个嵌套类。此示例演示如何使用点（.）运算符访问嵌套类的成员。

class OuterClass {

    val oStr = "Outer Class"

    class NestedClass {
        val nStr = "Nested Class"
        fun demo() = "demo() function of nested class"
    }
}

fun main(args: Array<String>) {
    // accessing data member of nested class
    println(OuterClass.NestedClass().nStr)

    // accessing member function of nested class
    println(OuterClass.NestedClass().demo())

    // creating object of the Nested class
    val obj = OuterClass.NestedClass()
    println(obj.demo())
}

输出：

Kotlin Nested and Inner Class

Kotlin 嵌套类 - 无法访问外部类的成员

以下程序将抛出编译错误，因为嵌套类无法访问外部类的成员。这里嵌套类试图访问属于外部类的成员oStr，因此我们得到一个编译错误。我们可以通过使用内部类来解决这个问题，这将在同一篇文章的下一节中讨论。

class OuterClass {

    val oStr = "Outer Class"

    class NestedClass {
        val nStr = "Nested Class"
        fun demo() = "demo() function using $oStr"
    }
}

fun main(args: Array<String>) {
    println(OuterClass.NestedClass().demo())
}

输出：

Compilation Error

Kotlin 内部类

使用inner修饰符声明 Kotlin 内部类。内部类可以访问外部类的成员。让我们使用上面使用内部类而不是嵌套类的相同示例。这里我们使用内部内部类访问外部类的成员oStr。

class OuterClass {

    val oStr = "Outer Class"

    inner class InnerClass {
        val nStr = "Nested Class"
        fun demo() = "demo() function using $oStr"
    }
}

fun main(args: Array<String>) {
    val o = OuterClass()
    println("${o.InnerClass().demo()}")

    val i = OuterClass().InnerClass()
    println("${i.demo()}")
}

输出：

Kotlin Inner Class

Kotlin 数据类

原文： https://beginnersbook.com/2019/03/kotlin-data-class/

在 Kotlin 中，您可以创建一个data类来保存数据。您希望将类标记为data的原因是让编译器知道您正在创建此类来保存数据，然后编译器会自动为您的数据类创建多个函数，这将有助于管理数据。在本指南中，我们将学习数据类和编译器自动生成的函数。

数据类学生：

data class Student(val stuName: String, val stuAge: Int)

在 Kotlin 中自动生成数据类的函数

现在我只是在这里提到函数的名称，我们将在示例的帮助下看到它们中的每一个。

equals()
hashCode()
toString()
copy()
componentN()

Kotlin 数据类要求

为了将类标记为数据，该类必须满足某些要求。要求如下：

数据类的主构造函数必须至少有一个参数。此外，参数标记为val或var。
类不能标记为开放，抽象，密封或内部。
该类可以扩展（继承）其他类，它还可以实现其他接口。

Kotlin 数据类示例

在下面的示例中，我们有一个Student类，我们将其标记为数据类。由于我们已将此类声明为data，因此编译器已自动为此类生成了多个函数，如copy()，toString()，equals()等，我们将在接下来的几个示例中讨论这些函数。

data class Student(val name: String, val age: Int)

fun main(args: Array<String>) {
    val stu = Student("Chaitanya", 31)
    val stu2 = Student("Ajeet", 30)
    println("Student Name is: ${stu.name}")
    println("Student Age is:  ${stu.age}")
    println("Student Name is: ${stu2.name}")
    println("Student Age is:  ${stu2.age}")
}

输出：

Kotlin Data class

数据类`hashCode()`和`equals()`方法

如果两个对象在 kotlin 中相同，那么它们具有相同的哈希码，我们可以使用hashCode()方法获得。

方法equals()返回true或false。如果两个对象的hashCode()相等，则equals()返回true，否则返回false。

data class Student(val name: String, val age: Int)

fun main(args: Array<String>) {
    val stu = Student("Chaitanya", 31)
    val stu2 = Student("Chaitanya", 31)
    val stu3 = Student("Ajeet", 30)
    if (stu.equals(stu2) == true)
        println("stu is equal to stu2.")
    else
        println("stu is not equal to stu2.")

    if (stu.equals(stu3) == true)
        println("stu is equal to stu3.")
    else
        println("stu is not equal to stu3.")

    println("Hashcode of stu: ${stu.hashCode()}")
    println("Hashcode of stu2: ${stu2.hashCode()}")
    println("Hashcode of stu3: ${stu3.hashCode()}")
}

输出：

Kotlin hashcode and equals functions

数据类`copy()`方法

通过在数据类中使用copy()方法，我们可以复制其他对象的一些属性。让我们举个例子。这里我们有一个Student类的对象stu，其中包含学生"Steve"的名称，年龄和主题细节，我们创建了另一个名为"Lucy"的对象stu2并使用数据类的copy()方法，复制了stu对象的年龄和主题细节。

data class Student(val name: String, val age: Int, val sub: String)

fun main(args: Array<String>) {
    val stu = Student("Steve", 26, "Math")

    // copying the age and subject from object stu
    val stu2 = stu.copy(name = "Lucy")

    println("stu: Name ${stu.name}, Age ${stu.age} & Subject ${stu.sub}")
    println("stu2: Name ${stu2.name}, Age ${stu2.age} & Subject ${stu2.sub}")
}

输出：

Kotlin data class copy method

数据类`toString()`方法

data类的toString()方法返回对象的String表示形式。

data class Student(val name: String, val age: Int, val sub: String)

fun main(args: Array<String>) {
    val stu = Student("Steve", 26, "Math")
    println(stu.toString())
}

输出：

Student(name=Steve, age=26, sub=Math)

数据类`component()`方法

数据类的componentN()方法将对象解构为多个变量。在下面的例子中，我们有一个Student类的对象stu，我们使用componentN()方法将对象解构为变量。component1()方法返回对象的第一个属性的值，component2()返回第二个属性的值，依此类推。

data class Student(val name: String, val age: Int, val sub: String)

fun main(args: Array<String>) {
    val stu = Student("Steve", 26, "Math")
    val name = stu.component1()
    val age = stu.component2()
    val sub = stu.component3()
    println("Name is: $name")
    println("Age is: $age")
    println("SUbject is: $sub")
}

输出：

Kotlin data class componentN() method

Kotlin Hello World 程序 - 第一个 Kotlin 程序

原文： https://beginnersbook.com/2017/12/kotlin-hello-world-program/

让我们写一个简单的 Kotlin 程序来在屏幕上显示"Hello World"消息。借助这个简单的程序，我们将尝试理解 Kotlin 编程的基础知识。

您可以在 Eclipse IDE 或流行的 IntelliJ IDEA IDE 中运行 Kotlin 程序。您可以参考以下教程来了解如何在这些 IDE 中创建和运行您的第一个 Kotlin 程序。

Kotlin 的 Hello World 程序

// Display Hello World! on screen
fun main(args : Array<String>) {
    println("Hello World!")
}

输出：

Hello World!

让我们详细讨论 Hello World 程序

该程序的第一行是：

// Display Hello World! on screen

这是一个注释。你可以在这里写任何东西，编译器在执行程序时忽略这些注释。注释提高了代码的可读性，因此当程序员阅读它们时，只需阅读注释即可轻松理解代码的用途。

该程序的第二行是：

fun main(args : Array<String>) { }

这是主函数。与 java 类似，Kotlin 程序的执行从该函数开始。该功能是 Kotlin 程序的起点。这是 Kotlin 程序的强制性功能。

该程序的第三行是：

println("Hello World!")

这类似于 java 中的System.out.println("Hello World!")语句。此语句的目的是在屏幕上的双引号内显示消息。

Kotlin 密封类

原文： https://beginnersbook.com/2019/03/kotlin-sealed-class/

密封类用于表示受限类层次结构，其中对象或值可以具有来自有限值集合的类型之一。您可以将密封类视为枚举类的扩展。枚举类中的值集也受到限制，但枚举常量只能有单个实例，而密封类的子类可以有多个实例。

为什么我们需要密封类？

让我们首先了解密封类的必要性。在下面的例子中，我们有一个类Color，它有三个子类Red，Orange和Blue。
这里的eval()方法中的when表达式必须使用else分支，否则我们会得到一个编译错误。现在，如果我们尝试向类Color添加子类，则else分支中的代码将执行，这是默认代码。编译器应警告我们新添加的子类的代码不存在，因此我们应该在添加新子类，而不在表达式中添加逻辑时收到警告或错误。使用Sealed类解决了这个问题。

open class Color{
    class Red : Color()
    class Orange : Color()
    class Blue : Color()
}
fun eval(c: Color) =
        when (c) {
            is Color.Red -> println("Paint in Red Color")
            is Color.Orange -> println("Paint in Orange Color")
            is Color.Blue -> println("Paint in Blue Color")
            else -> println("Paint in any Color")
        }

fun main(args: Array<String>) {
    val r = Color.Red()
    eval(r)
}

Kotlin 密封类示例

在 Kotlin 中，在类标题中的class关键字之前使用sealed关键字声明了密封类。

让我们使用密封类在上面看到的相同示例。这里我们通过将类Color标记为密封来解决上述问题。

名称密封的类仅表示从一组有限的值中获取值。这里else分支在when表达式中不是必需的，因为编译器知道该类是密封的，它只需要三个派生类的表达式，不需要默认的else分支。现在，如果我们尝试将新的子类添加到类Color中，它将不会创建不必要的错误，而是会引发错误。

例如，如果我们在密封类Color中添加一个新的子类White，并且在表达式时不添加White子类的表达式，那么我们将得到此错误 - Error:(12, 9) Kotlin: 'when' expression must be exhaustive, add necessary 'is White' branch or 'else' branch instead

sealed class Color{
    class Red : Color()
    class Orange : Color()
    class Blue : Color()
}
fun eval(c: Color) =
        when (c) {
            is Color.Red -> println("Paint in Red Color")
            is Color.Orange -> println("Paint in Orange Color")
            is Color.Blue -> println("Paint in Blue Color")
        }

fun main(args: Array<String>) {
    val r = Color.Red()
    eval(r)
}

输出：

Kotlin Sealed class example

现在你可以理解，通过使类密封，我们将限制添加到类层次结构中。

Kotlin 的密封类规则

我们无法创建密封类的对象，这意味着密封类无法实例化。
密封类的所有子类必须在声明密封类的同一文件中声明。
密封类的构造函数默认为private，我们不能将其设为非私有。

Kotlin 关键词，软关键词和标识符

原文： https://beginnersbook.com/2017/12/kotlin-keywords-identifiers/

Kotlin 中的某些单词具有特殊含义，不能用作标识符（变量名，函数名，类名等）。这些词被称为保留词或关键词。在本指南中，我们将了解关键字和标识符。

Kotlin 中关键词的类型

我们有两种类型的关键字：

硬关键字
软关键字

1.硬关键词

这些关键字不能用作标识符。例如

这是有效的：

//valid variable name
val myvar = 5

这是无效的：

//error: "else" cannot be used as a variable name
val else = 5


as	class	break	continue	do	else
for	fun	false	if	in	interface
super	return	object	package	null	is
try	throw	true	this	typeof	typealias
when	while	val	var

2.软关键词

软关键字是仅在特定上下文中使用的关键字，这意味着我们可以将它们用作标识符。除了上面的关键字列表，还有其他关键字可以用作标识符。例如，by是一个软关键字，它将接口的实现委托给另一个对象。我们也可以使用关键字by作为标识符。

//valid code
fun main(args: Array) {
    val by=10
    println(by+10)
}

Kotlin 还有其他一些软关键词，如catch，get，finally，field等。

Kotlin 标识符

我们给变量，类，函数等的名称称为标识符。例如：

var num = 100

这里num是一个标识符。

Kotlin 标识符的命名约定

标识符不能有空格。
Kotlin 中的标识符区分大小写。
它们不能包含特殊字符，如@，#，%等。
标识符可以以下划线“_”开头。
最佳做法是为标识符指定有意义的名称。例如：add，multiply和divide是比a，m和d更有意义的标识符。
如果您希望在标识符中包含两个单词，则可以使用大写字母开头第二个单词。例如，sumOfTwo。

参考

Kotlin 文档 - 关键词参考

Kotlin 变量和数据类型

原文： https://beginnersbook.com/2017/12/kotlin-variables-data-types/

有两种类型的变量 - 可变和不可变。不可变变量是不能更改其值的变量，也称为不可变或只读变量。另一方面，可变变量的值可以改变。

不可变变量：`val`关键字

在 Kotlin 中使用val关键字声明不可变变量。在这个例子中，我们使用val关键字声明了一个不可变变量myName，后来显示了它的值。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){
    /**
     * This is an immutable variable
     * also called unchangeable variable
     * or read-only variable.
     */
    val myName = "Chaitanya"
    println("My Name is: "+myName)
}

输出：

Kotlin immutable variable

当我们尝试更改不可变变量的值时会发生什么？

如果我们尝试更改不可变变量的值，我们将得到一个编译错误，就像我们在下面的例子中得到的那样。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){
    /**
     * This is an immutable variable
     * also called unchangeable variable
     * or read-only variable.
     */
    val myName = "Chaitanya"
    myName="Chaitanya Singh"
    println("My Name is: "+myName)
}

输出：

Error:(13, 5) Kotlin: Val cannot be reassigned

可变变量：`var`关键字

与不可变变量不同，我们可以更改可变变量的值。在 kotlin 中，我们使用var关键字来声明一个可变变量。让我们举一个例子来理解这一点。

在这个例子中，我们使用var关键字声明了一个可变变量，为了证明我们可以改变它的值，我们已经为myName变量重新分配了一个不同的值。

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){
    /**
     * This is an mutable variable
     * we can change the value of this
     * variable
     */
    var myName = "Chaitanya"
    myName="Chaitanya Singh"
    println("My Name is: "+myName)
}

输出：

Kotlin mutable variable

什么是变量？

变量是一个名称，赋予内存中可以保存数据的位置。例如，当我声明这样的变量时：

var website = "beginnersbook"

数据"beginnersbook"存储在特定位置的存储器中，称为website。

这里var是一个用于声明变量的关键字，website是一个标识符（变量的名称），"beginnersbook"是数据（变量的值），变量的类型是String（我们稍后会讨论）。

另请阅读： Kotlin 关键字和标识符。

类型推断

正如我们前面提到的，我们可以在单个语句中声明和初始化变量，如下所示：

var website = "beginnersbook"

在上面的语句中我们没有指定变量的类型，kotlin 知道变量website是一个字符串。编译器可以通过查看值来了解变量的类型。

但是，如果您想明确提及变量的类型，那么您可以这样做：

var website: String = "beginnersbook"

这里我们已经明确地将变量website的类型称为String。

首先声明并稍后初始化：

我们可以先声明变量，然后我们可以在程序中稍后初始化它。这里要注意的重点是，我们这样做，你必须在声明期间指定变量的类型。

//It is mandatory to specify the type in this case
var website: String
website = "beginnersbook"

Kotlin 数据类型

数字 - Byte，Short，Int，Long，Float，Double
Boolean - true，false
Char
Array
String

数字

我们有几种数据类型来表示 Kotlin 中的数字。

1.字节

字节数据类型的范围是 -128 到 127.这用于表示较小的整数值。

fun main(args : Array) {
    val num: Byte = 99
    println("$num")
}

输出：

您必须了解数据类型的范围以避免错误。例如，以下代码将生成错误，因为分配给byte类型的变量的值不在该范围内。

fun main(args : Array) {
    //Range is -128 to 127
    val num: Byte = 300
    println("$num")
}

输出：错误

我们也可以知道数据类型的最小值和最大值，如下所示：

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    var bigByte: Byte = Byte.MAX_VALUE
    var smallByte: Byte = Byte.MIN_VALUE
    println("Biggest Byte value is: " + bigByte)

    /**
     * I can use String interpolation and put
     * the variable inside quotes to display its
     * value
     */
    println("Smallest Byte value is: $smallByte")
}

输出：

Kotlin Data Types

2.`Short`

Short数据类型的范围是-32768 到 32767。

fun main(args : Array) {
    val num: Short = 29999
    println("$num")
}

输出：

您可能想知道我们何时在Short数据类型中有更大的范围，为什么我们使用Byte数据类型？
这是为了节省内存。与字节数据类型相比，短数据类型保留更多内存，因此如果您确定该值将在-128 到 127 的限制内，则从内存角度来看，字节数据类型将是更好的选择

`Int`

Int数据类型的范围是-2 ** 31到2 ** 31 - 1

fun main(args : Array) {
    val num: Int = 123456
    println("$num")
}

输出：

注意：如果你没有明确指定变量的类型，那么编译器会将该变量视为Int，如果值介于-2 ** 31到2 ** 31 - 1

`Long`

Long数据类型的范围是-2 ** 63到2 ** 63 - 1

fun main(args : Array) {
    val num: Long = 12345678
    println("$num")
}

输出：

12345678

注意：如果没有明确指定变量的类型，那么编译器会将该变量视为 Long，如果该值超出-2 ** 31到2 ** 31 - 1但位于-2 ** 63到2 ** 63 - 1的范围内

5.`Double`

fun main(args : Array) {
    // all floating numbers are double by default
    // unless you suffix the value with F letter
    val num = 101.99
    println("$num")
}

输出：

101.99

6.`Float`

fun main(args : Array) {
    // This is a float data type as we have suffixed
    // the value with letter 'F'
    val num = 101.99F
    println("$num")
}

输出：

101.99

`Boolean`

布尔变量的值为true或false。

fun main(args : Array) {
    val boolValue = false
    println("$boolValue")
}

输出：

false

`Char`

所有英文字母（小写或大写）都包含在Char数据类型中。您不能将数字分配给Char数据类型的变量。

fun main(args : Array) {
    val ch = 'A'
    println("$ch")

    val ch2: Char
    ch2 = 'Z'
    println("$ch2")
}

输出：

A
Z

Kotlin 类型转换

原文： https://beginnersbook.com/2018/09/kotlin-type-conversion/

类型转换是将一种数据类型转换为另一种类型的过程，例如 - 将int转换为long，long转换为double等。在教程中，我们将学习如何在 Kotlin 中执行类型转换。

在 Kotlin 和 Java 中进行类型转换

在 java 中，一种类型会自动转换为其他类型（在某些情况下），在 Kotlin 中我们需要显式转换类型。

例如：

Java：

Int自动转换为Long数据类型，因为long大于int。

// This code is valid in Java, even though we are converting int to long
// because long is larger than int and it can hold integers
int num1 = 101;
long num2 = num1;

Kotlin：

在 Kotlin 中转换不是自动的，我们需要明确地进行类型转换。

// This code is invalid in Kotlin. This will cause compile time 
// error, type mismatch
val num1: Int = 101
val num2: Long = num1

Kotlin 中的正确代码：
我们使用toLong()函数在 Kotlin 中将int转换为long。

val num1: Int = 101
val num2: Long = num1.toLong()

简单类型转换实例

/**
 * created by Chaitanya for Beginnersbook.com
 */
package beginnersbook

fun main(args : Array<String>){

    /**
     * Double to int type casting
     */
    println("4.554 to int: " + (4.554.toInt()))

    /**
     * int to Char type casting
     */
    println("66 to Char: " + (65.toChar()))

    /**
     * Char to int type casting
     */
    println("B to int: " + ('B'.toInt()))
}

输出：

Kotlin Type Casting

当我们将较大的类型转换为较小的类型时会发生什么？

将较大类型转换为较小类型时，我们有两种可能的结果。如果我们转换为较小类型的值超出目标类型的范围，则结果将被截断。但是，当值在目标类型的范围内时，它将被转换而不会被截断。

示例 1：当值超出目标类型的范围时

在这个例子中，我们将long类型转换为int类型，其中long类型的值超出整数类型的范围。

fun main(args : Array<String>) {
    val num1: Long = 5453448989999998988
    val num2: Int = num1.toInt()
    println("Number num1 is: $num1")
    println("Number num2 is: $num2")
}

输出：

Number num1 is: 5453448989999998988
Number num2 is: 2041161740

示例 2：当值在目标类型的范围内时

在这个例子中，我们将long类型转换为int类型，其中long类型的值在整数类型的范围内。

fun main(args : Array<String>) {
    val num1: Long = 5453448
    val num2: Int = num1.toInt()
    println("Number num1 is: $num1")
    println("Number num2 is: $num2")
}

输出：

Number num1 is: 5453448
Number num2 is: 5453448

Kotlin 运算符 - 算术，赋值，一元，逻辑等

原文： https://beginnersbook.com/2017/12/kotlin-operators-arithmetic-assignment-unary-logical-and-more/

运算符用于操作数并用于计算。例如，+是一个运算符，当我在这样的表达式中使用它时：a + b，它在操作数a, b上执行加法。在本指南中，我们将学习 Kotlin 中可用的操作符类型以及如何使用它们。

Kotlin 中的运算符分为以下几类：

1.算术运算符

+加法运算符
-减法运算符
*乘法运算符
/减法运算符
%模数运算符

算术运算符的例子

fun main(args: Array<String>) {

   val num1 = 101.99
   val num2 = 100.50
   var op: Double

   op = num1 + num2
   println("Addition: $op")

   op = num1 - num2
   println("Subtraction: $op")

   op = num1 * num2
   println("Multiplication: $op")

   op = num1 / num2
   println("Division: $op")

   op = num1 % num2
   println("Modulus: $op")
}

输出：

Addition: 202.49
Subtraction: 1.4899999999999949
Multiplication: 10249.994999999999
Division: 1.014825870646766
Modulus: 1.4899999999999949

加法运算符（+）也用于字符串连接。你可以在这里阅读：
Kotlin 中的字符串连接

注意：本指南不完整。即将添加更多内容。

Kotlin - 如何从用户获取输入

原文： https://beginnersbook.com/2018/09/kotlin-input-from-user/

在本教程中，我们将看到如何在 Kotlin 中从用户那里获取输入。

示例 1：显示用户输入的字符串

在此示例中，我们将从用户获取输入并将其显示在输出中。这里我们使用readLine()函数来读取在控制台上输入的字符串。

fun main(args: Array<String>) {
    print("Write anything here: ")

    val enteredString = readLine()
    println("You have entered this: $enteredString")
}

输出：

Write anything here: welcome to beginnersbook.com
You have entered this: welcome to beginnersbook.com

示例 2：获取输入并将其转换为其他类型

正如我们在上面的例子中看到的那样，readLine()函数将输入读作String。如果我们想要输入不同类型的输入，例如整数，长整数，那么我们需要显式地将输入转换为另一种类型或使用 java Scanner类。

将输入作为String并将其转换为int

这里我们明确地将输入转换为整数。

fun main(args: Array<String>) {
    print("Write any number: ")

    val number = Integer.valueOf(readLine())
    println("The entered number is: $number")
}

输出：

Write any number: 101
The entered number is: 101

使用Scanner类

获取String以外的输入在本例中，我们将输入作为整数并分别使用nextInt()和nextFloat()函数浮点数。类似地，我们可以使用nextLong()，nextDouble()和nextBoolean()方法分别获取长，双和布尔输入。

//Program created for https://beginnersbook.com
import java.util.Scanner
fun main(args: Array<String>) {
    //creating Scanner object
    val read = Scanner(System.`in`)

    //Taking integer input
    println("Enter an integer number: ")
    var num1 = read.nextInt()

    //Taking float input
    println("Enter a float number: ")
    var num2 = read.nextFloat()

    //Displaying input numbers
    println("First Input Number: "+num1)
    println("Second Input Number: "+num2)
}

输出：

Enter an integer number: 
99
Enter a float number: 
10.55
First Input Number: 99
Second Input Number: 10.55

Kotlin taking input from user

posted @ 2024-10-24 18:12 绝不原创的飞龙阅读(10) 评论(0) 编辑收藏举报

刷新页面返回顶部

龙哥盟

掠夺·扩张·投机·博弈

BeginnersBook-Kotlin-教程-一-

BeginnersBook Kotlin 教程（一）

Kotlin 注释

什么是注释？

Kotlin 中的注释类型

1）单行注释

2）多行注释

Kotlin 字符串

在 Kotlin 中声明一个String

在 Kotlin 中获取字符串长度

比较 Kotlin 中的String

访问特定索引处的字符串中的字符

子串

检查String是否包含另一个String

Kotlin 数组

Kotlin 数组声明

访问 Kotlin 中的数组元素

Kotlin 数组set()和get()函数

get()

set()

数组的大小

检查数组中的元素

Kotlin Array first()和last()函数

查找数组中元素的索引

Kotlin 范围

Kotlin 范围的一个简单例子

检查范围中的元素

Kotlin 范围：rangeTo()和downTo()函数

Kotlin 范围步长

Kotlin 范围反转

Kotlin If - Else表达式

1. Kotlin - if表达

if表达式的例子

2. Kotlin - If..Else表达式

if..else表达式示例

3. Kotlin - if..else if..else阶梯表达式

if..else if..else表达式示例

4. Kotlin - 嵌套表达式

参考

Kotlin when表达式

Kotlin when表达式的简单的例子

Kotlin when表达式的范围

表达式里面的算术运算

Kotlin for循环

Kotlin 中for循环的一个简单例子

Kotlin for循环遍历Array

Kotlin for循环遍历数组索引

在for循环中使用withIndex()函数

Kotlin while循环

Kotlin 中的一个简单的循环

无限循环

Kotlin do-while循环

Kotlin do-while循环示例

do-while循环至少运行一次

Kotlin 无限循环

Kotlin continue表达式

Kotlin continue循环示例

Kotlin continue：显示偶数

continue标签

在 Eclipse IDE 中创建并运行您的第一个 Kotlin 项目

安装 Kotlin 插件

在 Eclipse IDE 中打开 Kotlin 透视图

在 Eclipse 中创建第一个 Kotlin 项目

在 Kotlin 项目中创建项目文件

运行第一个程序

Kotlin break语句

Kotlin break示例

Kotlin 打破了嵌套循环中的示例

Kotlin break标签

Kotlin 函数

Kotlin 中的函数类型

1.标准库函数

标准库函数示例

2.用户定义的函数

用户定义的函数示例

用户定义的函数，带参数和返回类型

Kotlin 内联函数

Kotlin 递归和尾递归

在 Kotlin 中声明一个`String`

比较 Kotlin 中的`String`

检查`String`是否包含另一个`String`

Kotlin 数组`set()`和`get()`函数

`get()`

`set()`

Kotlin `Array first()`和`last()`函数

Kotlin 范围：`rangeTo()`和`downTo()`函数

Kotlin `If - Else`表达式

1. Kotlin - `if`表达

`if`表达式的例子

2. Kotlin - `If..Else`表达式

`if..else`表达式示例

3. Kotlin - `if..else if..else`阶梯表达式

`if..else if..else`表达式示例

Kotlin `when`表达式

Kotlin `when`表达式的简单的例子

Kotlin `when`表达式的范围

Kotlin `for`循环

Kotlin 中`for`循环的一个简单例子

Kotlin `for`循环遍历`Array`

Kotlin `for`循环遍历数组索引

在`for`循环中使用`withIndex()`函数

Kotlin `while`循环

Kotlin `do-while`循环

Kotlin `do-while`循环示例

`do-while`循环至少运行一次

Kotlin `continue`表达式

Kotlin `continue`循环示例

Kotlin `continue`：显示偶数

`continue`标签

Kotlin `break`语句

Kotlin `break`示例

Kotlin `break`标签

Kotlin `try-catch`

`try catch`块的语法

Kotlin `try catch`块示例

Kotlin 没有`catch`块的`try`块

Kotlin 多个`catch`块

Kotlin 多个`catch`块的例子

多个`catch`块的另一个例子

为什么在最后一个`catch`块中使用父`Exception`类是个好主意

Kotlin 嵌套`Try-Catch`块

嵌套`try catch`块的语法

嵌套的`Try-Catch`块示例

Kotlin `throw`关键字

Kotlin `throw`关键字示例

Kotlin 异常处理中的`try`表达式

Kotlin `try`表达式的例子