参考教程
https://www.jianshu.com/p/e42a9ea09ac0
https://www.runoob.com/kotlin/kotlin-basic-syntax.html
kotlin官方文档中文版
作为一名java开发者，先看看java与kotlin的区别

java与kotlin的区别

操作对象：在Kotlin中，所有变量的成员方法和属性都是对象，若无返回值则返回Unit对象，大多数情况下Uint可以省略；Kotlin 中没有 new 关键字
数据类型 & 转换：在Java中通过装箱和拆箱在基本数据类型和包装类型之间相互转换；在Kotlin中，而不管是常量还是变量在声明是都必须具有类型注释或者初始化，如果在声明 & 进行初始化时，会自行推导其数据类型。
编译的角度：和Java一样，Kotlin同样基于JVM。区别在于：后者是静态类型语言，意味着所有变量和表达式类型在编译时已确定。
撰写：在Kotlin中，一句代码结束后不用添加分号 “；”；而在Java中，使用分号“;”标志一句代码结束。

基本语法

导包

包的声明应处于源文件顶部：与java一样
采用import关键字导包 与java一样不同的是它还能导入函数
比如

package my.demo
import  kotlin.text.*

程序入口 main函数

我使用的是Andorid Studio3.5，使用3.1版编译不会出错，运行的时候会报错

fun main() {
    println("Hello World!")
}

函数

函数定义使用关键字 fun，参数格式为：参数 : 类型

fun main() {
    println(sum(1, 1))
    println(sum2(2, 2))
    println("Hello World!")
}

//sampleStart
fun sum(a: Int, b: Int): Int {// Int 参数，返回值 Int
    return a + b
}

fun sum2(a: Int, b: Int) = a + b //不得不佩服kotlin的超前思想还能这么玩，自行推导类型

表达式作为函数体，返回类型自动推断：

fun sum(a: Int, b: Int) = a + b
public fun sum(a: Int, b: Int): Int = a + b   // public 方法则必须明确写出返回类型  经测试不写好像也没问题...

无返回值的函数(类似Java中的void)：

fun printSum(a: Int, b: Int): Unit { 
    print(a + b)
}
// 如果是返回 Unit类型，则可以省略(对于public方法也是这样)：
public fun printSum(a: Int, b: Int) { 
    print(a + b)
}

默认参数
函数参数可以有默认值，当省略相应的参数时使用默认值。与其他语言相比，这可以减少重 载数量：
a. 如果是继承过来的则不能在子类写默认值了

open class A {
    open fun hi(string: String = "Hi") {

    }
class B : A() {
    override fun hi(string: String) {//不能有默认值
        println(string)
    }
}

fun main() {
    val b = B()
    b.hi()
}
}

b. 如果一个默认参数在一个无默认值的参数之前，那么该默认值只能通过使用命名参数调用该函数来使用：比如

fun foo(num: Int = 0, s: String) {
    println(num)
    println(s)
}
fun main() {
    foo(s = "哈哈")
}

如果在默认参数之后的最后一个参数是 lambda 表达式，那么它既可以作为命名参数在括号内 传入，也可以在括号外传入：

fun foo(bar: Int = 0, baz: Int = 1, qux: () -> Unit) {
    println(baz)
}
调用的时候
    foo {  }//可以这样
    foo(qux = {})//可以这样

可变长参数函数

函数的变长参数可以用 vararg 关键字进行标识：比如

fun vars(vararg v:Int) {
    for (i in v) {
        print(i)
    }
}

print和println的区别就是println可以换行

lambda(匿名函数) 还有这种操作 我的天

lambda表达式使用实例：

    var sumLambda: (Int, Int) -> Int = { x, y -> x + y }
    print(sumLambda(1, 2))

定义常量和变量

可变变量定义：var 关键字
var <标识符> : <类型> = <初始化值>
不可变变量定义：val 关键字，只能赋值一次的变量(类似Java中final修饰的变量)
val <标识符> : <类型> = <初始化值>

常量与变量都可以没有初始化值,但是在引用前必须初始化
编译器支持自动类型判断,即声明时可以不指定类型,由编译器判断。

    val a: Int = 1  // 立即赋值
    val b = 2 //编译器自动推断
    val c: Int      //  如果没有初始值类型不能省略
    c = 3 //明确赋值
    println("a=$a,b=$b,c=$c")
    var d = 5
    d+=1 //改变变量值
    println("d=$d")
    var s="Hello World!"
    println("你好世界$s")

注释 (与java一样不再赘述)

字符串

字符串用String类型表示。字符串是不可变的。字符串的元素字符可以使用索引运算 符访问:s[i] 。可以用for循环迭代字符串:

fun main()  { 
val str =   "abcd" //sampleStart 
for (c  in  str)    
{               println(c) 
}
 //sampleEnd
 }

与java字符串一样可以使用+操作符连接字符串。但是优先使用字符串模板或原始字符串而不是字符串连接。
字符串模板
字符串字面值可以包含模板表达式 ，即一些小段代码，会求值并把结果合并到字符串中。 模 板表达式以美元符（ $ ）开头，由一个简单的名字构成:

    val i = 10
    println("i = $i")//输出 i = 10
    //或者用花括号括起来的任意表达式:
    val s = "abc"
    println("$s 的长度是${s.length}")//输出 abc 的长度是3
    println("$s 的长度是${b.len(s)}")//输出 abc 的长度是3

NULL检查机制

Kotlin的空安全设计对于声明可为空的参数，在使用时要进行空判断处理，有两种处理方式，字段后加!!像Java一样抛出空异常，另一种字段后加?可不做处理返回值为 null或配合?:做空判断处理

类型检测及自动类型转换

我们可以使用 is 运算符检测一个表达式是否某类型的一个实例(类似于Java中的instanceof关键字)。

fun getStringLength(obj: Any): Int? {//当返回值可能为空时使用?
    if (obj !is String)
        return null
    // 在这个分支中, `obj` 的类型会被自动转换为 `String`
    return obj.length
}

区间

区间表达式由具有操作符形式 .. 的 rangeTo 函数辅以 in 和 !in 形成。
区间是为任何可比较类型定义的，但对于整型原生类型，它有一个优化的实现。以下是使用区间的一些示例:

    for (i in 1..4) println(i) // 输出“1234”
    for (i in 4..1) println(i) // 什么都不输出
    var x = 5
    if (x in 1..10) { // 等同于 1 <= i && i <= 10
        println(x)
    }
// 使用 step 指定步长
    for (i in 1..4 step 2) println(i) // 输出“13”  类似于等差数列

    for (i in 4 downTo 1 step 2) println(i) // 输出“42”  降序
// 使用 until 函数排除结束元素
    for (i in 1 until 10) {   // i in [1, 10) 排除了 10
        println(i)
    }

笔记

1.关于lambda表达式（匿名函数）的理解
通常完整Lambda表达式会由花括号{}括起来，在花括号内先定义完整语法形式的参数声明（并具有可选的类型注解），然后紧跟着 - >符号，- >符号就是由另一个花括号括起来的方法体部分。如果推测的Lambda的返回类型不是Unit，则Lambda体内的最后一个（或可能单个）表达式被视为返回值。
Lambda表达式的完整语法形式：

val sum = { x: Int, y: Int -> x + y }

把所有可选的注解都保留形式

val sum: (Int, Int) -> Int = { x, y -> x + y }

实例

fun main() {
    //lambda(匿名函数)的理解
    val sumLambda: (Int, Int) -> Int = { x, y -> x + y }
    println(sumLambda(1, 2))  // 输出 3
    val lam = {a:Int, b:Int->a-b}
    println(lam(3,2))
}