Kotlin-初步认识

参考：
- Kotlin Primer·第二章·基本语法
- 用 Kotlin 开发 Android 项目是一种什么样的感受？
- 快速上手 Kotlin 的 11 招

基本语法

语句

• in关键字
  判断一个独享是否存在某一个区间内，可以使用in关键字
• when表达式
• 智能类型推荐
  判断一个对象是否为一个类的实例，可以使用is关键字
• 空值检测

//当data不为空的时候，执行语句块
data?.let{
    //... 
}

//相反的，以下代码当data为空时才会执行
data?:let{
    //...
}

函数

• 基本函数声明：
  //使用关键字fun声明，创建了一个名为say（）的函数，接受一个String类型的参数，并返回一个String类型的值

 fun say(str: String): String {
    return str
}

fun say(str: String): String = str

fun getIntValue(value: Int) = value

• 变参函数

//在Java中，我们这么表示一个变长函数
public boolean hasEmpty(String... strArray){
    for (String str : strArray){
        if ("".equals(str) || str == null)
            return true;
    }
    return false;
}

//在Kotlin中，使用关键字vararg来表示
fun hasEmpty(vararg strArray: String?): Boolean{
    for (str in strArray){
        if ("".equals(str) || str == null)
            return true 
    }
    return false
}

Kotlin代码

class StringUtils {
    companion object {
       fun isEmpty(str: String): Boolean {
            return "" == str
        }
    }
}

compnion object表示外部类的一个伴生对象，可以理解为外部类自动创建一个对象作为自己的field。

Kotlin默认会将所有的包级别函数放在一个自动生成的叫EcampleKt的类中

在Kotlin中没有static关键字，那么如果子啊Java代码中想要通过类名调用一个 Kotlin 类的方法，你需要给这个方法加入@JvmStatic注解

类的特性

构造函数

class Person(private var name: String) {

    init {
        name = "Zhang Tao"
    }

    internal fun sayHello() {
        println("hello $name")
    }
}

次级构造函数

class Person(private var name: String) {

    private var description: String? = null

    init {
        name = "Zhang Tao"
    }

    constructor(name: String, description: String) : this(name) {
        this.description = description
    }

    internal fun sayHello() {
        println("hello $name")
    }
}

修饰符

• open:为每个变量和方法添加final修饰符
• internal：它是模块级别的访问权限
  

  data数据类：data修饰的类称之为数据类

单例类设计

class Single private constructor() {
    companion object {
        fun get():Single{
            return Holder.instance
        }
    }

    private object Holder {
        val instance = Single()
    }
}

动态代理

interface Animal{
    fun bark()
}

class Dog :Animal {
    override fun bark() {
        println("Wang Wang")
    }
}

class Cat(animal: Animal) : Animal by animal {
}

fun main(args: Array<String>) {
   Cat(Dog()).bark()
}

函数与闭包

• Unit 空函数：不需要实现其方法。相当于表示一个值的类型。类似于Java中的void类型

editText.addTextChangedListener(object : TextWatcher {
    override fun afterTextChanged(s: Editable?) = Unit

    override fun beforeTextChanged(s: CharSequence?, start: Int, count: Int, after: Int) = Unit

    override fun onTextChanged(s: CharSequence?, start: Int, before: Int, count: Int) = Unit
})

• Nothing 是一个值的类型。如果一个函数不会反悔，则会声明为范围Nothing类型

public class Nothing private constructor()  

复杂的函数

• 运算符重载

fun main(args: Array<String>) {
  for (i in 1..100 step 20) {
    print("$i ")
  }
}

上面的代码实际..的原理实际上就是对一个 Int 值，调用他的 rangeTo方法，传入一个 Int 参数，并返回一个区间对象。

for (i in 1.rangeTo(100) step 20) {
    print("$i ")
}

闭包

• 自执行闭包 ：自执行闭包就是在定义闭包的同时直接执行闭包，一般用于初始化上下文环境

{ x: Int, y: Int ->
    println("${x + y}")
}(1, 3)

Lambda

Kotlin中真正把Lambda抽象为一个类型

val printMsg = { msg: String -> 
    println(msg) 
}

fun main(args: Array<String>) {
  printMsg.invoke("hello")
}

//fun main(args: Array<String>) {
//  printMsg("hello")
//}

首先声明了一个名为printMsg的Lambda,它接收了一个String类型的值作为参数，然后main函数中调用它，如果还想省略，你还可以在调用时直接省略invoke，像函数一样使用。

• 
  
• 高阶函数
  

Lambda 表达式最大的特点是可以作为参数传递。当定义一个闭包作为参数的函数，称这个函数为高阶函数。

fun main(args: Array<String>) {
    log("world", printMsg)
}

val printMsg = { str: String ->
    println(str)
}

val log = { str: String, printLog: (String) -> Unit ->
    printLog(str)
}
//其实就是 log 有两个参数，一个str:String，一个printLog: (String) -> Unit。