Kotlin基础语法

1. 变量

• val : 常量

声明初始化后不能再改变的量，类似java中的final

val a: Int = 1  // 指定类型申明，不过这是多余的操作
val age = 5   // 自动确定为int
val name: String  // 指定来类型，但是先不初始化
name = "小明"       // 可以延迟初始化

• var ：变量

声明初始化后还能继续修改

fun logString() {
        //自动确定为int
        var ageVar = 5
        //可以指定类型，当然这是多余的操作
        var money: Double = 11.11
    }

2. 函数

格式：函数fun关键字定义 方法名(参数):返回值

如：

fun sum(a: Int, b: Int): Int {
    return a + b
}

3. Null检测

想必大家在最初了解的时候，最看中的则是kotlin自带null类型检测了

3.1 声明检查

默认声明后是不允许置为null的，就下这样

var a: String = "hello"
a = null//编译器会直接提示错误

如果需要允许可以为null，那么就在类型后加一个?

var a: String? = "hello"
a = null

3.2 在调用方法变量的时候检查

在调用方法时，也有会提示错误

var a: String? = "hello"
var length = a?.length//编译器会直接提示错误

4. 条件表达式

4.1 for循环

4.1.1 日常写法

• 增强for循环写法 ，采用 in 关键字(后面会讲到)，就像java里采用:方式

var itemF = listOf("1", "2", '3', "4")
# java方式就像 for (String any : itemF) 
for (any in itemF) {
    //输出遍历内容
    Log.i(TAG, "any ：" + any)
}

• 获取index方式遍历

java里，我们如果需要index，很多时候会直接采用最普通的for(int i=0;i

//需要获取index方式遍历
for (index in itemF.indices) {
    Log.i(TAG, "item at" + index + ", " + itemF[index])
}

4.1.2 配合方法做简写

比起java还有更多的一些用法，比如在方法里可以配合简写方式出现

fun maxCompare(a: Int, b: Int): Int {
    if (a > b) {
        return a
    } else {
        return b
    }
}

可以改写为

fun maxOf(a: Int, b: Int) = if (a > b) a else b

4.2 while

while常用方法与java基本类似

val items = listOf("1", "2", "3")
var index = 0
while (index < items.size) {
    Log.i(TAG, "while test . item at" + index + ", " + items[index])
            index++
}

4.3 when

采用when关键字。与java中的switch很像，替代里switch，写起来更简洁,省去了case和break，还支持lambda，就像下面这样

val i = 1
when (i) {
    //匹配2
    2 -> {
        Log.i(TAG, "when test . is 2 ")
        }
    //匹配1，lambda方式
    1 -> Log.i(TAG, "when test . is 1 ")
    //都不匹配
    else -> Log.i(TAG, " no match")
}

4.4 Ranges

• in关键字，用在条件判断中。

判断一个数是否在一个范围里(左右均包含)

val x = 5
val y = 4
//判断x即5，是否在y+1即5到10这个区间里
if (x in (y + 1)..10) {
    Log.i(TAG, "x in range")
}

非判断就在in前加一个感叹号，比如

val x = 5
val y = 4
//即判断4 不在 3到1的中(3,2,1)
if (x !in (y - 1) downTo 1) {
    Log.i(TAG, "x in range")
}

这里可以注意到，前面升序的时候我们采用的两个点，比如从1到10，则为1…10，但是降序的时候，我们需要用关键字 downTo

• step关键字

step可在for循环的时候，如果不想挨个遍历，可以采用跳跃的方式

//从1遍历到10，每次间隔2
for (x in 1..10 step 2) {
    Log.i(TAG, "setp2 " + x)
}

//从9遍历降到0，每次间隔3
for (x in 9 downTo 0 step 3) {
    Log.i(TAG, "setp3 " + x)
}

输出：

#升序增加2方式
setp2 1
setp2 3
setp2 5
setp2 7
#降序跳跃3方式
setp2 9
setp3 9
setp3 6
setp3 3
setp3 0

5. 集合

kotlin集合没有java那么

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-LzGuqxjV-1575041818924)(https://github.com/nxSin/BlogPic/blob/eaa4b04c4d12bfe7377941928e0e7d07642d104a/kotlin/collection.png?raw=true)]

前面有看到采用了listOf来初始化一个列表，这样初始化出来的列表是不可变的，可以遍历操作

//不可变列表
        val nonMutlist = listOf("1", "2", "3", "4")
        nonMutlist.forEach { str -> Log.d(TAG, "遍历不可变列表：str " + str) }

另外还有一个可变的列表MutableList，其长度内容是

//可变列表
        val mutableList: MutableList = mutableListOf()
        mutableList.add("1")
        mutableList.add("2")
        mutableList.forEach { str -> Log.d(TAG, "遍历可变列表：str " + str) }

集合类比较常用，这里先简单提一下