1、空类型、空安全
2、函数的基本使用

空类型、空安全

1、定义可为空的变量
修饰符 变量名 ： 类型? = 值

    var a: String? = "abcde"
    println("$a")
    a = null
    println("$a")

2、判断空的方式
　　1 if...else...
　　2 ?. 当a为空时,则不执行?后面的代码,否则执行

　　//1)if..else..
    if (a == null) {
        println("a为空")
    } else {
        println("a不为空")
    }
    //2) ?.   当a为空时,则不执行?后面的代码,否则执行
    println(a?.length)

3、函数中使用空的情况

fun sumNum(): Int? {
    var b: String? = "123465"
    return b?.length
}

4、let操作符
　　1. let操作符的作用：当时用符号?.验证的时候,为null是不执行let里面的内容
　　2. let的用法：变量?.let{ ... }

  val arrTest: Array<Int?> = arrayOf(1, 2, null, 3, null)
    // 一般写法
    for (index in arrTest) {
        if (index == null) {
            continue
        }
        println("index = $index")
    }
    // let写法
    for (index in arrTest) {
        index?.let { println("index = $it") }
    }

5、Evils操作符（安全操作符）
　　1. ?: 这个操作符表示在判断一个可空类型时，会返回一个我们自己设定好的默认值.
　　2. !! 这个操作符表示在判断一个可空类型时，会显示的抛出空引用异常（NullPointException）.尽量不要使用,除非保证一定不为空
　　 3. as? 这个操作符表示为安全的类型转换.
　　4. as操作符，表示类型转换，如果不能正常转换的情况下使用as?操作符。当使用as操作符的使用不能正常的转换的情况下会抛出类型转换（ClassCastException）异常，而使用as?操作符则会返回null,但是不会抛出异常

  //   ?:
    var testStr: String? = null
    var length = 0
    // 一般写法
    length = if (testStr != null) testStr.length else -1

    // ?: 写法
    length = testStr?.length ?: -1
    println(length)

    //  !!
    testStr = null
  //   println(testStr!!.length)//如果为空,会报空指针异常.只有在保证一定不为空的时候可以使用

    //  as?
  // 会抛出ClassCastException异常
//   val num1 : Int? = "Koltin" as Int
//    println("nun1 = $num1")

    val num2 : Int? = "Koltin" as? Int
    println("nun2 = $num2")

函数的基本使用

1 、函数的声明
　　1. 关键字：fun
　　2. 格式：可见性修饰符 fun 函数名(参数名 ：类型,...) : 返回值{}
　　3. Kotlin中默认为public可见性修饰符
　　4. () 　{} 必须存在

fun test(){ 
}
//相当于java中
public void test(){
}

2、成员函数
成员函数是指在类或对象中的内部函数。

class Demo {
    fun test(){
    }
}

3、函数的使用
普通的使用
成员函数的使用

// 普通的使用
test()
// 如果函数有返回值
val x = basis()
// 成员函数的使用：先初始化对象，在根据对象使用`中缀符号(.)`调用其成员函数
Demo().test()
// 如果函数有返回值
val x = Demo().test()

4、函数的返回值
　　1. Unit类型(函数无返回值,默认,可以忽略不写)
　　2. 其他显示返回类型的返回值

fun unitFun() : Unit{
    println("我是返回值为Unit的函数，Unit可省略")
    return
    // return Unit 可省略
    // 或者 return  可省略
}
等价于
 fun unitFun(){
    println("我是返回值为Unit的函数，Unit可省略")
}

fun num() : Int{
    return 2
}

5、函数的参数
　　1. 具有参数的基本函数声明
　　　　格式:name : type

fun funArgs(numA: Int, numB: Float) {
    println("numA = $numA \t numB = $numB")
}

2. 默认参数，即参数具有默认值
　　　　当具有默认参数时，可以对是参数有默认值的参数不传递参数值。

fun defArgs(numA: Int = 1, numB: Float = 2f) {
    println("numA  =  $numA \t numB = $numB ")
}

3. 命名参数，当传递参数的时候显示使用 参数名 = 参数值
　　　　即在使用函数时显示使用参数名 = 参数值这种方式传递参数

//命名参数
fun callFun(str: String, isTrue: Boolean = false, numA: Int = 2) {
    println("$str \t $isTrue \t $numA")
}

4. 可变数量的参数：即参数的个数不定。
　　　　1. 当一个函数中的参数是不定数量的个数并且是同一个类型，则可是使用vararg修饰符去修饰这个变量，则被vararg修饰的参数相当于一个固定类型的数组。
　　　　2.声明格式：fun 函数名(vararg 参数名 ： 类型，...) ：返回值{}

//可变数量的参数
fun varargFun(a:Int,vararg str:String){
    str.forEach {
        print("$it \t")
    }

fun main(args: Array<String>) {
    //无参
    test()
    //有参
    funArgs(100, 1f)
    // 默认参数的函数使用
    defArgs()
    defArgs(1, 10f)
    //命名参数
    //str不具备有默认值,所以必须传值,其他可以不用传
    callFun("aaaaa")
    callFun("str",true,2)//----和java一样了-----
    callFun("str",isTrue = true,numA = 3)//使代码更具有可读性
    callFun("cccc",numA = 10000)//不需要所有的参数时
    //可变参数
    varargFun(100,"aa","bb","cc")
 }
}

6、单表达式函数
　　即函数具备返回值的时候，可以省略花括号并且在=赋值符号之后指定代码体，而函数的返回值是有编辑器自动推断的。注意:只有一行代码体的时候,可以使用该函数.

fun main(args: Array<String>) {
    println(test1())
    println(test2(2))
    println(test3(2f))

}

// 无参数的情况
fun test1() = 2                     // 自动推断为：返回类型为Int

// 有参数的情况
fun test2(num: Int) = num * 2      // 自动推断为：返回类型为Int

// 或者
fun test3(x: Float, y: Int = 2) = x * y  // 和默认参数一起使用，返回值为Float型

----------------------------THE END-------------------------