Kotlin编程知识总结

总结自《Android第一行代码》

变量

var val 可变变量 不可变变量
自动类型推导：
val a = 10
显式声明类型：
val a: Int = 10

函数

关键词 fun

fun methodName(param1: Int, param2: Int): Int {
	return 0
}

语法糖

fun methodName(param1: Int, param2: Int): Int = returnValue //用等号表示返回值
fun methodName(param1: Int, param2: Int) = returnValue //自动类型推导

逻辑控制

if条件

//基本的if条件控制
fun largerNumber(num1: Int, num2: Int): Int {
	var value = 0
	if (num1 > num2) {
    value = num1
	} else {
		value = num2
	}
	return value
}
//利用if语句的返回值
fun largerNumber(num1: Int, num2: Int): Int {
	val value = if (num1 > num2) {
		num1
	} else {
		num2
	}
	return value
}
//利用等号表示返回值的语法糖
fun largerNumber(num1: Int, num2: Int) = if (num1 > num2) {
	num1
} else {
	num2
}

when条件

//基本语法
when(任意类型的参数) {
	匹配值 -> { 执行逻辑 }
	匹配值 -> { 执行逻辑 }
	...
}
//利用when的返回值
fun getScore(name: String) = when (name) {
	"Tom" -> 86
	"Jim" -> 77
	"Jack" -> 95
	"Lily" -> 100
	else -> 0
}
//类型匹配，关键词为“is”
fun checkNumber(num: Number) {
	when (num) {
	is Int -> println("number is Int")
	is Double -> println("number is Double")
	else -> println("number not support")
	}
}

循环语句

//区间
val range = 0..10 //[0,10]
//用for-in 遍历
for (i in 0..10) {
	println(i)
}
//单端闭区间
val range = 0 until 10//[0,10)
//for in 的步长
for (i in 0 until 10 step 2) {
	println(i)
}
//降序区间
10 downTo 1 //[10,1]

OOP

OOP的基本

//类的创建和字段的添加，与Java一致
//实例化，无需new关键词
val p = Person()
//继承前需要加入‘open’关键词使其可以被继承
open class Person {
	...
}
//继承的关键词“:”
class Student : Person() {
	var sno = ""
	var grade = 0
}
//Person类后面的一对空括号表示Student类的主构造函数在初始化的时候会调用Person类的无参数构造函数
//调用Person的有参构造函数
class Student(val sno: String, val grade: Int, name: String, age: Int) :
	Person(name, age) {
	...
}
//次构造函数，因为几乎用不到所以不写
//接口 和Java几乎一致
//实现接口的关键词为“:”，中间用“,”分隔
class Student(name: String, age: Int) : Person(name, age), Study {
	override fun readBooks() {
		println(name + " is reading.")
	}
}
//允许对接口中的函数默认实现
interface Study {
	fun readBooks()
	fun doHomework() {
		println("do homework default implementation.")
	}
}
//函数可见性修饰符：默认为“public”，protected仅当前类和子类可见，internal 同一模块中的类可见。

数据类的单例类

//数据类：添加“data关键词，”自动根据主构造函数生成equals()、hashCode()、toString()等方法
data class Cellphone(val brand: String, val price: Double)
//单例类：将class改为Object，创建一个实例，并且保证全局只有一个实例。
object Singleton {
	fun singletonTest() {
		println("singletonTest is called.")
	}
}

Lambda编程

集合

//使用listOf函数创建不可变集合
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
//集合同样可以用for in 遍历
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
for (fruit in list) {
	printLn(fruit)
}
//使用mutableListOf函数创建可变集合
val list = mutableListOf("Apple", "Banana", "Orange", "Pear", "Grape")
list.add("Watermelon")
//同样还有Set集合，setOf和mutableSetOf函数
//哈希表Map集合
val map = HashMap<String, Int>()
map.put("Apple", 1)//传统的写法
map["Apple"] = 1//下标语法
val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)//mapOf创建
//哈希表的遍历
for ((fruit, number) in map) {
	println("fruit is " + fruit + ", number is " + number)
}

函数式API

//集合的函数式API
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val maxLengthFruit = list.maxBy { it.length }
println("max length fruit is " + maxLengthFruit)
//lambda表达式的语法结构
{参数名1: 参数类型, 参数名2: 参数类型 -> 函数体}
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val lambda = { fruit: String -> fruit.length }
val maxLengthFruit = list.maxBy(lambda)
//maxBy函数接收一个Lambda参数
//将表达式直接传入maxBy中
val maxLengthFruit = list.maxBy({ fruit: String -> fruit.length })
//当Lambda参数是函数的最后一个参数时，可以将Lambda表达式移到函数括号的外面
val maxLengthFruit = list.maxBy() { fruit: String -> fruit.length }
//如果Lambda参数是函数的唯一一个参数的话，还可以将函数的括号省略：
val maxLengthFruit = list.maxBy { fruit: String -> fruit.length }
//自动类型推导，简化Lambda表达式中参数列表的参数类型
val maxLengthFruit = list.maxBy { fruit -> fruit.length }
//当Lambda表达式的参数列表中只有一个参数时，也不必声明参数名，而是可以使用it关键字来代替
val maxLengthFruit = list.maxBy { it.length }
//其他常用的函数式API
//map 按照的需求对集合中的元素进行任意的映射转换
val newList = list.map { it.toUpperCase() }
//filter 过滤集合数据
val newList = list.filter { it.length <= 5 }
//any函数用于判断集合中是否至少存在一个元素满足指定条件，all函数用于判断集合中是否所有元素都满足指定条件
val anyResult = list.any { it.length <= 5 }
val allResult = list.all { it.length <= 5 }

空指针检查

Kotlin中的空指针

kotlin中所有参数和变量都不可为空，类名后加“?”即表示可为空的类型，可能造成空指针异常的函数都不允许编译通过

判断空指针的辅助工具

//?. 当对象不为空时正常调用相应的方法，当对象为空时则什么都不做
a?.doSomething()
//相当于
if (a != null) {
	a.doSomething()
}
//?: 左右两边都接收一个表达式，如果左边表达式的结果不为空就返回左边表达式的结果，否则就返回右边表达式的结果
val c = a ?: b
//相当于
val c = if (a ! = null) {
	a
} else {
	b
}
//应用示例
fun getTextLength(text: String?) = text?.length ?: 0
//!!非空断言，确定这里不会为空，通过编译
val upperCase = content!!.toUpperCase()
//let函数，将原始调用对象作为参数传递到Lambda表达式中
obj.let { obj2 ->
	// 编写具体的业务逻辑
}
//配合?.操作符解决空指针问题
fun doStudy(study: Study?) {
study?.let {
		it.readBooks()
		it.doHomework()
	}
}

小技巧

//字符串内嵌表达式
"hello, ${obj.name}. nice to meet you!"
//当表达式中仅有一个变量的时候，还可以将两边的大括号省略
"hello, $name. nice to meet you!"
//函数参数默认值
fun printParams(num: Int, str: String = "hello") {
	println("num is $num , str is $str")
}
//调用
printParams(123)
//通过键值对来传参，无需按照传统的顺序
printParams(str = "world", num = 123)