Kotlin 编程教程

Kotlin 的历史

以下是 Kotlin 历史上的重要里程碑

年份	事件
2016	Kotlin v1.0 发布
2017	Google 宣布对 Kotlin 在 Android 上的支持
2018	Kotlin v1.2 发布，增加了在 JVM 和 JavaScript 之间共享代码的功能
2019	Google 宣布 Kotlin 成为 Android 应用程序开发者的首选编程语言
2021	2021年9月20日，Kotlin v1.5.31 发布。

使用 Kotlin 的原因

以下是 Kotlin 被广泛使用的一些重要原因

• Kotlin 是一种静态类型语言，非常易于读写。
• Kotlin 程序不需要在程序中使用分号。这使得代码更简洁、更具可读性。
• 该语言允许以多种方式与 Java 交换和使用信息。此外，Java 和 Kotlin 代码可以共存于同一个项目中。
• Kotlin 的类型系统旨在从代码中消除 NullPointerException。
• 用 Kotlin 编写新代码所需的时间更少。部署和大规模维护 Kotlin 代码也更容易。

Kotlin 的特点

以下是 Kotlin 的一些特性，这些特性将使您确信该编程语言的发展前景。

代码精简

Kotlin 是一种基于面向对象编程的语言，代码行数可以减少高达 40%，这使得 Kotlin 成为软件或 Web 开发的理想选择。

开源

用于 Android 的 Kotlin 利用 JVM，并结合了面向对象编程和函数式编程的特性。

快速编译

在使用 Kotlin 工作时，代码很容易编译，这为 Android 开发带来了更好的性能，并且它还会解释在整个代码中可以使用哪种类型的数据函数。

扩展函数

Kotlin 可以支持多种扩展函数，而无需对代码进行任何更改。这有助于使现有代码对开发人员更具吸引力和出色。

例如

Fun String.removeFirstLastChar():
String = this.substring(1, this.length -1)

此代码将有助于修剪字符串的第一个和最后一个字符，我们可以这样应用它

Val string1 = "Today is cloudy."
Val string2 = string1.removeFirstLastChar()

空安全

在 Kotlin 中，系统区分可空引用和非空引用，如下面的 Kotlin 示例所示。

例如，一个字符串变量不能持有 null

Var string1: String = "Today is Sunday"
String1 = null  // compilation error
To permit null, we can adjoin the nullable variable :
Var string2: String? = "Today is Sunday"
String2 = null
print(string2)

互操作性

Kotlin 代码可以被 Java 使用，Java 代码也可以与 Kotlin 一起使用。因此，如果您了解面向对象编程，就很容易转向 Kotlin 开发。此外，如果有一些用 Java 编写的应用程序，它们也可以在 Kotlin 的环境中使用。

强大的工具

与 Java 一样，Kotlin 代码也可以使用 IDE 或命令行界面编写。使用 IDE 工作很容易，语法错误也大大减少。同时，当您使用命令行界面工作时，代码必须先进行编译。

智能转换

智能转换基本上有助于降低应用程序成本并提高其速度或性能。它通过类型转换或不可变值来管理代码的效率。

例如，如果识别了字符串，则可以借助智能转换函数找到其长度和计数

Val string1: Any = "Today is Monday"
when(string1)
{
is String  -> string1.length
Is Int -> string1.inc()
}

低采用成本

Kotlin 因其低采用成本而受到企业的青睐。最重要的是，它很容易被开发人员学习，尤其是有编程背景的开发人员。

Kotlin 环境设置

以下步骤可帮助您通过安装 Kotlin 来设置工作环境。

第 1 步) 安装 Java

正如我们前面讨论的，Kotlin 是基于 Java 的，所以如果您计划采用 Kotlin，首先需要安装 Java。请参考我们的Java 安装教程。

第 2 步) 安装 Java IDE

幸运的是，有多种Java IDE可供选择。我们在这里提供了下载链接，让事情变得简单一些。

• 要下载 Eclipse，请点击此处。
• 要下载 NetBeans，请点击此处。
• 要下载 IntelliJ，请点击此处。

在本 Kotlin 教程中，我们将使用 Eclipse。

第 3 步) 安装 Kotlin

要在 Eclipse 中安装 Kotlin，请转到 Eclipse 中的“帮助”部分，然后单击“Eclipse Marketplace”选项。

现在，在搜索框中输入 Kotlin 关键字。单击“Go”选项以列出插件。它会给您一个 Kotlin 插件的链接，您需要从给定的链接安装该插件。

安装完成后，请重启 Eclipse IDE。您可以在 Eclipse IDE 的右上角找到一个快捷方式图标。这是一种快速访问方法。

在 Eclipse IDE 中访问 Kotlin 的另一种方法是，转到“窗口”->“透视图”->“打开透视图”，然后选择“其他”选项。在这里，您可以查看稍后安装的插件列表，如下所示。

一旦您验证了 Kotlin 的安装，让我们在下一步中创建第一个 Kotlin 程序。

第 4 步) 第一个 Kotlin 程序

开始您的第一个 Kotlin 项目。从“文件”菜单中，选择“新建”选项，然后选择“其他”，并从列表中开始一个新的 Kotlin 项目。

现在，您需要为项目定义一个名称，然后就可以开始使用 Kotlin 了。

通过这些简单的步骤，您可以轻松地在系统上下载 Eclipse 和 Kotlin，并立即编写您的第一个 Kotlin 程序。

Kotlin 的架构

一个构建良好的架构对于应用程序扩展其功能并满足最终用户群的期望至关重要。Kotlin 有其自己独特而鲜明的架构来分配内存，并为开发人员和最终用户获得高质量的成果。

Kotlin 的协程和类以一种能够产生更少样板代码、提高性能并增强效率的方式构建核心。在多种情况下，kotlin 编译器可能会有不同的反应，尤其是在它针对不同类型的语言时。

在架构图中，很明显代码执行分三个简单步骤完成。

1. 第一步，将“.kt”或 kotlin 文件添加到编译器中。
2. 第二步，Kotlin 编译器将代码转换为字节码。
3. 第三步，将字节码放入Java 虚拟机中，并由 JVM 执行。

当一对字节码文件在 JVM 上运行时，它们会激发彼此之间的相互通信，这就是为什么 Kotlin 中称为 Java 互操作性的特性得以诞生。

当 Kotlin 目标为 JavaScript 时，就会发生 Kotlin 到 JavaScript 的转译。

当选择 JavaScript 作为目标时，任何作为 Kotlin 附带库一部分的 Kotlin 代码都会被转译为 JavaScript。然而，Java 开发工具包（JDK）或任何使用的 Java 库都会被排除。

在此类操作中，非 Kotlin 文件不被考虑。在以 JavaScript 为目标时，.kt 文件由 Kotlin 编译器转换为 ES5.1，以生成与 JavaScript 一致的代码。Kotlin 编译器致力于实现最佳的输出大小、与现有模块的互操作性、与标准库相同的功能以及 JavaScript 可读的输出。

从讨论中可以清楚地看出，Kotlin 编译器可以创建更高效、更有能力、更独立的代码，从而产生高性能的软件产品。

Kotlin 变量

变量用于存储在程序中被操作和引用的数据。它基本上是一个存储数据的单元，并为其标记一个解释性别名，以便程序易于阅读和理解。换句话说，我们可以说变量是收集信息的容器。

在 Kotlin 中，所有变量都必须声明。但是，如果任何变量未声明，则会弹出语法错误。此外，变量的声明决定了我们允许存储在该变量中的数据类型。在 Kotlin 中，变量可以使用 val 和 var 关键字定义。以下是在 Kotlin 中声明变量的语法

Var day = "Monday"
Var number = 3

在这里，我们声明了局部变量 day，其值为“Monday”，类型为 String；另一个局部变量 number，其值为 3，类型为 Int，因为这里的字面量是整数类型，即 3。

局部变量通常同时声明和初始化。我们还可以在初始化 Kotlin 变量时执行某些操作。

我们可以对相同数据类型的变量执行操作，如此处的 num1 和 num2 都是相同的数据类型，即 Int，而 day 是字符串数据类型。因此，它会显示一个错误。这里是另一种在 Kotlin 中定义变量的技术。

var day : String = "GURU99"
var num : Int = 100

让我们看看 var 和 val 关键字彼此有何不同。

Var

Var 就像任何编程语言中使用的通用变量，可以在单个程序中多次使用。此外，您可以在程序中随时更改其值。因此，它被称为可变变量。

这是 Kotlin 中可变变量的一个例子

var num1 = 10
Var num2 = 20
Num1 = 20
print(num1 + num2) // output : 40

在这里，num1 的值 20 覆盖了 num1 之前的值 10。因此，num1 + num2 的输出是 40 而不是 30。

Val

Val 就像一个常量变量，你不能在程序后面更改它的值，它也不能在单个程序中多次赋值，并且在特定程序中只能使用一次。因此，它被称为不可变变量。

这是 Kotlin 中不可变变量的一个 Kotlin 程序示例

Val num1 = 10
Var num2 = 20

这里，num1 的值 10 不能被新的 num1 值 20 覆盖，因为它是 val 类型，即常量。因此，输出是 30 而不是 40。

注意：在 Kotlin 中，不可变变量优于可变变量。

Kotlin 中的数据类型

数据类型是相关值的集合，并描述了可以对它们进行的操作。与其他编程语言类似，Kotlin 也有其预定义的数据类型集，如 Int、Boolean、Char、Double 等。

在 Kotlin 中，每种数据类型都被视为一个对象。

现在，在本 Kotlin 基础教程中，让我们更深入地了解 Kotlin 中使用的预定义数据类型。

数字

Kotlin 提供了一组内置的数据类型，称为数字，它们被细分为整数和浮点数。

整数

整数是数字的类别，有四种类型

类型	大小 (位)	最小值	最大值
Byte	8	-128	127
Short	16	-32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231 – 1)
Long	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263 – 1)

浮点数

浮点数是带有小数位的非整数。

Float: Float 是一个 32 位的单精度浮点值。

示例: var: Float x = 3.25600

Double: Double 是一个 64 位的双精度浮点值。

示例: var: Double y = 2456.345587

布尔值

Kotlin 中的布尔数据类型对于表示逻辑值很重要。布尔值只有两个可能的值，即 true 或 false。

例如： val day = true

val day2 = false

字符

Kotlin 中的字符是借助名为 char 的关键字表示的。在 Kotlin 中，单引号表示 char 的声明。在 Java 中，char 有时被用作数字，这在 Kotlin 中是不可能的。

例如

val onechar = 'x'
print(onechar) //  output : x
Val onedigit = '7'
print(onedigit) // output : 7

Kotlin 类型转换或 Kotlin 类型转换

类型转换是将一种数据类型变量转换为另一种数据类型变量的过程。它也被广泛称为类型转换。

值得注意的是，在 Java 中，支持将较小数据类型隐式类型转换为较大数据类型。

For Example : int abc = 15;
Long bcd = abc; // compiles successfully

然而，在 Kotlin 中，完全不支持将较小的数据类型隐式转换为较大的数据类型，即 int 数据类型不能隐式转换为 long 数据类型。

For Example : var abc = 15
Val bcd : Long = abc // error

然而，在 Kotlin 中，类型转换是显式完成的。这里就用到了辅助函数，它们指导将一种数据类型变量转换为另一种。

有一些预先拥有的辅助函数用于将一种数据类型转换为另一种

toInt()

toByte()

toShort()

toChar()

toLong()

toFloat()

toDouble()

For Example : var abc = 15
Val bcd : Long = abc.toLong() // compiles successfully

Kotlin 运算符

运算符是重要的特殊字符或符号，用于确保对操作数（包括变量和值）进行操作。在 Kotlin 中，有一组运算符用于不同的操作，如算术运算、赋值运算、比较运算等。

算术运算符

算术运算符用于加法、减法、乘法、除法和取模。

运算符	含义
+	加法（也用于字符串连接）
–	减法运算符
*	乘法运算符
/	除法运算符
%	取模运算符

例如

var x = 10
var y = 20
var z = ( ( x + y ) * ( x + y ) ) / 2     

以下代码的输出是 45。

比较运算符

比较运算符用于比较两个值、两个变量或两个数字。它与大于号( > )、小于号( < )、等于号( ==)、不等于号( != )、大于等于号( >= )、小于等于号(<= )一起使用。其结果总是 true 或 false。

例如

var x = 10
Var y =20
Var z = x < y // Output : true
Var w = x > y // Output : false
Var m = x == y // Output : false

赋值运算符

赋值运算符用于赋算术运算后的值。它与 +=, -=, *=, /=, %= 等符号一起使用。

例如

var x = 10
var y = 20
var x + = y // Output : 30
Var y - = x // Output : 10
Var x * = y // Output : 200

递增和递减运算符

递增和递减运算符用于增加和减少变量或数字的值。它借助 ++ 和 -- 等符号使用。

递增和递减有两种类型，即前置递增 ++a、后置递增 a++、前置递减 --b、后置递减 b--。

例如

var a = 10
var b = 20
var c = a++ // Output: 11
var d = b— //Output : 19     

Kotlin 数组

数组是同类数据类型的集合，是用于在连续内存位置存储相同类型数据的最基本数据类型之一。数组在任何编程语言中对于组织数据都非常重要，这样存储在单个位置的多个数据就易于搜索或排序。

在 Kotlin 中，数组是相同数据类型的可变集合，而不是原生数据类型。

以下是 Kotlin 中数组的一些属性

• 数组的大小一旦声明就不能改变。
• Kotlin 中的数组是可变的。
• 数组存储在连续的内存位置中。
• 数组可以通过索引来访问，如 a[1]、a[2] 等。
• 数组的索引从零开始，即 a[0]。

在 Kotlin 中，数组可以通过两种不同的方法定义

通过使用 arrayOf() 函数

在 Kotlin 中，库函数的使用非常广泛。arrayOf() 函数就是这样一个库函数，它通过将变量的值传递给函数来定义数组。

例如：使用 arrayOf() 函数隐式类型声明数组

val x = arrayOf(1,2,3,4,5,6,7,8,9)

例如：使用 arrayOf() 函数显式声明数组类型。

Val y = arrayOf<Int>(1,2,3,4,5,6,7,8,9)

通过使用数组构造函数

在 Kotlin 中，有一个名为 Array 的类。因此，使用 Array 的构造函数来创建数组是可行的。构造函数中的数组包含两个主要参数。

Kotlin 中的数组索引是什么？

该函数接受数组索引以返回索引的初始值。

例如

val abc = Array(7 , { i -> i*1})

这里，数组的值是 7，并且使用 lambda 表达式来初始化元素的值。

还有多种方法可以使用某些函数来访问和修改数组。因此，有两个成员函数 get() 和 set()，用于访问类数组的对象。

例如

val x = arrayOf(10,20,30,40,50,60,70,80,90)
val y = x.get(0) // Output 10

这里，输出是 10，因为数组索引 0 处的值是 10

注意：get() 仅接受单个值

例如

val x = arrayOf(10,20,30,40,50,60,70.80.90)
val y = x.set(2, 3) //

输出：30 40

在这里，输出是 30 和 40，因为数组索引 2 处的值是 30，索引 3 处的值是 40。

注意：set() 接受数组的多个值。

Kotlin 字符串

字符串是任何编程语言中的基本数据类型。字符串就是字符序列。String 类表示字符字符串。在 Kotlin 中，所有字符串都是 String 类的对象，这意味着字符串字面量是作为该类的实例实现的。

语法

 Val myString = "Hey there!"

Kotlin 集合

集合包含多个相似类型的对象，集合中的这些对象被称为元素或项。集合可以帮助存储、检索、操作和聚合数据。

集合类型

不可变集合

这种类型的集合支持只读功能。人们不能修改它的元素。

方法包括

• 列表 – listOf() 和 listOf<T>()
• 集合 – setOf()
• 映射 – mapOf()

可变集合

它同时支持读写功能。

方法包括

• 列表 – mutableListOf(), arrayListOf() 和 ArrayList
• 集合 – mutableSetOf(), hashSetOf()
• 映射 – mutableMapOf(), hashMapOf() 和 HashMap

Kotlin 函数

在任何编程语言中，函数都是一组相似的语句，旨在执行特定任务。函数允许将程序分解为多个小的代码块。这种代码划分增加了代码的可读性、可重用性，并使程序易于管理。

Kotlin 被称为一种静态类型语言。这里，'fun' 关键字用于声明函数。在 Kotlin 中，有两种类型的函数，这完全取决于它们在标准库中的可用性或用户定义。它们是

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

现在，让我们用 Kotlin 代码示例来详细讨论它们。

标准库函数

它们是内置的库函数，可以隐式定义并可供使用。

示例 2

fun main(args: Array<String>){  
var number = 9  
var result = Math.sqrt(number.toDouble())  
print("$result")  
}  

输出

3.0

sqrt() 是库中定义的函数，它返回一个数的平方根。

print() 函数将消息打印到标准输出流。

用户定义函数

顾名思义，这些函数通常由用户创建，可用于高级编程。

在这里，函数使用 'fun' 关键字声明。

示例 3

fun functionName(){
//body of the code
}

在这里，我们调用函数来运行函数体 functionName() 内部的代码。

Kotlin 函数示例

fun main(args: Array<String>){  
    sum()  
    print("code after sum")  
}  
fun sum(){  
    var num1 =8  
    var num2 = 9  
    println("sum = "+(num1+num2))  
}  

输出

sum = 17

sum 后的代码

Kotlin 中的异常处理

编程中的异常被定义为程序中发生的运行时问题，导致程序终止。此问题可能由内存空间不足、数组越界、除以零等情况引起。为了抑制这些类型的代码执行问题，使用了异常处理。

异常处理被定义为处理运行时问题并在执行期间维持程序流程的技术。

Kotlin 使用 'throw' 表达式来抛出异常对象。这里所有异常类都是 Throwable 类的后代。

Throw MyException("throws exception")

异常处理中有四种类型的异常。它们是

• try – 此块包含可能创建异常的语句。它后面总是跟着 catch 或 finally 或两者。
• catch – 它捕获从 try 块抛出的异常。
• finally – 它总是检查异常是否被处理。
• throw – 它用于显式抛出异常。

Try catch

在异常处理的 try-catch 块中，try 块包含可能抛出异常的代码，而 catch 块捕获表达式并处理它。

try catch 块的语法

try{    
//code with exception    
}catch(e: SomeException){  
//code handling exception  
}    

带有 finally 块的 try 语法

try{    
//code with exception    
}finally{  
// code finally block  
}   

Finally

在 Kotlin 中，finally 块总是检查异常是否被处理，这使其成为异常处理中非常重要的一条语句。

示例 4

在此代码片段中，发生了异常并且得到了处理。

fun main (args: Array<String>){  
    try {  	
        val data =  9/ 0  
        println(data)  
    } catch (e: ArithmeticException) {  
        println(e)  
    } finally {  
        println("finally block executes")  
    }  
    println("write next code")  
}  

输出

java.lang.ArithmeticException: / by zero
finally block executes
write next code

Throw

Throw 块抛出一个显式异常。此外，它还用于抛出自定义异常。

语法

Throw SomeException()

Throw SomeException()

示例

fun main(args: Array<String>) {
    try{
        println("Exception is not thrown yet")
        throw Exception("Everything is not well")
        println("Exception is thrown")
    }
    catch(e: Exception){
        println(e)

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

输出

Kotlin 空安全

支持 Kotlin 的系统类型主要区分可以携带可空引用的引用和不能携带可空引用的引用。Kotlin 是一种空安全语言，旨在从代码中消除空指针异常或空引用，这被故意称为“十亿美元的错误”。

许多编程语言最常见的绊脚石是，在访问空引用的成员时，会导致空指针异常，这可能是因为 !! 运算符或此构造函数在别处使用并在代码的另一点传递。可空属性要求每次使用前都确认进行空检查。

在 Kotlin 中，系统区分可空引用和非空引用。

例如，一个字符串变量不能持有 null

示例 5

fun main(args: Array<String>){
    var x: String = "GURU99 is the only place where you will get maximum technical content!" // Not Null by default
    println("x is : $x")
    // You cannot assign null variable to not-nullable variables 
    // a=null // it will give compilation error
    var y: String? = "Thanks for visiting GURU99" 
// Nullable Variable
    println("y is : $y")
    y = null
    println("y is : $y")
}

输出

Kotlin 面向对象编程

面向对象编程方法允许通过创建对象将复杂的代码片段划分为更小的代码块。这些对象共同具有两个特征：状态和行为。

以下是我们将用 Kotlin 代码示例讨论的一些面向对象编程元素

• 类和对象
• 构造函数
• 继承
• 抽象类

Kotlin 中的类

在创建对象之前，我们首先需要定义一个类，这个类也被称为对象的蓝图。

语法

class ClassName {
    // property
    // member function
    ... .. ...
}

Kotlin 中的对象

在定义类时，我们只定义了对象的规范，没有分配内存或存储等其他参数。

语法

var obj1 = ClassName()

Kotlin 中的构造函数

构造函数是初始化类属性的一种方式。它是在实例化对象时调用的成员函数。但在 Kotlin 中，它的工作方式不同。

Kotlin 中有两种类型的构造函数

主构造函数：初始化类的优化方式

语法

class myClass(valname: String,varid: Int) {  
    // class body  
}  

次构造函数：帮助添加初始化逻辑

Kotlin 继承

当子类获得父类的某些属性时，就会发生继承。当两个或多个类具有相同的属性时，允许继承。

语法

open class ParentClass(primary_construct){
    // common code
  }class ChildClass(primary_construct): ParentClass(primary_construct_initializ){
    // ChildClass specific behaviours
  }

Kotlin 中的抽象类

抽象类是不能被实例化的类，但我们可以从它们继承子类。'abstract' 关键字用于声明抽象类。

示例 6

  open class humanbeings { 
    open fun Eat() { 
        println("All Human being Eat") 
    } 
} 
abstract class Animal : humanbeings() { 
    override abstract fun Eat() 
} 
class Cat: Animal(){ 
    override fun Eat() { 
        println("Cats also loves eating") 
    } 
} 
fun main(args: Array<String>){ 
    val lt = humanbeings() 
    lt.Eat() 
    val d = Cat() 
    d.Eat() 
} 

输出

Kotlin 的现在与未来

现在

• 许多公司如 Netflix、Pinterest 和 Corda 正在使用 Kotlin 来创建功能强大的 Android 应用。
• 在从 2016 年到 2017 年的短短一年内，Kotlin 凭借其惊人的编程特性变得非常流行。
• 2017年，谷歌宣布 Kotlin 为安卓开发的官方编程语言。
• 您可以快速用 Kotlin 替换 Java 代码，因为它与 Java 和 Android 100% 互操作。

未来

• 跨平台游戏开发
• 跨平台移动应用开发
• 服务器端脚本和微服务
• 机器学习与数据分析

摘要

• Kotlin 是 JetBrains 在 2010 年提出的一种编程语言，用于多平台应用程序，遵循 Apache 2.0 许可。
• Kotlin 这个名字来源于科特林岛的名字，这与 Java 的名字来源于一个名为爪哇的岛屿相似。
• 2016年，Kotlin 的第一个版本 v1.0 发布
• Kotlin 程序不需要在程序中使用分号。这使得代码更简洁、更具可读性。
• 对于 Android 开发者来说，Kotlin 是一种基于面向对象编程的语言，代码行数可以减少高达 40%，这使得 Kotlin 成为软件或 Web 开发的理想选择。
• 在 Kotlin 中，所有变量都应使用 var 和 val 关键字声明。
• 与其他编程语言类似，Kotlin 也有其预定义的数据类型集，如 Int、Boolean、Char、Double 等。
• 在 Kotlin 中，有一组运算符用于不同的操作，如算术运算、赋值运算、比较运算等。
• 在 Kotlin 中，数组是相同数据类型的可变集合，而不是原生数据类型。
• 在 Kotlin 中，数组使用两种方法定义——ArrayOF() 和构造函数。
• Kotlin 是一种空安全语言，有助于从代码中消除空指针异常或空引用，这被戏称为“十亿美元的错误”。