记录Kotlin常见问题和代码。
6. when代替OR智能转换（20171122）
在网上看到一个问题是说有两个方法，同名不同参数
fun foo(long: Long) {...}
fun foo(int: Int) {...}
然后现在有个变量是未定类型val someValue: Any = "0" // 0 or 0L，在使用foo方法的时候，然后他是这样写的，问说如何智能转换，不要使用||。
if (someValue is Int || someValue is Long) {
foo(someValue)
}
// 或者这样
if (someValue is Int)
foo(someValue)
else if (someValue is Long)
foo(someValue)
使用when来替代它
when (someValue) {
is Long -> foo(someValue)
is Int -> foo(someValue)
}
这样就体现了Kotlin的智能转换功能了
5. 同时符合until和downTo要求（20171025）
之前看到别人问了一个说想递减同时又不包含结束值怎么写？ downTo 和 until 不能并存，截图如下
满足他
for (i in (0 until 10).reversed()) {
println(i)
}
但是我不是很明白他这样的需求，until又不能减掉中间的数，只能是区间的头和尾，上面的需求摆明可以这样写，
for (i in (0 until 10).reversed()) {
println(i)
}
为什么一定要用until和downTo结合呢？？？
4. 使用when表达式多个case符合条件，判断要写全
使用Kotlin的when表达式来判断多个case符合条件，换成Java就是
switch(x) {
case 1:
case 2:
break;
}
这里遇到一个坑，有一个方法：
fun check(value: Any?): String = when (value) {
is Int, Float, Double -> {
if (value == 0) "value为0"
else "value = $value"
}
else -> {
"value为空"
}
}
这个方法是用来判断输入的值，如果是Int、Float、Double类型的话就判断是否为0，如果不是的就返回字符串value为空。
fun main(args: Array<String>) {
println(check(1))
println(check(11f))
println(check(8.01))
println(check(0))
}
打印结果为
....居然是这样，跟我想的完全不一样，为什么会这样呢，看一下编译后的代码：
发现原因没有，只有Int类型的才有加instanceof判断，而另外两个却没有，那么得为Float和Double也加上is判断才行。
fun check(value: Any?): String = when (value) {
is Int, is Float, is Double -> {
if (value == 0) "value为0"
else "value = $value"
}
else -> {
"value为空"
}
}
再来看看编译后的代码：
还有打印的结果：
3. run、let、apply和with的区别
run函数
可以看出run是一个扩展函数，并且有返回值的，将最后一行做为返回，默认返回Unit，那么我们来写个例子：
data class User(val name: String = "jowan", val age: Int = 24)
fun main(args: Array<String>) {
val user = User()
// runUnit类型为Unit
val runUnit = user.run {
println("runUnit:$this") // 打印runUnit:User(name=jowan, age=24)
}
println("runUnit type:$runUnit") // 打印runUnit type:kotlin.Unit
// run类型为User
val run = user.run {
println("run:$this") // 打印run:User(name=jowan, age=24)
User(age = 1)
}
}
let函数
可以看出let也是一个扩展函数，与run函数一样，同样是有返回值，将最后一行做为返回，默认返回Unit，但是与run不同的时候，let有参数而run没有：
data class User(val name: String = "jowan", val age: Int = 24)
fun main(args: Array<String>) {
val user = User()
// letUnit类型为Unit
val letUnit = user.let {
println("letUnit:$it")
}
println("letUnit type:$letUnit")
// let类型为User
val let = user.let {
it ->
println("let:$it")
User(age = 2)
}
}
apply函数
可以看出apply函数也是一个扩展函数，也有返回值，默认返回该对象，与run的区别是run返回最后一行，apply返回该对象：
data class User(val name: String = "jowan", val age: Int = 24)
fun main(args: Array<String>) {
val user = User()
// apply类型为User
val apply = user.apply {
println("apply:$this") // 打印apply:User(name=jowan, age=24)
}
apply.let {
println("apply let:$it") // 打印apply let:User(name=jowan, age=24)
}
}
with函数
可以看出with函数不是扩展函数，与let和apply有点像，同样是有返回值，将最后一行做为返回，默认返回Unit，并且可以直接调用对象的方法和变量：
data class User(val name: String = "jowan", val age: Int = 24)
fun main(args: Array<String>) {
val user = User()
// withUnit类型为Unit
val withUnit = with(user) {
println("withUnit:$this") // 打印withUnit:User(name=jowan, age=24)
}
// with类型为User
val with = with(user) {
println("with:$this, name:$name, age:$age") // 打印with:User(name=jowan, age=24), name:jowan, age:24
User(age = 111)
}
with.let {
println("with let:$it") // 打印with let:User(name=jowan, age=111)
}
}
小结
| 函数名 | 返回值 | 参数 | 函数类型 |
|---|---|---|---|
| run | 闭包返回 | 无 | 扩展函数 |
| let | 闭包返回 | it | 扩展函数 |
| apply | this | 无 | 扩展函数 |
| with | 闭包返回 | 无 | 非扩展函数 |
2. 设置默认值
有这样一个问题，通过Json获取到的数据，如果获取有空的值，那么就要将其改为默认值：
data class User(val name: String?, val age: Int?)
fun main(args: Array<String>) {
var user = User(null, 23)
println(user.name?.let { user.name } ?: "jowan")
}
这样子写是不是很麻烦，那么这里我们可以将其写成一个方法，这样子调用的话就很方便了：
data class User(val name: String?, val age: Int?)
fun <T> T?.getDefault(default: T): T = this?.let { this } ?: default
fun main(args: Array<String>) {
val (name, _) = User(null, 23)
println(name.getDefault("jowan"))
val (_, age2) = User("jowan", null)
println(age2.getDefault(23))
}
1. 获取变量类型(getJavaClass)
使用::class.java来获取变量类型，也可以用.javaClass来获取类型。
fun main(args: Array<String>) {
val i = "str"
val classJava = i::class.java
println(classJava) // 打印class java.lang.String
val javaClass = i.javaClass
println(javaClass) // 打印class java.lang.String
}
