快速入门Kotlin语言（基本语法概要）
- 引言
- 基本数据类型
- 常量和变量
- 函数
- 字符串模板
- 逻辑控制
- 非null检测
- 类
- 区间
- 集合
- 结语
一，引言
- Kotlin [1] （科特林）是一个用于现代多平台应用的静态编程语言 [2] ，由 JetBrains 开发。
- 使用 Kotlin 更快地编写更出色的 Android 应用。 Kotlin 是一种新型的静态类型编程语言，有超过 60% 的专业 Android 开发者在使用，它有助于提高工作效率、开发者满意度和代码安全性。
–来自Google 开发者平台数据 - GitHub 托管地址
二，基本类型
Kotlin完全抛弃了Java中的基本数据类型，全部使用了对象数据类型。举个栗子：在Java中，int 是一个关键字，有自己的包装类Integer，而在Kotlin中，Int就是一个类，有自己的方法和继承结构。
三，常量和变量
- 常量用 val 关键字标识，只能为其赋值一次，类似于 Java 中的 final 变量。
//定义整形常量
val x: Int
//定义整形变量 赋初始值
val y: Int = 2021
//赋初始值 才能使用
x = 2021
println(x) //2021
println(y) //2021
//再次重新赋值报错
x=2022 //Val cannot be reassigned
- 变量用 var 关键字标识，可以重新赋值，类似于 Java 中的非 final 变量。
//定义整形变量 赋初始值
var x: Int = 2021
//打印值
println(x) //2021
//再次赋值
x = 2022
//打印值
println(x) //2022
- 根据赋值，自动推断数据类型
//明确数据类型 Int
var a: Int = 2021
//自动推断为 Int 型
var b = 2021
//自动推断为 String 型
var c = "Hello,Kotlin"
四，函数
- 定义规则
fun methodName(param1: Int, param2: Int = 2021): Int {
return 0
}
- fun 是声明函数的关键字，无论定义什么函数，都要用 fun 来声明；
- methodName 是函数名，定义时最好见文知义；
- () 中可以定义多个输入的参数，并可以赋初始值；
- () 后面是返回值类型，可省略；
- {} 之间是函数体，可以编写具体的逻辑。
/**
- 比较两个整数的大小
- @param a
- @param b
- @return 最大值
*/
fun getMaxValue(a: Int, b: Int): Int {
if (a > b) {
return a
} else {
return b
}
}
- 还可以，将函数体作为返回值，直接返回，return 可以省略，Kotlin 可以自动推断出返回值类型。
/**
- 比较两个整数的大小
- @param a
- @param b
- @return 最大值
*/
fun getMaxValue1(a: Int, b: Int) = if (a > b) a else b
五，字符串模板
- 定义规则
模板表达式以美元符 $ 开头，由一个简单的字符串构成：
$ 字符串
如果表达式非常复杂，可以用大括号 {} 包括起来：
$ {字符串}
//定义常量 a
val a: Int = 2021
//定义常量 b
val b: Int = 2021
//打印常量 a
println("a 的值：$a")
//打印 a + b 的值
println("a + b 的值：${a + b}")
a 的值：2021
a + b 的值：4042
六，逻辑控制
- 在 Kotlin 中，和 Java 一样，也有逻辑控制语句，像常用的 if，when，for 循环等等，通过这些控制语句，才能编写相应的逻辑代码。
- if 控制语句
在 Kotlin 中，if 控制语句，有返回值。
/**
* 比较两个数的大小
* @param a
* @param b
* @return 返回最大值
*/
fun getMaxNumber(a: Int, b: Int): Int {
val maxNumber = if (a > b) {
a
} else {
b
}
return maxNumber
}
- 你会发现，maxNumber 是一个多余的常量，我们可以精简下代码：
/**
* 比较两个数的大小
* @param a
* @param b
* @return 返回最大值
*/
fun getMaxNumber(a: Int, b: Int): Int {
return if (a > b) {
a
} else {
b
}
}
- 当函数只有一行逻辑体的时候，我们可以省略函数体部分，return 后面的逻辑可以理解为一行代码，只是 return 后面的返回值而已，我们可以再次精简下代码：
/**
* 比较两个数的大小
* @param a
* @param b
* @return 返回最大值
*/
fun getMaxNumber(a: Int, b: Int) = if (a > b) {
a
} else {
b
}
- 还可以，再次精简下代码：
/**
* 比较两个数的大小
* @param a
* @param b
* @return 返回最大值
*/
fun getMaxNumber(a: Int, b: Int) = if (a > b) a else b
-
when 控制语句
-
将它的参数与所有的分支条件顺序比较，直到某个分支满足条件：
/**
* 查询学生的信息
* @param name 学生名称
* @return 学生信息
*/
fun getClassName(name: String) = when (name) {
"张三" -> "7年级1班"
"李四" -> "7年级3班"
else -> "查询不到该学生的信息！"
}
- Kotlin 还可以判断类型，用 is ：
/**
* 获取数字的类型
* @param number
*/
fun getNmuberType(number: Number) {
when (number) {
is Int -> println("number is Int")
is Double -> println("number is Double")
else -> println("none of the above")
}
}
-
for - in 循环语句
-
for 循环，可以对任何提供迭代器（iterator）的对象进行遍历。
-
我们定义一个数组：
var heroNames = arrayOf("亚瑟", "刘邦", "露娜", "玄策")
- 循环遍历该数组，我们可以通过下面的方式：
- 通过角标：
for (i in heroNames.indices) {
println("这个英雄 在 $i 是 ${heroNames[i]}")
}
- 通过获取数据对象：
for (item in heroNames) {
println(item)
}
- 通过库函数：
for ((index, value) in heroNames.withIndex()) {
println("$index ----$value")
}
- 通过 iterator 迭代器：
var iterator = heroNames.iterator()
while (iterator.hasNext()) {
println(iterator.next())
}
- while 条件语句
- while(条件)…逻辑体
- do{}…while()
/**
* 打印10以内的正偶数
*/
fun getNumByWhile() {
var i: Int = 10
var j: Int = 10
while (i >= 0) {
if (i % 2 == 0) {
println("偶数i：$i")
}
i--
}
do {
if (j % 2 == 0) {
println("偶数j：$j")
}
j--
} while (j >= 0)
}
-
return
-
默认从最直接包围它的函数或者函数返回。
-
break
-
终止最直接包围它的循环。
-
continue
-
结束当前，继续下一次直接包围它的循环。
七，非空检测
- Kotlin 语言有很大的一个特点，就是做非空检测，减少开发者因 null 导致的一系列的异常错误。
//定义变量 a
var a: Int
//定义常量 b 赋空值报错
val b: String = null//Null can not be a value of a non-null type String
//赋空值报错
a = null//Null can not be a value of a non-null type In
- 在 Kotlin 语言中，默认定义的变量和常量，都是非空的，任何用到它的地方都是非空，我们可以放心的使用。
- 如何定义一个可空的数据呢？Kotlin 语言中这样定义：在对应的数据类型后面加 ？, ? 操作符表示当对象不为空时正常调用相应的方法，当对象为空时则什么都不做。
//定义变量 a
var a: Int?
//定义常量 b 赋空值正常
val b: String? = null
赋空值正常
a = null
- 既然，数对象可能为空，那么在使用的时候，如何检测非空呢？
- 直接判读 非空 !=null
//获取 b 的长度
var lenght = if (b != null) b.length else -1
- 安全调用，在对应的可空数据类型后面，也加上可空符 ？
//获取 b 的长度
b?.length//表示：b 不为空才可以调用 length 属性
var lenght = b?.length ?: -1
- 通过安全调用操作符，我们可以获取某个对象中的某个属性的某个值，例如：获取KPL中EDG（如果参赛）中露娜（如果在玩）使用的皮肤，可以如下调用：
//如果任意一个属性（环节）为空，这个链式调用就会返回 null
KPL.EDG?.LUNA?.SKIN
八，类
- 万物皆对象，Java是一门面向对象编程语言，Kotlin 语言也是类似的。定义一个类后，该类具有相应的特征，可以继承一个父类，重写方法，也可以实现接口等等。
- Any：
所有类的基类，默认继承（类似于 Java 中 Object 类）：
public open class Any {
public open operator fun equals(other: Any?): Boolean
public open fun hashCode(): Int
public open fun toString(): String
}
- Kotlin 中使用关键字 class 声明类：
//定义 Animal 动物类
class Animal {
var name: String = ""
var age: Int = 0
fun getInfo() {
println("name: $name,age: $age")
}
}
- 可以生成类的实例，修改属性值并调用相关的方法：
//类的实例
var animal: Animal = Animal()
//修改熟悉值
animal.name = "狗"
//调用方法
animal.getInfo()
- 打印结果：
name: 狗,age: 0
- 带参数的类
//定义带参数的电脑类
class Computer(var brand: String, var price: Double) {
fun getInfo() {
println("brand: $brand,price: $price")
}
}
- 修改属性调用相关的方法
Computer("lenovo", 6655.00).getInfo()
- 打印结果：
brand: lenovo,price: 6655.0
- 一个类的初始化代码，可以放到以 init 关键字作为前缀的初始化块（initializer blocks）中。
//定义带参数的电脑类
class Computer(var brand: String, var price: Double) {
init {
//初始化代码
getInfo()
}
fun getInfo() {
println("brand: $brand,price: $price")
}
}
- 继承
Kotlin 中，一个类默认是不可以被继承的，可以添加 open 关键字让该类可以被继承。
open class Animal {
}
- 子类继承父类，可以用 :
class Cat : Animal() {
}
- Cat 类不仅拥有父类 Animal 的属性和函数，还可以定义自己的属性和函数。父类的函数加上 open 关键字才可以被重写，子类重写父类的函数也要加上 override 关键字。
open fun getInfo() {
println("name: $name,age: $age")
}
override fun getInfo() {
super.getInfo()
}
- 如果你想禁止再次覆盖，使用 final 关键字。
final override fun getInfo() {
super.getInfo()
}
- 初始化顺序
本类中初始化函数和属性值，按照逻辑顺序执行，子类继承父类，先执行父类的后执行子类的逻辑：
//定义 Animal 动物类
open class Animal {
var name: String = "我是父类的属性".also(::println)
init {
println("我是父类的 init 函数")
}
}
//定义猫类继承动物类
class Cat : Animal() {
var nameCat: String = "我是子类的属性".also(::println)
init {
println("我是子类的 init 函数")
}
}
- 打印结果：
我是父类的属性
我是父类的 init 函数
我是子类的属性
我是子类的 init 函数
- 单例类
Kotlin中使用object关键字可以定义一个单例类：
object School {
fun getSchoolName() {
println("欢迎来到清华大学")
}
}
- 调用
可以通过类名，直接调用对应的属性值和函数，类似于 Java 中的静态方法的调用。但是在 Kotlin 中，它帮我们生产了一个 School 实例，并且保证全局只有一个 School 实例。
School.getSchoolName()
- 接口
Kotlin 中，接口和 Java 的关键字是相同的，使用 interface。 - 定义一个接口
interface CommonMethod {
fun eat()
fun play()
}
- 实现一个接口，用 ：后给接口名；也可以实现多个接口。
class Dog : CommonMethod {
override fun eat() {
}
override fun play() {
}
}
九，区间
- 在 Kotlin 语言中，我们可以用 a … b 表示一个 a 到 b 区间，数学中表示：[a,b] 两边都闭合的。判断是否在改区间，用 in ，不在该区间用 !in 。
- 定义区间 [a,b] ：
//年龄在10岁（包含10）到15岁（包含15岁）的年龄段
10..15
- 也可以定义一个左开右闭的区间 [a,b) ：
//年龄在10岁（包含10）到15岁（不包含15岁）的年龄段
10 until 15
- 打印年龄，每次递加1：
//输出年龄
for (i in 10..15) {
println("$i 岁")
}
- 结果：
10 岁
11 岁
12 岁
13 岁
14 岁
15 岁
- 还可以到序，用 downTo ，每次递减 1：
//输出年龄
for (i in 15 downTo 10) {
println("$i 岁")
}
- 可以设置，每次递减或者递加的步数，用 step：
//输出年龄
for (i in 15 downTo 10 step 2) {
println("$i 岁")
}
- 结果：
15 岁
13 岁
11 岁
十，集合
- Kotlin 标准库提供了一整套用于管理集合的工具，类似于 Java 中的 Set，List，Map都有自己的实现类，这些集合接口与相关函数位于 kotlin.collections 包中Kotlin 中。
根据操作，分为不可变和可变集合： - 不可变：一个 只读 接口，提供访问集合元素的操作。
- 可变： 一个 可读写 接口，通过写操作扩展相应的只读接口：添加、删除和更新其元素。
- Collection - 它是集合结构层次的根，此接口表示一个只读集合的共同行为：检索大小、检测是否为成员等等。 Collection 继承自 Iterable 接口，它定义了迭代元素的操作。
- Collection 源码：
public interface Collection<out E> : Iterable<E> {
public val size: Int
public fun isEmpty(): Boolean
public operator fun contains(element: @UnsafeVariance E): Boolean
override fun iterator(): Iterator<E>
public fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean
}
- MutableCollection
- 是一个可读写集合
- MutableCollection 源码：
public interface MutableCollection<E> : Collection<E>, MutableIterable<E> {
override fun iterator(): MutableIterator<E>
public fun add(element: E): Boolean
public fun remove(element: E): Boolean
public fun addAll(elements: Collection<E>): Boolean
public fun removeAll(elements: Collection<E>): Boolean
public fun retainAll(elements: Collection<E>): Boolean
public fun clear(): Unit
}
- 子类 List
- List 是一个有序、可以有重复元素的只读集合，可以通过索引 访问数据。
- List 源码：
public interface List<out E> : Collection<E> {
override val size: Int
override fun isEmpty(): Boolean
override fun contains(element: @UnsafeVariance E): Boolean
override fun iterator(): Iterator<E>
override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean
public operator fun get(index: Int): E
public fun indexOf(element: @UnsafeVariance E): Int
public fun lastIndexOf(element: @UnsafeVariance E): Int
public fun listIterator(): ListIterator<E>
public fun listIterator(index: Int): ListIterator<E>
public fun subList(fromIndex: Int, toIndex: Int): List<E>
}
- 创建 List 进行相关的操作
//创建 List
val heros = listOf("大乔", "后裔", "伽罗")
println("heros 的大小：${heros.size}")
println("heros 的第二个英雄是：${heros[1]}")
println("heros 的第三个英雄是：${heros.get(2)}")
println("大乔在 heros 的位置是：${heros.indexOf("大乔")}")
//打印数据
var iterator = heros.iterator()
while (iterator.hasNext()) {
println(iterator.next())
}
- 打印结果：
heros 的大小：3
heros 的第二个英雄是：后裔
heros 的第三个英雄是：伽罗
大乔在 heros 的位置是：0
大乔
后裔
伽罗
- 子类 MutableList
- 可读写的 List ， 有相关的删除、添加等操作功能。
- MutableList 源码：
public interface MutableList<E> : List<E>, MutableCollection<E> {
override fun add(element: E): Boolean
override fun remove(element: E): Boolean
override fun addAll(elements: Collection<E>): Boolean
public fun addAll(index: Int, elements: Collection<E>): Boolean
override fun removeAll(elements: Collection<E>): Boolean
override fun retainAll(elements: Collection<E>): Boolean
override fun clear(): Unit
public operator fun set(index: Int, element: E): E
public fun add(index: Int, element: E): Unit
public fun removeAt(index: Int): E
override fun listIterator(): MutableListIterator<E>
override fun listIterator(index: Int): MutableListIterator<E>
override fun subList(fromIndex: Int, toIndex: Int): MutableList<E>
}
//创建 MutableList
val heroRankings = mutableListOf("娜可露露", "公孙离", "镜")
//添加元素
heroRankings.add("张良")
//移除元素
heroRankings.remove("镜")
println("heroRankings 的数值：$heroRankings")
- 打印结果：
heroRankings 的数值：[娜可露露, 公孙离, 张良]
- 子类 Set
- Set 是一组无序、元素不可以重复的只读集合。
- Set 源码：
public interface Set<out E> : Collection<E> {
override val size: Int
override fun isEmpty(): Boolean
override fun contains(element: @UnsafeVariance E): Boolean
override fun iterator(): Iterator<E>
override fun containsAll(elements: Collection<@UnsafeVariance E>): Boolean
}
//创建 Set
var names = setOf("鲁班七号", "后裔", "张良")
println("names 的大小：${names.size}")
println("names ：$names")
- 打印结果：
names 的大小：3
names ：[鲁班七号, 后裔, 张良]
- 子类 MutableSet
- MutableSet 是一组无序、元素不可以重复的可读写集合。
- Mutable 源码：
public interface MutableSet<E> : Set<E>, MutableCollection<E> {
override fun iterator(): MutableIterator<E>
override fun add(element: E): Boolean
override fun remove(element: E): Boolean
override fun addAll(elements: Collection<E>): Boolean
override fun removeAll(elements: Collection<E>): Boolean
override fun retainAll(elements: Collection<E>): Boolean
override fun clear(): Unit
}
//创建 MutableSet
var animals = mutableSetOf("狗", "猫", "老虎")
animals.add("猫")
animals.remove("老虎")
println("animals 的大小：${animals.size}")
println("animals 的值：$animals")
- 打印结果：
animals 的大小：2
animals 的值：[狗, 猫]
- Map
- 不是 Collection 接口的继承者；但是它也是 Kotlin 的一种可读集合类型。是一组键值对，键是唯一的，值可以重复。
- Map 源码：
public interface Map<K, out V> {
public val size: Int
public fun isEmpty(): Boolean
public fun containsKey(key: K): Boolean
public fun containsValue(value: @UnsafeVariance V): Boolean
public operator fun get(key: K): V?
public val keys: Set<K>
public val values: Collection<V>
public val entries: Set<Map.Entry<K, V>>
public interface Entry<out K, out V> {
public val key: K
public val value: V
}
}
//创建 Map- 打印结果：
mapHeros 的所有的 keys: [小名, 小王]
mapHeros 的所有的 values: [2021, 2022]
小名在哪个位置：2021
编号为2021的英雄是否存在：true
- MutableMap
- Map 的子类、可读写的集合。
- MutableMap 源码：
public interface MutableMap<K, V> : Map<K, V> {
public fun put(key: K, value: V): V?
public fun remove(key: K): V?
@SinceKotlin("1.1")
@PlatformDependent
public fun remove(key: K, value: V): Boolean {
// See default implementation in JDK sources
return true
}
public fun putAll(from: Map<out K, V>): Unit
public fun clear(): Unit
override val keys: MutableSet<K>
override val values: MutableCollection<V>
override val entries: MutableSet<MutableMap.MutableEntry<K, V>>
public interface MutableEntry<K, V> : Map.Entry<K, V> {
public fun setValue(newValue: V): V
}
}
//创建 MutableMap- 打印结果：
ranking 的值：{1=鲁班, 2=安琪拉, 3=后裔}
十一，结语
参考资料：
- Kotlin 中文网 https://www.kotlincn.net/
- 【第一行代码】https://www.ituring.com.cn/book/2744
谢谢阅读，如有错误和侵权，望联系作者指正！本文完毕~