Android kotlin 使用技巧

Me

Kotlin var，val

var(variable)用来声明一个可变变量，这是一个可以通过重新分配来更改为另一个值的变量。
val(value)用来声明一个只读变量，这种声明变量的方式相当于java中的final变量。

Kotlin 函数

fun 函数名(参数名:类型,参数名:类型...) :返回类型{
	return 返回值
}
fun methodName(param1:Int,param2:Int):Int{
	return 0
}
//当一个函数中只有一行代码时，可以不必写函数体，直接用等号连接即可。
fun methodName(param1:Int,param2:Int):Int = 0

//扩展：无限参数传递
/*** kotlin版代码 ***/
fun displayActors(vararg name: String) {
    println("actors: " + name);
}
/*** Java版代码 ***/
public void displayActors(String... name) {
    System.out.println("actors :" + name);
}

Kotlin 扩展函数

//1.首先创建String.kt，也可以在现有类添加
//2.最好将它定义成顶层方法，可以让它拥有全局的访问域
fun String.letterCount():Int{
	var count = 0
	for (char in this){
		if(char.isLetter()){
			count++
		}
	}
}

Kotlin 逻辑控制

if

//if语句使用每个条件的最后一行代码作为返回值
fun largerNumber(num1: Int, num2: Int): Int {
    val value = if (num1 > num2) {
        num1
    } else {
        num2
    }
    return value
}

when

when(参数){
	匹配值 -> {执行逻辑}(执行逻辑只有一行代码时，{}可以省略)
	else -> {默认逻辑}
}
//case1
fun getScore(name: String) = when (name) {
    "Tom" -> 80
    "jim", "jack" -> 90
    else -> 100
}
//case2
//when允许进行类型匹配
fun checkNumber(num: Number) {
    when (num) {
        is Int -> {println("number is Int")}
        is Double ->{println("number is Double")}
        else -> {println("number not Number")}
    }
}
//case3
//when语句不带参数的用法,可以已条件的格式去判断
fun getScore(name: String) = when {
    name.startsWith("Tom") -> 80
    name == "Jim" -> 90
    name == "Jack" -> 90
    else -> 100
}

Kotlin 继承与构造函数

继承

//加上open关键字，就允许被继承了。
open class Person{}
//java中用extends继承；kotlin中用：冒号继承
class Student : Person(){}

构造函数

//主构造函数
class Student(val son: String, val grade: Int) : Person() {
	//init主构造函数体
    init {
        println("son is $son")
        println("grade is $grade")
    }
}
//次构造函数"constructor"关键字定义
//注意：所有次构造函数必须调用主构造函数
open class Person(name: String, age: Int) {}
class Student(val son: String, val grade: Int, name: String, age: Int) : Person(name, age) {
    constructor(name: String, age: Int) : this("", 0, name, age) {}
    constructor() : this("", 0) {}
}

Kotlin 数据类与单例

数据类

// data关键字，可以帮你将equals(),hashCode(),toString()等固定且无实际逻辑意义的方法自动生成
data class StudentBean(
    var orders: List<OrderItemBean>,
    var name: String,
    var age: Int
)

单例

// object 关键字,一个单例就创建了
object Singleton{}

Kotlin ?和!!

"?"当前对象可以为空，系统在任何情况不会报它的空指针异常。
"!!"当前对象不能为空，如果对象为null，那么系统一定会报异常！

Kotlin lateinit var 和 by lazy (延迟初始化)

/** lateinit var **/
private lateinit var name: String
 
/** by lazy **/
//用于属性延迟初始化
val name: Int by lazy { 1 }
 
//用于局部变量延迟初始化
public fun foo() {
    val bar by lazy { "hello" }
    println(bar)
    //::object.isInitialized可用于判断object变量是否已经初始化
    if(::name.isInitialized){}
}

Kotlin 集合

List接口的方法支持读功能
MutableList接口的方法支持读写功能

//List集合
//创建不可变集合，无法对该集合进行添加，修改，删除操作。
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
//创建可变集合
val list = mutableListOf("Apple", "Banana", "Orange", "Pear", "Grape")
list.add("Watermelon")
for (fruit in list) {
    println(fruit)
}
//Map集合
val map = mapOf<String, Int>("Apple" to 1, "Banana" to 2, "Orange" to 3)
for ((fruit, number) in map) {
    println("fruit is " + fruit + ", number is " + number)
}
//OR
val map = HashMap<String, String>()
	map["Apple"] = "Apple"
	map["Banana"] = "Banana"
	map["Orange"] = "Orange"
//ArrayList集合
var list = ArrayList<String>()
    list.add("Apple")
    list.add("Banana")
    list.add("Orange")
    list.add("Pear")
    list.add("Grape")
    list.add("Watermelon")

Kotlin 集合函数式Api

Lambda语法结构
{参数名1:参数类型,参数名2:参数类型->函数体}

maxBy

//maxBy 获取集合中某个元素的某个字段最大值的元素，如果有多个最大值元素，那么返回第一个。 
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val maxLengFruit = list.maxBy(it.leng)

map

//map 用于将集合中的每一个元素都映射成一个另外的值，最终生成一个新的集合。
val list = listOf("App le", "Bana na", "Oran ge", "Pe ar", "Gra pe", "Water melon")
val newList = list.map{it.split(" ")}
//打印"Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon"

flatMap

//flatMap 
val list = listOf("App le", "Bana na", "Oran ge")
val newList = list.flatMap{it.split(" ")}
//打印"App", "le", "Bana", "na", "Oran", "ge"

filter

//filter 用与过滤集合中的数据
val list = listOf("App le", "Bana na", "Oran ge", "Pe ar", "Gra pe", "Water melon")
val newList = list.filter{it.length <=5}
//打印"Apple", "Pear", "Grape"

any

//any 用于判断集合中是否至少存在一个元素满足指定条件
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val anyResult = list.any { it.length <= 5 }

all

//all 用于判断集合中是否所有元素都满足指定条件
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val allResult = list.all { it.length <= 5 }

Kotlin 内联函数

let

//let 表示object不为null的条件下，才会去执行let函数体
object?.let{
   it.todo()
}

with

//with 适用于调用同一个类的多个方法时，可以省去类名重复，直接调用类的方法即可
with(object){
	//todo
}

run

//run 实际上可以说是let和with两个函数的结合体
run(object){
	//todo
}

apply

//apply 从结构上来看apply函数和run函数很像，唯一不同点就是它们各自返回的值不一样，run函数是以闭包形式返回最后一行代码的值，而apply函数的返回的是传入对象的本身
apply(object){
	//todo
}

also

//also also函数的结构实际上和let很像唯一的区别就是返回值的不一样，let是以闭包的形式返回，返回函数体内最后一行的值，如果最后一行为空就返回一个Unit类型的默认值。而also函数返回的则是传入对象的本身
object.also{
	//todo
}

函数名	函数体内使用的对象	返回值	是否是扩展函数	适用的场景
let	it	闭包形式返回	是	适用于处理不为null的操作场景
with	this	闭包形式返回	否	适用于调用同一个类的多个方法时，可以省去类名重复，直接调用类的方法即可，经常用于Android中RecyclerView中onBinderViewHolder中，数据model的属性映射到UI上
run	this	闭包形式返回	是	适用于let,with函数任何场景。
apply	this	返回this	是	1、适用于run函数的任何场景，一般用于初始化一个对象实例的时候，操作对象属性，并最终返回这个对象。 2、动态inflate出一个XML的View的时候需要给View绑定数据也会用到. 3、一般可用于多个扩展函数链式调用 4、数据model多层级包裹判空处理的问题
also	it	返回this	是	适用于let函数的任何场景，一般可用于多个扩展函数链式调用

Kotlin 函数的参数默认值

//给参数默认值
fun printParams(num: Int = 100, str: String = "hello") {
    println("num is $num , str is $str")
}
//调用
fun main(){
	printParams(123)
}
//或者
fun main(){
	printParams(num = 123)
}

Kotlin private,protected,internal,public

private var v1 = “本类可见”
public var v2=“任何地方都可以见”
protected var v3=“只有在本源文件中可见”
internal val v4=“同一模块下可见”

Kotlin 循环语句： for，in

/**可以用in判断数字是否在某个区间**/
if(x in 1..5){ ...}		//检查x数值是否在1到5区间
if(name in list){...}	//检查list中是否有某个元素
/**可以用in遍历整个集合**/
for(i in 1..5){ ...		//遍历1到5
for(item in list){...	//遍历list中的每个元素(相当于Java的for(String item : list))
/**在遍历集合时，可以从第N项开始遍历**/
for(i in 3..list.size-2){...相当于for (int i = 3; i <= list.size()-2; i++)
/**可以倒序遍历**/
for(i in list.size downTo 0) {...相当于for (int i = list.size(); i >= 0; i--)
/**可以反转列表**/
for(i in (1..5).reversed())
/**可以指定步长**/
for(i in 1.0..2.0 step 0.3) //步长0.3

Kotlin Gson解析

// 对象
Gson().fromJson(data, ResultBean::class.javaObjectType)
// 集合
val fromJson: MutableList<String> = Gson().fromJson<MutableList<String>>(recent_search, MutableList::class.javaObjectType)

Kotlin companion object

/*companion object 修饰为伴生对象,伴生对象在类中只能存在一个，
类似于java中的静态方法 Java中使用类访问静态成员，静态方法*/
companion object {
        const val LOAN_TYPE = "loanType"
        const val LOAN_TITLE = "loanTitle"
        
        @JvmStatic//静态注解
        fun startIntent(context: Context, orderNo: String) {
    		val intent = Intent()
   			intent.setClass(context, OrderDetailActivity::class.java)
    		intent.putExtra(LOAN_TYPE , orderNo)
    		context.startActivity(intent)
		}
}

Kotlin Java中调用Kotlin时，如何使用默认值省略函数参数？

常规操作

//kotlin
class OrderActivity : BaseKtActivity() {
	companion object {
	    fun startIntent(orderId: String, orderType: Int = 0) {
			//TODO 逻辑处理
	    }
    }
}
//java调用
Orderctivity.Companion.startIntent("orderId",0);

添加@JvmOverloads后

class OrderActivity : BaseKtActivity() {
	companion object {
		@JvmOverloads
	    fun startIntent(orderId: String, orderType: Int = 0) {
			//TODO 逻辑处理
	    }
    }
}
//java调用
Orderctivity.Companion.startIntent("orderId");
//OR
Orderctivity.Companion.startIntent("orderId",0);

Kotlin 可空类型

• 安全调用运算符 "?."

?.相当于判空处理，如果不为null就执行?.后面的表达式，否则就返回null

data class User(
	var name: String?,
	var age: Int
)
val user = User("张三",18)
val name = user?.name ?: "李四"

• Elvis运算符 "?:"

如果?:前面表达式为null, 就执行?:后面的表达式，它一般会和?.一起使用。

val age = user.age ?:"18"

• 安全类型转化运算符 as?

//相当于 if(userBean is User) userBean as Userelse null
val user = userBean as? User

• 非空断言运算符 !! 与 契约(contract) 简化非空表达式

val name1 = user!!.name
val name2 = requireNotNull(user).name