变量与常量
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