kotlin 基础学习

kotlin 学习

kotlin优点
语法简洁，支持lambda表达式，强大的when语法，不用写分号结尾

kotlin 语法
定义
常量用val，变量用var 关键字在前面，类型以“：”隔开在后面，也可以省略直接赋值，类型后带问号？表示可为空类型（默认空安全）。
常量val延迟加载by lazy{},默认线程安全，关闭线程安全lazy(LazyThreadSafetyMode.NONE){},变量var延迟加载lateinit。

val c:Int  //如果不在声明时初始化则必须提供变量类型
c = 1      //明确赋值

注释
Kotlin中的块注释允许嵌套

类型检测及自动类型转换
使用is运算符检测一个表达式是否某类型

obj !is String

比较两个数字
Kotlin中没有基础数据类型，只有封装的数字类型，你每定义的一个变量，其实kotlin帮你封装了一个对象，这样可以保证不会出现空指针。数字类型也一样，
所以在比较两个数字的时候，就有比较数据大小和比较两个对象是否相同的区别了。
在kotlin中，三个等号===表示比较对象地址，两个==表示比较两个值大小

类型转换
由于不同的表示方式，较小类型并不是较大类型的子类型，较小的类型不能隐式转换为较大的类型。这意味着在不进行显式转换的情况下我们不能把Byte型值赋给一个Int变量

val b:Byte = 1
val i:Int = b.toInt()

每种数据类型都有下面的这些方法，可以转化为其他的类型
toByte(): Byte
toShort(): Short
toInt(): Int
toLong(): Long
toFloat(): Float
toDouble(): Double
toChar(): Char

字符
和java不一样，kotlin中的Char不能直接和数字操作，Char必须使用单引号‘包含起来的。比如’0‘，’a'

区间
区间表达式由具有操作符形式..的rangeTo函数辅以in 和!in形成

for(i in 1..4) print(i) //输出 1234    
for(i in 4..1) print(i) //什么都不输出

for(i in 1..4 step 2) print(i)  //输出“13” 使用step指定步长
for(i in 4 downTo 1 step 2) print(i) //输出“42”

//使用until函数排除结束元素

for(i in 1 until 10){  //i in [1,10) 排除了10

}

条件
if...else 正常使用，不过移除了switch用更强大的when替代，when子式可以是常量、变量、返回数值的表达式、返回boolean值的表达式，强大到用来替换if...else if

// 测试值 x = 0, -1, 1, 2, 3, 6, 10
var x = 10
when (x) {
    //常量
    2 -> println("等于2")
    //数值表达式
    if (x > 0) 1 else -1 -> println("大于0并等于1，或小于0并等于-1")
    //Boolean类型表达式
    in 1..5 -> println("范围匹配1-5")
    !in 6..9 -> println("不是6-9")
    is Int -> println("类型判断")
    else -> println("else")
}
// 代替if...else if
when{
    x > 6 && x <= 10  ->  println("大于6小于等于10")
    x < 6 -> println("小于6")
    else -> println("else")
}

循环
while和do...while同Java无区别，for则有很大改变并多出了几个变种
例：

val list = arrayListOf("aa", "bb", "cc")
//递增for (int i = 0; i < list.size(); i++)
for (i in list.indices) {
   print(list[i])
}
//递增for (int i = 2; i < list.size(); i++)
for (i in 2..list.size-1) {
   print(list[i])
}
//递减for (int i = list.size() - 1; i >= 0; i--)
for (i in list.size - 1 downTo 0) {
    print(list[i])
}
//操作列表内的对象
for (item in list) {
    print(item)
}
//加强版
for（（i， item） in list.witnIndex()） {
    print(list[i])
    print(item)
}
//变种版
list.forEach {
    print(it)
}

list.forEach {
    print(it)
}

list.forEachIndexed { i, s ->
    print(list[i])
    print(s)
}

list.forEachIndexed(object :(Int,String) -> Unit{
    override fun invoke(i: Int, s: String) {
        print(list[i])
        print(s)
    }
})

冒号 常量变量的类型声明，函数的返回值，类的继承，使用java类的时候。kotlin最终还是编译成Java字节码，使用到Java类是必然的，在Kotlin语法如下：

val intent = Intent(this,MainActivity::class.java)  //类名::class.java

Kotlin特色
Java的getter/setter方法自动转换成属性，对应到Kotlin属性的调用
自定义getter/setter重点在field，跟我们所熟悉的Java的this指代当前类一样，field指代当前参数，直接使用参数名instance代替不会报错但是单例就没效果了

class User {
    companion object {
        @Volatile var instance: User? = null
            get() {
                if (field == null) {
                    synchronized(User::class.java) {
                        if (field == null)
                            field = User()
                    }
                }
                return field
            }
    }

    var name: String? = null
    var age: String? = null
}

字符串模板
在Java中拼接字符串的代码可读性都很差，在kotlin字符串拼接非常简洁，只需用$后面加上参数名，复杂的参数要加上{}

val user = User()
//赋值
user.name = "tutu"
user.age = "23"
//取值
val name - user.name
val age = user.age
var userInfo = "name:${user.name},age:$age"
//输出结果：name:tutu,age:23

lambda 就是把接口名、方法名和参数类型省略掉不写再加个 ->
//无参数无返回值
Thread(Runnable {

}).start()
//单参数无返回值
view.setOnClickListener { v ->

}
//多参数有返回值
view.setOnKeyListener(View.OnKeyListener {v,keyCode,event ->

})

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

//类型后面加?表示可为空
var age:String? = "23"
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1

注意事项
内部类和参数默认为public，而在Java中为default即在同一个包中可见，类默认为不可继承（final），想要可被继承要声明为open或abstract取消了static关键字，静态方法和参数统一写在companion object块，internal模块内可见，inner内部类