Kotlin---基础数据类型与函数

变量与常量

Kotlin和一些脚本语言一样，在定义变量的时候不需要指定变量类型，Kotlin会根据默认值来确定变量类型。

在定义类属性时，定义的变量必须有默认值，而在定义函数中的局部变量时，可以不指定默认值，但是必须指定变量类型。

Kotlin使用var来定义变量，使用val来定义不可变值，而使用const来定义常量

变量定义

• 有默认值的变量定义方式：
  在类属性以及函数中都可以使用var来定义变量，如果没有指定类型的话，Kotlin会根据默认值推导变量类型

class TestKotlin {
    var stringVar = "test"  // 定义字符串
    var intVar = 10 // 定义int类型的值
    var booleanVar = false // 定义boolean
    var floatVar = 1.0f // 定义float
    var longVar = 10L // 定义long
    var doubleVar = 10.0 // 定义dobule
    // 指定变量类型
    var stringTypeVar : String = "test" // 明确指定变量为string类型
    var intTypeVar : Int = 10 // 明确指定变量为int类型的值
}

• 无默认值的变量定义方式
  这种方式只能在函数中定义，如果在类属性中定义的话会报错：Property must be initialize or be abstract

class TestKotlin {
    var intVar:Int =10
    var intTypeVar:Int  // Error：Property must be initialize or be abstract

    fun print(){
        var intVar:Int
    }
}

• 静态变量的定义方式
  可以在类的Top-Level定义变量，而在这个Level所声明的变量就可以相当于Java中的Static静态变量。在使用时，根据import的包名+类名来确定静态变量。Kotlin中没有static关键字。

// TestKotlin.kt
var staticInt:Int =10
class TestKotlin {

}
// 不同包下使用静态变量
import com.example.myapplication.staticInt

class ApplicationKotlin {

    fun print(){
        staticInt
    }
}

不可变值的定义

不可变值的作用类似于Java中的final。但是与final有所不同，这部分后续再分析。官方文档中说：对于类的属性而言，var代表可变(Mutable)，而val代表不可变(Read-Only)

我们可以在类成员定义时，为val定义的常量赋予初始值，如果不赋值的话，就会报错。
而在函数的局部变量中定义val常量时候，可以后面再赋值，但是不可多次赋值，否则会报错

class TestKotlin {
    val intVal : Int = 10

    fun print(){
        val intInsideVal:Int
        intInsideVal= 10
        val intInsideValInit=10
    }
}

类成员属性中，使用val定义的值可以在构造函数内初始化，不过还是建议在定义时进行初始化

class TestKotlin {
    val intVal : Int
    
    constructor(){
        intVal=10
    }
    fun print(){
        val intInsideVal:Int
        intInsideVal= 10
        val intInsideValInit=10
    }
}

常量

Kotlin可以在类的Top-Level定义常量以及变量。而const则只能用于类Top-Level的常量声明中。通过const val的声明一个常量，const只能与val配对，不能使用var来配对

const val constString = "This is final String"

class TestKotlin {
       
}

基础数据类型的转换

在项目中通常会遇到基础数据类型的转换，如int类型的值+float类型的值。在Java中可以强转，或者隐式转换，如int+float=>int，而Kotlin中则不能直接强转。

int值与long值是可以直接相加返回long值

class TestKotlin {

    fun test():Long{
        val intV:Int =10
        val longV :Long =10L
        val sumV=intV+longV
        return sumV
    }
}

int值与float值也可以直接相加返回float值

class TestKotlin {

    fun test():Float{
        val intV:Int =10
        val longV :Float =10.0F
        val sumV=intV+longV
        return sumV
    }
}

但如果我们希望int+float=>int的话，需要这么做，使用toInt函数来返回int类型的值：

class TestKotlin {

    fun test():Int{
        val intV:Int =10
        val longV :Float =10.0F
        val sumV=intV+longV.toInt()
        return sumV
    }
}

同样，还有toLong,toDouble等等用于数值转换

函数

一个简单函数会通过fun关键字来定义函数。

• 定义无返回值的函数

class TestKotlin {

    fun test(){
        println("this is a function")
    }
}

• 定义int返回值的函数

class TestKotlin {

    fun test():Int{
        println("this is a function and return int")
        return 0
    }
}

• 定义带参数返回的函数

class TestKotlin {

    fun test() {
        var result = add(10, 20)
    }

    fun add(x: Int, y: Int): Int {
        return x + y
    }
}

• 使用表达式作为函数体，而返回值Kotlin会自动推断

class TestKotlin {

    fun test() {
        var result = add(10, 20)
    }

    fun add(x: Int, y: Int) = x + y
    fun add2(x: Int, y: Int):Int = x + y
}

• 定义类方法

import com.example.myapplication.add

class TestKotlin {

    fun test() {
        var result = add(10, 20)
    }

}
// com.example.application下的类
fun add(x: Int, y: Int): Int = x + y
class ApplicationKotlin {


}

• 通过Lambda定义函数
  如果需要返回值，则定义具体的返回值

class TestKotlin {

    fun test() {
        val add: (Int, Int) -> Int = { x, y -> x + y }
        add(10, 20)
    }
}

如果不需要返回值，则将返回值定义Unit即可

class TestKotlin {

    fun test() {
        val add: (Int, Int) -> Unit = { x, y -> print("") }
        add(10, 20)
    }

}

The type with only one value: the Unit object. This type corresponds to the `void` type in Java.
Kotlin的文档中也说明了，Unit是一个对象，而它也对应着Java中的void类型

• 在函数中也可以定义参数的默认值，并且在调用时，可以通过具体的参数名来指定参数

  
  Default Params