kotlin学习（三）

for循环

fun main(arg: Array<String>) {
    var a: Int? = null
    println(a)
}

跳出循环和其他语言的continue 和break 用法一致

foreach循环

fun main(arg: Array<String>) {
    var a = "storm"
    a.forEach {
        println(it)
    }
}

退出循环跳到指定标签处

fun main(arg: Array<String>) {
    var a = "storm"
    var b = "super"
    tag_demo@for (i in a){
        for (j in b){
            println("i:$i ,j:$j ")
            if (i=='m'&& j == 's'){
                break@tag_demo
            }
        }
    }
    println("执行结束")
}

使用@符号定义标签，类似c语言中的goto语法，先定义一个标签，然后在break、continue、return的时候均可以@跟标签名，跳转到指定位置
此处需要注意的是kotlin中”双引号表示字符串，’单引号表示字符，”双引号内尽管只有一个字符也算字符串不能直接和单个字符进行比较

区间
区间可以定义一个指定范围的迭代器，相比于声明一个同样的数组，可以明显的节省内存，提高代码效率

fun main(arg: Array<String>) {
    var a = 1..100
    for (i in a){
        println(i)
    }
    var b = IntRange(1,100)
    for (i in b){
        println(i)
    }
    var c = 1.rangeTo(100)
    for (i in c){
        println(i)
    }
}

见名知义，定义区间有三种形式，第一种使用..,第二种使用基本数据类型对应的区间类型，第三种使用基础类型值的rangeToapi
区间还有另外两种遍历方式

fun main(arg: Array<String>) {
    var a = 1..100
    a.forEachIndexed{index, i ->
        println("index: $index ,i: $i ")
    }
    for ((index, i) in a.withIndex()){
        println("index: $index ,i: $i ")
    }
}

区间反转

fun main(arg: Array<String>) {
    // 反向区间
    var a = 100 downTo 1
    for (i in a){
        println(i)
    }
    // 区间反转
    var b = a.reversed()
    for(i in b){
        println(i)
    }
    for (i in b step 5){
        println(i)

    }
}

数组

fun main(arg: Array<String>) {
    var a = arrayOf('a','b','c')
    var b = arrayOf("string","string")
    var c = arrayOf(1,2,3)
    var d = arrayOf("string",'c', 1)
    var e = IntArray(20){1} // 定义一个大小为20，初始值为1的整型数组
    println(a)
    println(b)
    println(c)
    println(d)
    println(e)


    println(a.indexOf('a'))
    println(a.lastIndexOf('b'))
    println(a.indexOfFirst { it.equals('c') })

}

when
java中有switch，那么kotlin中的when语句就相当于java的switch，不过kotlin的when做了加强，它可以允许不带参数，且可以有返回值

fun main(arg: Array<String>) {
    var a = 60
    when{
        a < 60->{
          println("不及格")
        }
        a in 60..80 ->{
            println("及格")
        }
        a > 80 ->{
            println("优秀")
        }
    }

}

异常

fun main(arg: Array<String>) {
    var a = 2
    var b = 0
    try {
        print(a/b)
    }catch (e: ArithmeticException){
        println("除数不能为零")
    }
    finally {
        println("finnaly")
    }

}

面向对象

fun main(args: Array<String>) {
    val girl = Girl()
    println(girl.name)
    println(girl.age)
    girl.greeting()

    val rect = Rect()
    println(rect.long)
    println(rect.width)
}
//矩形
class Rect{
    //静态属性
    var long:Int = 100
    var width:Int = 100
}
//妹子
class Girl{
    //静态属性
    var name:String = "李四"
    var age:Int = 20
    //动态行为
    fun greeting(){
        println("hello  你好")
    }
}

运算符重载
kotlin中支持运算符重载，这点和c++的运算符重载很像，也是根据操作对象属性来定义的
重载定义关键字operator

fun main(args: Array<String>) {
    var a = 10
    var b = 20
    a.plus(b)

    val girl1 = Girl()
    val girl2 = Girl()
    girl2.name = "王五"
    val newGirl = girl1 + girl2
    println(newGirl)

//    println(newGirl.age)
}
class Girl{
    //定义对应的运算符函数
//    operator fun plus(girl:Girl):Girl{
//        return this
//    }
//    operator fun plus(age:Int):Girl{
//        this.age += age
//        return this
//    }
    operator fun plus(girl:Girl):Int{
        return this.age+girl.age
    }
    var name:String = "张三"
    var age:Int = 20
}