Kotlin学习（一）基础语法

玩了一整天的kotlin，发现根本停不下来，语法写的好痛快。今天就来写写Kotlin那些基本语法，其实跟Java有些一样又有些不一样，我们来看看：

函数

首先看一个基本的函数：

基本函数
    fun add(a: Int, b: Int): Int {
        return a + b
    }
    简易写法
    fun add(a :Int,b :Int) = a+b;
    fun showString(strOne :String):String = strOne;

    没返回值函数
    fun showString(strOne: String, strTwo: String): Unit{
        println(strOne + "and" + strTwo);
    }
    没返回值的函数 Unit可以省略不写
    fun showString2(strOne: String, strTwo: String){
        println(strOne + "and" + strTwo);
    }

还有一种提供默认参数的写法：

//默认参数的函数，可以当java的重载使用，如果有默认参数，调用函数时不传参数也一样可以使用
    fun show(str : String = "hello",str2:String = "world"){
        println(str +"  "+str2);
    }

接下来是可变参数函数的写法：

可变参数，用 vararg 关键字
    fun test(vararg strArray: String?): String{
        for (str in strArray){
            if("hello".equals(str))
                return "has  hello"
        }
        return "not";
    }

常量变量

接下来我们看看Kotlin里面常量和变量的定义：

常量变量
    fun test(){
        val a : Int = 10;//val 表示的是常量，声明时必须初始化,加上 “:Int”是指定了常量的类型，没加的话则会自动推断类型
        val b = 10;//自动推断常量 b 为Int类型
        val c :Int;//如果不初始化常量，必须先指定常量类型

        a = 15;//常量初始化之后不能修改，这里会报错



        var A : Int = 11;//var 表示的是变量，加上 “:Int”是指定了常量的类型，没加的话则会自动推断类型
        var B = 11;//自动推断变量 B 为Int类型
        var C :Int;//如果不初始化变量，必须先显式指定变量类型
        C = 15;
        C = 20;//变量可以修改值
    }

常量和变量需要区分的是，常量是用val修饰，而变量是var修饰，常量赋值之后无法修改，这点跟java一样。

常见表达式：

条件表达式：

 fun max(a :Int,b :Int){
        if(a > b){
            println(a);
        }else{
            println(b);

        }
    }
    //简易写法
    fun max2(a :Int,b :Int) = if(a > b ) println(a) else println(b);

循环表达式：for

fun forTest(){
        var arr = arrayOf("A","B","C","D","E","F");
        for(i in arr.indices){//根据下标取值
            println(arr[i]);
        }
        for(value in arr){//根据值打印
            println(value);
        }
    }

while:

//while循环
    fun whileTest(){
        var i = 0;
        while(i < 10){
            println("i:"+i);
            i++;
        }
    }

while的话跟java的while循环基本一样。

接下来我们看看when表达式，其实就是java中的switch表达式，只不过功能上比switch强的太多太多：

fun whenTest(){
        var arr = arrayOf("A","B","C","D");
        for(value in arr){
            when(value){
                "A" -> println("是A");//直接根据值判断，没用到 is 、in 等字段
                "B" -> println("是B");
                "C" -> println("是C");
                "D" -> println("是D");
            }
        }

    }

这是一个最基本的when表达式。接下来我们看看无自变量的when,通过这种写法，我们可以通过when的检查然后在左边为我们的字段赋值：

fun whenTest2(){
        var x = 15;
        var s = "hello world";
        var a = when {
            x in 1..10 -> "在这范围内";//如果这句执行了，下面就不会执行了，相当后面隐藏了break;
            s.contains("hello") -> "welcome to china"
            else ->""
        }
        println(a);
    }

when表达式还可以根据任何类型进行判断：

fun whenTest3(obj :Any){
        when(obj){//比switch好处，switch 只能判断固定的类型
            "字符串" -> println("字符串");
            1 -> println("第一名");
            is String -> println("这个是字符串类型");
            is Long -> println("这个是Long类型");
            !is String -> println("这个不是String类型");
            else -> println("这个相当于java  switch 的default")
        }
    }

这个是判断View是属于那些布局

fun whenTest4(v :View){
        when(v){//
            is TextView -> println("这是TextView");
            is LinearLayout -> println("这是LinearLayout");
            is Button -> println("这是Button");
            is RelativeLayout -> println("这是RelativeLayout");
        }
    }

接下来我们看看in 字段的范围判断：

//in 范围判断
    fun inTest(){
        var y = 10;
        var x = 8;
        if(x in 1..y-2){//代表x 在 1 - 8 这个区间内
            println("在这范围内");
        }

        for (x in 1..10){//打印1到10
            println(x);
        }

    }

Kotlin相比java最明显的还是它致力于消除空指针，空引用带来的危害，所以它有了可空引用类型，非空引用类型，一般的写法是在变量类型后面加上问号则是可空类型：

var a :String     : 代表不可空       var  a :String?    :代表可空类型。我们看看代码：

//可空类型
    fun nullTest(){
        var num :Int? = 10; //在变量类型后面加上“?”表示类型为可空的
        num = null;//类型为可空，所以不会报错

        var name :String = "Jack";
        name = null;//类型不为可空，所以报错
    }


    //允许返回值为null
    fun getStr(str :String) :String?{
        return null;
    }

    //没有标注返回值可空，所以不能返回null
    fun getStr2(str :String) :String{
        return null;//这里会报错
    }

Kotlin还给我们提供空值检测：

//空值检测
    fun nullTest2(){
        var a :String? = "hello";
        println(a?.length);//a?.length 这句的 .length 在a不为null的时候才调用,为null的时候只打印 null

        var b :String? = "hello kotlin";
        b?.let {
            println("我是b不为空时才调用");
        }
        b = null;
        b?:let{
            println("我是b为空时才调用,跟 .let 相反");
        }
    }

这些函数相比java在应用开发中对我们的效率提升了很多，也便利了许多，不愧是亲儿子。