kotlin学习(一)------基础

语法基础：
定义一个包：

package baseTest.one

定义包的方式和Java一模一样。这里不多做解释。

定义方法：

//定义方法用fun关键字，add1是方法名，a和b时形参列表中的参数，为Int类型
//返回值为Int类型
fun add1(a:Int,b:Int):Int{
    return a+b
}

上面的方法因为返回的值和语句很简单能简化为：

fun add(a:Int,b:Int)=a+b

注意kotlin可以不写分号结束，一行就是一句。

下面定义两个等价的没有返回值的方法：

fun show(){
    println("my name is haha ")
}

fun show1():Unit{
    print("haha")
}

上面的两个方法完全等价，kotlin不像java，没有返回值可以不写。
这一点超级棒，很简洁。

下面是局部变量的定义：

fun test(){
    val a:Int =2 //定义一个Int类型的变量
    val b =2    //kotlin会自动推断b为Int类型
    val c:Int  //如果定义时明月赋予初始值就不能忽略类型
    c=2
}

kotlin还能使用字符串模板，这样我们输出就就不要想java那样“”+“”这样麻烦了

fun main(args:Array<String>){
    val a = 1
    var str = "I have ${a} apple"
    var str1 = "I have $a apple"
    println(str)
    println(str1)
    println("${str1.replace("have","had")} lala")
}

注意上面的特点，使用字符串模板还可以在模板中使用方法。

kotlin也有条件表达式：

fun maxOf(a:Int,b:Int):Int{
    if (a>b){
        return a
    }else{
        return b
    }
}
//上面的方法可以简单化
fun maxOf1(a:Int,b:Int)=if (a>b) a else b

kotlin中 判断一个对象是不是某一类，直接用is

//返回类型加一个问号?表示返回值可以为null
fun getStringLength(obj:Any):Int?{
    if (obj is String){
        //条件语句里obj会自动转型为String类型
        return obj.length
    }//离开分支语句后obj仍然是Any类型
    return null
}

fun getStringLength1(obj:Any):Int?{
    if (obj !is String)return null
    //这种情况之下，obj会在分支另一端转换为String
    return obj.length
}

fun getStringLength2(obj:Any):Int?{
    //obj会在&&后自动转型为String
    if (obj is String&&obj.length>0){
        return obj.length
    }
    return null
}

上面的代码相比于java是不是简单多了，不用自己cast类型，使用is后自动转型。

下面我们就介绍循环：

//for循环
    var lists = listOf<String>("apple","banana","orange")
    for(item in lists){
        println(item)
    }

    //while循环
    var index=0
    while (index<lists.size){
        println(lists[index])
        index++
    }

接下来就来一个比java简介一百倍的when表达式，相当于java的swith的表达式：

fun decribe(obj:Any):String?=
        when(obj){
            1 -> "one"
            "banana"-> "fruit"
            "apple" ->"good fruit"
            !is String ->"nothing"
            else -> "no anything"
        }

是不是超级简洁，不要写break，也不要写分号

接下来我们介绍一下区间的特性

//区间
    val x=10
    val y=9
    if(x in 1..y+1){
        println("x is in range")
    }

 //检测数字是不是在区间外
    var lists = listOf<String>("apple","banana","orange")
    if (-1 !in 0..lists.lastIndex){
        println("-1 is not in range")
    }
    if (lists.size !in lists.indices){
        println("list size > list range")
    }

//区间迭代
    for (x in 1..5){
        println(x)
    }

    for (x in 1..10 step 2){
        println(x)
    }

下面我们就要展示kotlin对集合操作是多么的简便：

//遍历集合
    var lists = listOf<String>("apple","banana","orange","along")
    for(item in lists){
        println(item)
    }

    //下面的条件就算全部满足也只输出满足的第一个，后面的不输出
    when{
        "apple" in lists -> println("appple pie")
        "orange" in lists -> println("orange juice")
        "banana" in lists -> println("banan pizza")
    }
    //使用lambda表达式操作集合
    //下面的代码表示，只选取以a开头的元素，然后按照元素排序，然后
    //把每一个元素转换为大写
    //最后遍历操作后的新的lists元素
    lists.filter { it.startsWith("a") }.sortedBy { it }.map { it.toUpperCase() }
            .forEach{ println(it)}