Kotlin也没那么难（一）
do not speak，show my code...
基本概念
函数
kotlin:
fun functionName(parameter1: Int, parameter2: Int): Int {
//该函数返回两者最大值
return if (parameter1 > parameter2) parameter1 else parameter2
}
java:
Integer functionName(Integer parameter1, Integer parameter2) {
//该函数返回两者最大值
return parameter1 > parameter2 ? parameter1 : parameter2;
}
要点:
- kotlin中没有基本数据类型(int，float等)，都是以对象形式存在(Int，Float)，kotlin也没有数组，以Array类存在
- kotlin以 fun 关键字开头，而java以 返回类型 开头，kotlin的 返回类型以 :返回类型 的形式衔接在函数声明括号后
- kotlin的所有变量声明都是 变量名: 变量类型 ，java则是 变量类型 变量名
- kotlin也有三目运算符，不过写法是 if (表达式) 表达式正确时的值 else 表达式错误时的值，java则是 表达式 ? 表达式正确时的值 : 表达式错误时的值
- kotlin语句末尾可以省略分号
表达式函数体
kotlin中if是表达式，而不是语句。语句是没有自己的值，而表达式是有值的。表达式可以作为其他表达式的一部分也可以作为函数的返回值。在kotlin中除了循环（for、do、while）以外大多数控制结构都是表达式。
所以上面的函数就可以简化成以下代码：
fun functionStruct(parameter1: Int, parameter2: Int) =
if (parameter1 > parameter2) parameter1 else parameter2
细心的朋友可能发现了上面的函数没有声明返回类型，因为对于返回一个表达式的函数来说，编译器会自动分析返回类型，术语叫 类型推导
变量
kotlin不会以变量类型开头，因为有些的变量声明的类型是可以省略的
var number0 = 100
val number1 = 100
val number2 : Int = 100
val number3 //编译不通过
val number4 : Int //编译不通过
var 表示该变量是可变变量，可以重新赋值
val 表示该变量是不可变变量，不可以重新赋值
字符串模板 "...${变量}..."
eg:var age = "my age is ${number0}"，这种情况下大括号可以省略
如果是java会写成 String age = "my age is " + number0;
eg:"...${list.get(0)}..."这个时候大括号不能省
类和属性
kotlin中默认public修饰符
kotlin定义一个类最简单的方法就是class People(var name: String, val age: Int)
以上代码定义了一个People类，该类有两个属性name和age
由于name被var修饰，所以kotlin会为name创建一个getter和一个setter方法
由于age被val修饰，所以kotlin会为name创建一个getter方法
使用起来很简单
val my = People("name", 20)
my.name = "new Name"
println("my name is ${my.name} and my age is ${my.age}")
要点：
- kotlin创建对象是 Xxx() ，java是** new Xxx();**
- kotlin调用属性的getter方法直接 xxx.property
- kotlin调用属性的setter方法直接 xxx.property = value
注意:
如果写成class People(name: String, age: Int)，即省略了var和val，则这两个变量都只是构造函数用的临时变量，也就是说kotlin不会再自动给People类创建name和age变量
自定义getter和setter方法
class People(var name: String, val age: Int) {
var desc: String = "这是我的个人描述"
get() {
print("调用了getter方法")
return "my name is $name and my age is $age"
}
set(value) {
print("调用了setter方法")
field = value
}
}
需要注意的是这里有个 field 变量，这个变量术语叫做 幕后变量 ，这个后面我们会深入了解，这里只需要知道把要更新的值赋予给该变量就OK啦
目录和包
kotlin的包声明形式和java一样：package com.example.ice.kotlindemo，不过有意思的是kotlin不强制包声明和文件路径一致，也就是说该kotlindemo.kt文件不必强制放在com/example/ice/目录下。
kotlin文件可以同时声明多个类，甚至还可以声明函数和变量！java中只能在类中声明函数，并且一个java文件只能有一个public class的而且该class类名还必须和文件名一致
枚举和When
enum
enum class Color {
BLUE, RED, GREEN
}
kotlin中enum是软关键字，只有出现在class面前才有特殊意义，其他情况你甚至可以当一个变量使用 val enum: Color = Color.BLUE
when
when有点类似java中的switch，但是when是表达式
kotlin:
fun testWhen(enum: Color) =
when (enum) {
Color.BLUE -> "blue"
Color.RED -> "red"
Color.GREEN -> "green"
else -> "default"
}
java:
public String testWhen(Color color) {
String returnValue;
switch (color) {
case RED:
returnValue = "red";
break;
case BLUE:
returnValue = "blue";
break;
case GREEN:
returnValue = "green";
break;
default:
returnValue = "default";
break;
}
return returnValue;
}
要点：
- when不用java中的 break
- when用 -> 替代 java中的 case
- when用 else 替代java中的 default
- when是表达式不是语句块
在when分支上合并多个选项
when (enum) {
Color.BLUE, Color.RED -> "blue or red"
Color.GREEN -> "green"
else -> "default"
}
when结构中可以使用任意对象
var people1: People = People("name1", 20)
var people2: People = People("name2", 20)
fun testWhen2(people: People) =
when (people) {
people1 -> "is people1"
people2 -> {
"is people2"
}
else -> "no match"
}
要点：
- when表达式会把最后一行代码的结果当为返回值(见people2的情况，没有写return，但是会返回"is people2")
- when表达式某种情况下只有返回语句可以省略大括号(见people1的情况)
不带参数的when
fun testWhen3() =
when {
1 > 2 -> print("1 > 2")
2 > 1 -> print("2 > 1")
else -> throw ArithmeticException("error")
}
类型转换
kotlin使用 is 代替java的 instanceof 进行类型判断
kotlin使用 as 进行显示转换 var num = 100 as Float
注意：as也可以用于导入语句 import xxx.xxx.People as P 这样P就代表了People
循环
kotlin的循环比较于java来说没有很大的改变，但是多了一些关键字需要我们注意
var i = 0
for (i in 0..100) { //打印 01234..100
//for (i in 0 until 100) { //打印 01234..99
//for (i in 100 downTo 0 step 2) { //打印 1009896..0
print(i)
}
in 常常用来迭代list或map
val list = listOf(1, 2, 3)
for (i in list) {
print(i)
}
kotlin中使用 listOf 方法可以创建一个list
如果你想迭代list的同时获取当前的index,可以使用如下写法
for ((index, value) in list.withIndex()) {
//(index,value)的写法专业术语叫做解构声明，后面我们会深入了解
print("index = $index and value = $value")
}
in 也可以用来判断对象是否在集合中
if (2 in list) {
print("2 exist in list")
}
!in 关键字
Emm，这个看前面一个 ! 就知道是和 in 相反的结果了
try catch finally
- kotlin没有 throws 关键字（想起java被throws支配的恐惧了么）
- try也是一个表达式
val myAge = try {
1 / 0
} catch (e: Exception) {
print(e)
} finally {
100
}
函数
集合创建
listOf(1, 2, 3)
mutableListOf(1, 2, 3)
setOf(1, 2, 3)
mutableSetOf(1, 2, 3)
mapOf(1 to "1", 2 to "2", 3 to "3")
mutableMapOf(1 to "1", 2 to "2", 3 to "3")
有mutable前缀的方法创建的集合，元素是可以增添、移除、修改的
默认参数
fun defaultParaFun(para1: Int = 0, para2: Int, para3: Int) = para1 + para2 + para3
defaultParaFun(para2 = 2, para3 = 4)
我们给参数para1设置了默认值0
在调用该函数的时候我们对传入的值进行了显示的声明参数，比如2就是参数para2的值，3就是参数para3的值，此时函数返回值为5（0+2+3）
有意思的是如果我们给所有参数都加默认值：
fun defaultParaFun(para1: Int = 0, para2: Int = 1, para3: Int = 2) = para1 + para2 + para3
defaultParaFun() // 0+1+2
defaultParaFun(para3 = 5) // 0+1+5
defaultParaFun(para2 = 5) // 0+5+2
defaultParaFun(para1 = 5, para2 = 5) // 5+5+2
同时java是不支持默认参数的，所以我们可以给方法加上@JvmOverloads注解。这样的话kotlin编译器会将该方法生成一系列重载方法
result.png
由于我这个例子中 defaultParaFun 是直接写在 KotlinDemo.kt 文件中的（术语叫顶级函数），所以java调用要使用 KotlinDemoKt.defaultParaFun 形式，顶级函数是不是很像java中的静态函数（kotlin是没有static关键字的！）？
扩展函数
fun Int.add2(): Int {
return this + 2
}
print(0.add2())
要点：
- 我们定义了一个add2函数用于将一个 数+2 并返回
- add2函数面前使用 Int. 表示该函数是对Int类的扩展（就像是Int类本身的方法一样）
- add2函数体内的this其实就是调用该方法的对象（本例中this就是0）
- this可以省略，就变成了
return +2 - java中调用就得写成
KotlinDemoKt.add2(0)其实就是被编译成了静态函数 - 如果Int类也有add2则优先调用Int类的add2函数，即成员方法优先调用
- 如果子类和基类有同名的扩展函数，调用哪个扩展函数由调用对象的声明类型决定
- 除了有扩展函数也有扩展属性，不过扩展属性必须要有getter函数，同时也不能初始化
可变参数
fun varargFun(vararg list: Int) {
print(list[0])
}
fun varargFun2(array: Array<Int>) {
listOf(*array)
}
varargFun(1, 2, 3)
vararg 关键字表示该参数是可变参数
* 关键字是展开运算符，在该例中把array展开为多个对象并用于构造list
中缀调用
细心的朋友可能看到了之前我们定义map时用的是mapOf(1 to "1", 2 to "2", 3 to "3")
这里的to其实就是中缀调用，实际上就是一个to函数，中缀调用就是把方法名称放在两个参数中间，记得空格
我们可以看源码 infix fun <A, B> A.to(that: B): Pair<A, B> = Pair(this, that)
其中尖括号里的是泛型，Pair是一个有两个成员变量的类（一个叫first一个叫second）
我们先把infix关键字盖住，其实这就是一个扩展函数对不对！
我们在加上infix关键字，这个扩展函数就可以中缀调用了
需要注意的是，infix只能用于只有一个参数的函数上
解构声明
val (para1, para2) = 1 to "1"
在这个例子中，para1就是1，para2就是"1"
其实我们在之前循环的章节就有用到过解构声明
for ((index, value) in list.withIndex()) {
print("index = $index and value = $value")
}
解构声明不仅可以用在Pair和List也可以用在Map，我们会在后面的文章中深入了解解构规则
字符串
var string1 = "\\"
var string2 = """\"""
其实string1和string2都是表示
只不过普通的字符串包含转义，\ 就是个转义字符，所以 \\ 才能代表
而在多重引号字符串中就不包含转义，所以可以直接用 \ 来表示
注：多重引号字符串用来写正则特别方便
局部函数
这是我最喜欢的语法糖之一：函数里可以再定义函数
fun outer(){
print("outer invoke")
fun inner(){
print("inner invoke")
}
inner()
}
局部函数中可以访问外部函数中的所有参数和变量（记得定义在局部函数之前哦）！
结语
通过本篇文章的学习我们已经算 入门kotlin 了，下篇文章我会写 类和接口，lambda编程以及可空性 相关。基本上这两篇文章内容熟练掌握就可以应对开发需求，之后会有篇幅讲Kotlin的高阶使用：反射、泛型等。
最后祝大家国庆Happy~
