android 变量记录方法是,Android kotlin 记录-优快云博客

Kotlin 变量：var，val

Kotlin 函数

Kotlin 扩展函数

Kotlin 逻辑控制

when

Kotlin 继承与构造函数

继承

构造函数

Kotlin 数据类与单例

数据类

单例

Kotlin ?和!!

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

Kotlin 集合

Kotlin 集合函数式Api

maxBy

map

flatMap

filter

any

all

Kotlin 内联函数

let

with

run

apply

also

Kotlin 函数的参数默认值

Kotlin private,protected,internal,public

Kotlin 循环语句： for，in

Kotlin Gson解析

Kotlin companion object

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语句使用每个条件的最后一行代码作为返回值

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,

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("Apple" to 1, "Banana" to 2, "Orange" to 3)

for ((fruit, number) in map) {

println("fruit is " + fruit + ", number is " + number)

}

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

闭包形式返回

是

适用于处理不为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

返回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 = Gson().fromJson>(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)

}