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;
}

要点:

1. kotlin中没有基本数据类型(int，float等)，都是以对象形式存在(Int，Float)，kotlin也没有数组，以Array类存在
2. kotlin以 fun 关键字开头，而java以 返回类型 开头，kotlin的 返回类型以 :返回类型 的形式衔接在函数声明括号后
3. kotlin的所有变量声明都是 变量名: 变量类型 ，java则是 变量类型 变量名
4. kotlin也有三目运算符，不过写法是 if (表达式) 表达式正确时的值 else 表达式错误时的值，java则是 表达式 ? 表达式正确时的值 : 表达式错误时的值
5. 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}")

要点：

1. kotlin创建对象是 Xxx() ，java是** new Xxx();**
2. kotlin调用属性的getter方法直接 xxx.property
3. 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;
}

要点：

1. when不用java中的 break
2. when用 -> 替代 java中的 case
3. when用 else 替代java中的 default
4. 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"
        }

要点：

1. when表达式会把最后一行代码的结果当为返回值(见people2的情况，没有写return，但是会返回”is people2″)
2. 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

1. kotlin没有 throws 关键字（想起java被throws支配的恐惧了么）
2. 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())

要点：

1. 我们定义了一个add2函数用于将一个 数+2 并返回
2. add2函数面前使用 Int. 表示该函数是对Int类的扩展（就像是Int类本身的方法一样）
3. add2函数体内的this其实就是调用该方法的对象（本例中this就是0）
4. this可以省略，就变成了 return +2
5. java中调用就得写成 KotlinDemoKt.add2(0) 其实就是被编译成了静态函数
6. 如果Int类也有add2则优先调用Int类的add2函数，即成员方法优先调用
7. 如果子类和基类有同名的扩展函数，调用哪个扩展函数由调用对象的声明类型决定
8. 除了有扩展函数也有扩展属性，不过扩展属性必须要有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~