Android开发之Kitlin语言【知识点集合】

kitlin作为android开发的一种google推荐的语言。我们有必要来对它进行对应的学习。如果你之前有java的开发经验，那么对于kitlin的学习应该是很快融会贯通的。

kitlin这种语言是根据JVM的规则来做的，因此使用kitlin开发的语言在java项目中是可以运行的。所以他们是很相似的一个东西，但是kitlin结合了一些现在语言的特性，因此比java更加的简洁和方便。

kitlin基础

变量

val a = 10
val a:Int = 10
var a = 10

kitlin是可以做类型推导的，因此这里的a可以直接赋值，其中:Int的方式是显式变量声明方式

其中val和var的区别是：val是定义后不在改变相当于java中的final，而var这是可以变

函数

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

当一个函数中只有一行代码时，Kotlin允许我们不必编写函数体，可以直接将唯一的一行代码写
在函数定义的尾部，中间用等号连接即可

如下：
fun add(a:Int,b:Int) = a+b

if条件语句

//Kotlin中的if语句相比于Java有一个额外的功能，它是可以有返回值的，返回值就是if语句每一个条件中最后一行代码的返回值
fun largerNumber(num1: Int, num2: Int): Int {
 val value = if (num1 > num2) {
 num1
 } else {
 num2
 }
 return value
}

根据kitlin的特性可将上面的代码简化成如下

fun largerNumber(num1: Int, num2: Int) = if (num1 > num2) num1 else num2

when条件语句

fun getScore(name: String) = when (name) {
 "Tom" -> 86
 "Jim" -> 77
 "Jack" -> 95
 "Lily" -> 100
 else -> 0
}

如果when不加参数则表现如下

fun getScore(name: String) = when {
 name.startsWith("Tom") -> 86
 name == "Jim" -> 77
 name == "Jack" -> 95
 name == "Lily" -> 100
 else -> 0
}

这种方式的优点就是可以在条件参数上进行一些其他的处理、锐减使用这种方式。

循环

val range = 0..10  //得到的是[0,10]的数据

Kotlin中可以使用until关键字来创建一个左闭右开的区间
val range = 0 until 10 //[0.10)的数据

循环如下
for ( i in range step 2){
	println(i)
}

对象

class Student(name: String,age: Int) :Person(name,age){

    //Kotlin规定，当一个类既有主构造函数又有次构造函数时，所有的次构造函数都必须调用主构造 函数（包括间接调用）。
    constructor() :this("name",0){}
}

//一个类要被是能被继承则需要加上open关键字才行，否则kitlin中所有的类都是不可继承的
open class Person {
    var name = ""
    var age =0

    constructor(name: String, age: Int) {
        this.name = name
        this.age = age
    }


    fun eat(){
        println("person eat")
    }
}

最终调用如下即可【不需要使用new来声明要创建一个对象，因为无需new，也知道下面的这种范式是创建一个对象，因此比较简洁】
var person = Person("1",3)

接口

interface Study {
    fun readBooks()
    fun doHomework(){
        print("默认实现")
    }
}

kitlin中是没有抽象类一说，直接使用接口即可

其他的一些面向对象特性

数据对象，直接将class前面加上data即可免去编写hashCode、equils、toString等方法
data class DataClass(val brand:String,var price:Int)

单例对象直接在将class改成object则这个类就是单例的了。

//单例类
object Singleton {

    fun singletonTest(){
        println("单例就是这么简单")
    }
}

kitlin中的lambda表达式如下

   //创建集合
    val list = listOf("a","bb","c") //listOf()函数创建的是一个不可变的集合
    for (i in list){
        println(i)
    }

    val value1 = mutableListOf<Int>(1,2,5,4,3) //mutableListOf()函数创建一个可变的集合
    value1.add(40)
    for (i in value1){
        println(i)
    }

    val map = HashMap<String, Int>()
    map["Apple"] = 1
    map["Banana"] = 2
    map["Orange"] = 3
    map["Pear"] = 4
    map["Grape"] = 5

    val map2 = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)

    for ((str,v) in map2){
        println("name:$str index:$v")
    }

    val max = list.maxBy { it.length }
    println(max)

    val lambda = {s:String -> s.length}
    val maxBy = list.maxBy(lambda)
    println(maxBy)

    //然后Kotlin规定，当Lambda参数是函数的最后一个参数时，可以将Lambda表达式移到函数括 号的外面
    val maxLengthFruit = list.maxBy() { fruit: String -> fruit.length }

kitlin进阶

局部静态方法

class Util {
 fun doAction1() {
 println("do action1")
 }
 //定义静态方法 可直接调用Util.doAction2()
 companion object {
	 fun doAction2() {
	 	println("do action2")
	 }
 }
}

把文件中的class改为object则整一个类都是静态类

标准函数

with 函数

with函数接收两个参数：第一个参数可以是一个任意类型的对象，第二个参数是一个Lambda表达式。with函数会在Lambda表达式中提供第一个参数对象的上下文，并使用Lambda表达式中的最后一行代码作为返回值返回。

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val result = with(StringBuilder()) {
 append("Start eating fruits.\n")
 for (fruit in list) {
 append(fruit).append("\n")
 }
 append("Ate all fruits.")
 toString()
}
println(result)

run函数

首先run函数通常不会直接调用，而是要在某个对象的基础上调用；其次run函数只接收一个Lambda参数，并且会在Lambda表达式中提供调用对象的上下文。

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val result = StringBuilder().run {
 append("Start eating fruits.\n")
 for (fruit in list) {
  append(fruit).append("\n")
 }
 append("Ate all fruits.")
 toString()
}
println(result)

上面是必须有一个上下文来调用run方法的，这里就是StringBuilder对象

apply函数

由于apply函数无法指定返回值，只能返回调用对象本身，因此这里的result实际上是一个StringBuilder对象，所以我们在最后打印的时候还要再调用它的toString()方法才行

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
val result = StringBuilder().apply {
 append("Start eating fruits.\n")
 for (fruit in list) {
 append(fruit).append("\n")
 }
 append("Ate all fruits.")
}
println(result.toString())