文章目录
一、Android 中的日志工具类 Log
- Log.v():对于级别 verbose,是 Android 日志里面级别最低的一种。用于打印那些最为琐碎的、意义最小的日志信息。
- Log.d():对应级别 debug,比 verbose 高一级。用于打印一些调试信息,这些信息对你调试程序和分析问题应该是有帮助的。
- Log.i():对应级别 info,比 debug 高一级。用于打印一些比较重要的数据,这些数据应该是你非常想看到的、可以帮你分析用户行为的数据。
- Log.w():对应级别 warn,比 info 高一级。用于打印一些警告信息,提示程序在这个地方可能会有潜在的风险,最好去修复一下这些出现警告的地方。
- Log.e():对应级别 error,比 warn 高一级。用于打印程序中的错误信息,比如程序进入了 catch 语句中。当有错误信息打印出来的时候,一般代表你的程序出现严重问题了,必须尽快修复。
二、变量和函数
2.1、变量
一、只有两种关键字
- val(value):用来声明一个不可变的变量,这种变量在初始赋值之后就再也不能重新赋值,对应 Java 中的 final 变量。
- var(variable):用来声明一个可变的变量,这种变量在初始赋值之后仍然可以再被重新赋值,对应 Java 中的非 final 变量。
定义一个变量时,应该先使用 val,如果有需要给变量重新赋值的情况,再使用 var。
二、类型推导机制
如果不显式声明变量类型,a 的类型会根据 10 自动推导成 Int。
val a = 10
也可以显式声明变量类型。
val a: Int = 10
三、数据类型
Kotlin 完全抛弃了 Java 中的基本数据类型,全部使用了对象数据类型。
Java 基本数据类型 | Kotlin 基本数据类型 | 数据类型说明 |
---|---|---|
int | Int | 整型 |
long | Long | 长整型 |
short | Short | 短整型 |
float | Float | 单精度浮点型 |
double | Double | 双精度浮点型 |
boolean | Boolean | 布尔型 |
char | Char | 字符型 |
byte | Byte | 字节型 |
2.2、函数(方法)
2.3、语法糖
fun methodName(params1: Int, params2: String): Int {
return 0
}
函数中只有一行代码时,可以不写函数体,return 也可以被省略。
fun methodName(params1: Int, params2: String): Int = 0
根据类型推导机制,省略返回值类型。
fun methodName(params1: Int, params2: String) = 0
三、程序的逻辑控制
3.1、if 条件语句
fun largerNumber(num1: Int, num2: Int): Int {
var value = 0
if (num1 > num2) {
value = num1
} else {
value = num2
}
return value
}
Kotlin 中的语句可以有返回值,返回值就是 if 语句每一个条件中最后一行代码的返回值。所以上述代码可以简化。在这里 value 使用的是 if 的返回值直接赋值,修饰符可以由 var 变为 val。
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
}
因为 if 语句中最后一行代码是一个返回值,所以上述代码还可以去掉 if 语句的大括号,精简成一行代码。
fun largerNumber(num1: Int, num2: Int) = if (num1 > num2) num1 else num2
3.2、when 条件语句
这里用一个示例来说明,写一个成绩查询的功能,输入学生姓名,返回考试分数,先用 if 来实现。
fun getScore(name: String) = if (name == "张三")
86
else if (name == "李四")
77
else if (name == "王五")
96
else if (name == "赵六")
100
else
0
使用 when 条件语句来实现。
fun getScore(name: String) = when (name) {
"张三" -> 86
"李四" -> 77
"王五" -> 96
"赵六" -> 100
else -> 0
}
when 语句还可以进行类型匹配。Number 类型是 Kotlin 内置的一个抽象类,Int、Long、Double 等等数据类型都是其子类。
fun getScore(num: Number) = when (num) {
is Int -> println("num is Int")
is Double -> println("num is Double")
else -> println("number not support")
}
最后 when 语句还有一种不带参数的写法。看起来代码变冗余了,不过有些场景却只有用这种才能实现,比如再下面还写一个所有姓张的人返回的分数都是 86.
fun getScore(name: String) = when {
name == "张三" -> 86
name == "李四" -> 77
name == "王五" -> 96
name == "赵六" -> 100
else -> 0
}
fun getScore(name: String) = when {
name.startsWith("张") -> 86
name == "李四" -> 77
name == "王五" -> 96
name == "赵六" -> 100
else -> 0
}
3.3、循环语句
循环语句有 while 语句和 for 语句。其中 while 语句 和 Java 中的 while 没有任何区别,这里只说 for 语句的用法。
两端都是闭区间( 0 和 10 也包含在其中)。
val range = 0..10
左闭右开(包含 0 不包含 10)。
val range = 0 until 10
跳过某个元素(跳过 2)。
val range = 0..10 step 2
两端都是闭区间的降序。
val range = 10 downTo 1
使用 for 循环。
for (i in range) {
println(i)
}
四、面向对象编程
4.1、类与对象
创建一个类。
class Person {
var name = ""
var age = 0
fun eat() {
println(name + "正在吃饭,他" + age + "岁了。")
}
}
创建一个对象。Kotlin 中不在使用 new 关键字。
val p = Person()
4.2、继承与构造函数
一、继承
创建一个 Student 类继承 Person 类。Kotlin 中非抽象类默认不可被继承。一个非抽象类需要能被继承,需要加 open 关键字。
class Student : Person() {
var sno = ""
var grade = 0
}
抽象类和加 open 关键字。
// 抽象类
abstract class Person
// 非抽象类可继承
open class Person
二、主构造函数
默认无参构造函数。
class Student : Person() {
var sno = ""
var grade = 0
}
有参构造函数。
class Student(val sno: String, val grade: Int) : Person() {
}
Kotlin 提供了一个 init 用来写构造函数的逻辑。
class Student(val sno: String, val grade: Int) : Person() {
init {
// 构造函数逻辑
}
}
可以在 init 结构体中调用父类的构造函数,但是并不推荐这种方式。这就是继承 Person 需要加 () 的原因,上面的继承 Person 的方式表示默认调用了父类的无参构造函数。首先改造父类构造函数,变为有参。
open class Person(val name: String, val age: Int) {
fun eat() {
println(name + "正在吃饭,他" + age + "岁了。")
}
}
再继承 Person 就表示调用父类的有参构造函数了。同时要注意,这时在 Student 的构造函数中增加的 name 和 age 两个字段并没有加 val 和 var。
class Student(val sno: String, val grade: Int, name: String, age: Int) : Person(name, age) {
init {
// 构造函数逻辑
}
}
三、次构造函数
当一个类既有主构造函数又有次构造函数时,所有的次构造函数都必须调用主构造函数(包括间接调用)。次构造函数通过 constructor 关键字来定义,也可以用于实例化一个类,跟主函数不同的是,它是有函数体的。
class Student(val sno: String, val grade: Int, name: String, age: Int) : Person(name, age) {
init {
// 构造函数逻辑
}
// 这里的 this 表示下面的次构造函数,可间接调用主构造函数
constructor() : this("", 0) {}
// this 表示直接调用主构造函数
constructor(name: String, age: Int) : this("", 0, "", 0) {}
}
还有一种特殊的情况,类中只有次构造函数,没有主构造函数。当一个类中没有显式的定义主构造函数且定义了次构造函数时,它就是没有主构造函数的。
当 Student 类中没有主构造函数时,继承 Person 类时也不需要再加上括号了。由于 Student 没有了主构造函数,次构造函数就只能调用父类的构造函数,this 关键字也因此变成了 super。
class Student : Person {
constructor(name: String, age: Int) : super(name, age) {}
}
4.3、接口
创建一个接口 Study。Kotlin 也允许对接口中定义的函数进行默认实现,当某个函数有默认实现时,实现这个接口就不用强制要求实现这个函数。
interface Study {
fun readBooks()
fun doHomework() {
println("默认实现做作业")
}
}
Kotlin 中不管是继承父类,还是实现接口,都统一使用冒号,中间用逗号隔开。另外接口的后面不用加上括号,因为它没有构造函数可以去调用。
class Student(name: String, age: Int) : Person(name, age), Study {
override fun readBooks() {
TODO("Not yet implemented")
}
override fun doHomework() {
TODO("Not yet implemented")
}
}
面向接口调用,又叫多态。
//调用
val student = Student("张三", 29)
doStudy(student)
fun doStudy(study: Study) {
study.readBooks()
study.doHomework()
}
函数修饰符。
修饰符 | Java | Kotlin |
---|---|---|
public | 所有类可见 | 所有类可见(默认) |
private | 当前类可见 | 当前类可见 |
protected | 当前类、子类、同一包路径下的类可见 | 当前类、子类可见 |
default | 同一包路径下的类可见(默认) | 无 |
internal | 无 | 同一模块中的类可见 |
4.4、数据类与单例类
一、数据类
数据类通常需要重写 equals()、hashCode()、toString() 这几个方法。其中,equals() 方法用于判断两个数据类是否相等。hashCode() 方法作为 equals() 的配套方法,也需要一起重写,否则会导致 HashMap、HashSet 等 hash 相关的系统类无法正常工作。toString() 方法用于提供更清晰的输入日志,否则一个数据类默认打印出来就是一行内存地址。
在 Kotlin 中,如果你希望一个类是数据类,只需要在 class 前面加上 data 关键字就可以了。Kotlin 会根据主构造函数中的参数帮你将 equals()、hashCode()、toString() 等固定且无实际逻辑意义的方法自动生成。当一个类中没有任何代码时,还可以省略大括号。
data class Person(val name: String, val age: Int)
二、单例类
Java 单例类可参考设计模式。
Kotlin 中实现单例模式非常简单,只需要将 class 关键字改成 object 关键字。
//调用
Singleton.singletonTest()
object Singleton {
fun singletonTest() {
println("调用了单例类")
}
}
五、Lambda 编程
5.1、集合的创建与遍历
传统意义上的集合主要就是 List 和 Set,再广泛一点的话,像 Map 这样的键值对数据结构也可以包含进来。List、Set 和 Map 在 Java 中都是接口,List 的主要实现类是 ArrayList 和 LinkedList,Set 的主要实现类是 HashSet,Map 的主要实现类是 HashMap。
一、List、Set
常规实现 List、Set。
val list = ArrayList<String>()
list.add("Apple")
list.add("Banana")
list.add("Orange")
val set = HashSet<String>()
set.add("Apple")
set.add("Banana")
set.add("Orange")
不可变集合 List、Set。
val list = listOf("Apple", "Banana", "Orange")
val set = setOf("Apple", "Banana", "Orange")
可变集合 List、Set。
val list = mutableListOf("Apple", "Banana", "Orange")
val set = mutableSetOf("Apple", "Banana", "Orange")
二、Map
传统的 Map,Kotlin 中并建议再使用 put、set 方法。
val map = HashMap<String, Int>()
map.put("Apple", 1)
map.put("Banana", 2)
map.put("Orange", 3)
Kotlin 推荐写法。
val map = HashMap<String, Int>()
map["Apple"] = 1
map["Banana"] = 2
map["Orange"] = 3
// 取数据
val num = map["Apple"]
不可变集合 Map,在这里 to 并不是一个关键字,而是一个 infix 函数。
val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3)
可变集合 Map。
val map = mutableMapOf("Apple" to 1, "Banana" to 2, "Orange" to 3)
5.2、集合的函数式 API
一、语法结构
首先看一下函数式 API 的语法结构,也就是 Lambda 表达式的语法结构。
{ 参数1,参数2 -> 函数体}
下面看一个例子,打印单词最长的水果名。
val list = listOf("Apple", "Banana", "Orange")
val lambda = { fruit: String -> fruit.length }
val maxFruit = list.maxBy(lambda)
val maxFruit = list.maxBy({ fruit: String -> fruit.length })
当 Lambda 参数是函数的最后一个参数时,可将 Lambda 表达式移到括号外。
val maxFruit = list.maxBy(){ fruit: String -> fruit.length }
当 Lambda 参数时函数的唯一参数时,可将函数的括号省略。
val maxFruit = list.maxBy{ fruit: String -> fruit.length }
类型推导机制,大多情况都不需要参数类型。
val maxFruit = list.maxBy{ fruit -> fruit.length }
当 Lambda 表达式中只有一个参数时,可不声明参数,直接用 it 代替。
val maxFruit = list.maxBy { it.length }
二、常用集合的函数式 API
- map 函数,映射每个元素为另外的值,生成一个新的集合。比如将所有元素转为大写。
val list = listOf("Apple", "Banana", "Orange")
val newList = list.map { it.toUpperCase() }
- filter 函数,用于过滤集合中的数据,并生成一个新的集合。比如只保留单词长度小于等于 5 的元素。
val list = listOf("Apple", "Banana", "Orange")
val newList = list.filter { it.length <= 5 }
- map 函数和 filter 也可以配合使用。不过要注意的是,调用顺序会影响执行效率,如果先映射每一个元素再过滤,执行效率会比先过滤再映射每一个元素要慢。所以这里选择先过滤再转换。
val list = listOf("Apple", "Banana", "Orange")
val newList = list.filter { it.length <= 5 }.map { it.toUpperCase() }
- any 函数和 all 函数,其中 any 函数用于判断集合中是否至少存在一个元素满足指定条件, all 函数用于判断集合中是否所有元素都满足指定条件。它们都返回布尔类型。
val list = listOf("Apple", "Banana", "Orange")
val any = list.any { it.length <= 5 }
val all = list.all { it.length <= 5 }
- 在集合中还有很多其他函数式 API,它们的基本语法规则都类似。
5.3、Java 函数式 API
如果在 Kotlin 中调用了一个 Java 方法,并且该方法接收一个 Java 单抽象方法接口参数,就可以使用函数式 API。Java 单抽象方法接口是指接口中只有一个待实现的方法,如果有多个待实现的方法,则无法使用函数式 API。
Java 原生 API 中有个最为常见的单抽象方法接口——Runnable 接口。只有一个待实现的 run() 方法。
@FunctionalInterface
public interface Runnable {
public abstract void run();
}
使用 Java 开启一个线程。
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("开启了线程");
}
}).start();
使用 Kotlin 开启一个线程。
Thread(object : Runnable {
override fun run() {
println("开启了线程")
}
})
Runnable 类中只有一个待实现方法,可不显示的重写 run 方法。
Thread(Runnable {
println("开启了线程")
})
如果一个 Java 方法的参数列表中不存在多余一个的单抽象方法接口参数,还可以将接口名省略。
Thread({
println("开启了线程")
})
跟前面 Kotlin 中函数式 API 的用类似,当 Lambda 表达式是方法的最后一个参数时,可以将 Lambda 表达式移动到括号外。只有一个参数时,去掉括号。
Thread {
println("开启了线程")
}
Java 函数式 API 的写法也常用到,例如点击事件。
button.setOnClickListener {
}
六、空指针检查
6.1、可空类型系统
回到 doStudy| 函数,在 Kotlin 实现的情况下,这里是不允许传入 null 作为参数的。
fun doStudy(study: Study) {
study.readBooks()
study.doHomework()
}
如果需要 null 可以作为参数传入,需要在类名后加一个问号,但是这时内部也需要做判空处理,不然会编译报错。
fun doStudy(study: Study?) {
if (study != null) {
study.readBooks()
study.doHomework()
}
}
6.2、判空辅助工具
?.
如果像上面每次都用 if 做判空处理,代码又会变得比较啰嗦,而且 if 判断语句还处理不了全局量的判空问题。为此 Kotlin 提供了一系列的辅助工具。首先是 ?. 操作符,当对象不为空时调用相应方法,为空时什么都不做,比如上面的代码可改为。
fun doStudy(study: Study?) {
study?.readBooks()
study?.doHomework()
}
?:
接下来是 ?: 操作符。比如下面简化前和简化后的代码。
val c = if (a != null) {
a
} else {
b
}
val c = a?:b
?. 和 ?:
?. 和 ?: 操作符的结合使用。比如编写一个函数来获得一段文本的长度,简化前和简化后代码如下。
fun getTextLength(text: String?): Int {
if (text != null) {
return text.length
}
return 0
}
fun getTextLength(text: String?): Int {
return text?.length ?: 0
}
在有时候我们已经在逻辑上对空指针进行了处理,但是因为 Kotlin 的空指针检查机制还是会导致代码编译不过。
比如定义一个可为空的全局变量 content,然后在 onCreate 中调用时先进行判空操作,当 content 不为空时才会调用 printUpperCase() 函数,在 printUpperCase() 函数中,我们将 content 转换为大写模式,最后打印出来。这段代码在逻辑上是没有问题的,但是因为空指针检查机制,printUpperCase() 函数并不知道外部已经对 content 变量进行了非空检查,导致编译失败。
在这种情况下,如果我们要强行通过编译,可以使用非空断言工具,在对象的后面加上 !!,不过这也是一种有风险的实现方式,代码如下。
let
let 即不是操作符,也不是什么关键字,而是一个函数,属于 Kotlin 中的标准函数。
下面的 doStudy() 函数的写法如果翻译成 if 判断语句的写法,可以看出每次调用 study 对象的任何方法,都会进行一次判空。
fun doStudy(study: Study?) {
study?.readBooks()
study?.doHomework()
}
fun doStudy(study: Study?) {
if (study != null) {
study.readBooks()
}
if (study != null) {
study.doHomework()
}
}
这时我们就可以结合使用 ?. 操作符和 let 函数对代码进行优化。下面的代码中,?. 操作符表示对象为空时什么都不做,对象不为空时就调用 let 函数,let 函数会将 study 对象本身作为参数传递到 Lambda 表达式中,此时的 study 对象就不会再为空了。
fun doStudy(study: Study?) {
study?.let { stu ->
stu.readBooks()
stu.doHomework()
}
}
当 Lambda 表达式的参数列表中只有一个参数时,可以不用参数名,使用 it 关键字代替。
fun doStudy(study: Study?) {
study?.let {
it.readBooks()
it.doHomework()
}
}
除此之外,let 函数还可以处理全局变量的判空问题,而使用 if 语句无法做到这一点,因为全局变量的值可能被其他线程所修改,比如以下代码是会报错的。
七、有用的小知识点
7.1、字符串内嵌表达式
拼接字符串可以告别加号,使用字符串内嵌表达式。
"hello, ${obj.name}. nice to meet you!"
当表达式中只有一个变量时,还可以省略大括号。
"hello, $name. nice to meet you!"
7.2、函数的参数默认值
下面的函数中,给第二个参数设定了一个默认值,这样在调用 printParams() 函数时,可以选择是否给第二个参数传值,不传就会使用默认值。
// 调用
printParams(123)
fun printParams(num: Int, str: String = "hello") {
println("num is $num, str is $str")
}
上面的情况中,我们设置的是第二个参数的默认值,如果只给第一个参数设置默认值,这样的方式就行不通了,因为调用时编译器会认为我们想把字符串赋值给第一个 num 参数,从而报类型不匹配的错误。
// 调用
printParams("str")
fun printParams(num: Int = 100, str: String) {
println("num is $num, str is $str")
}
要解决上面的问题,Kotlin 中可以通过键值对的方式传参,不需要关心传参的顺序,这时就可以省略有默认值的 num 参数了。
printParams(str = "world", num = 123)
printParams(str = "world")
在前面讲过的构造函数中,看下面的代码,有一个主构造函数和两个次构造函数。在学习了给函数的参数设置默认值后,这个功能可以很大程度上替代次构造函数的作用。
class Student(val sno: String, val grade: Int, name: String, age: Int) : Person(name, age) {
constructor() : this("", 0) {}
constructor(name: String, age: Int) : this("", 0, "", 0) {}
}
class Student(val sno: String = "", val grade: Int = 0, name: String = "", age: Int = 0) :
Person(name, age) {
}