(讲课篇)让小白都能明白的Android开发-2. 跨入Android大门的Kotlin语言篇 - 服务器托管|北京服务器租用|机房托管租用|IDC托管租用|机房机柜带宽租用-价格及费用咨询

文章目录

开始

基本用法

基础语法
程序的入口
函数
变量
注释
字符串模板
条件表达式
空值与null检测
类型检测与自动类型转换
for循环
while循环
when表达式
使用区间（range）
集合

习惯用法

创建数据类
函数的默认参数
过滤list
字符串内插
类型判断
遍历map/pair型list
使用区间
只读list
只读map
访问map
延迟属性
扩展函数
创建单例
if not null 缩写
if not null and else 缩写
if null 执行一个语句
在可能会空的集合中取第一元
if not null 执行代码
映射可空值（如果非空的话）
返回when表达式
“try/catch”表达式
“if”表达式
返回类型为 Unit 的方法的 Builder 风格用法
单表达式函数
对一个对象实例调用多个方法（with）
配置对象的属性（apply）
Java 7 的 try with resources
对于需要泛型信息的泛型函数的适宜形式
使用可空布尔
交换两个变量

大家好，我叫赵健，目前是一名Android开发工程师。今天开始我们一起步入Android开发的世界。本系列课程一共分为6节课，分别讲解了从事Android开发从知道到实际应用几个难点。本系列课程主要有以下几部分：

快速创建一个安卓应用以及基本UI的掌握
跨入Android大门的Kotlin语言篇
所有的动画都来源于这些操作
自定义UI及一些概念
快速接入第三方应用
分析一下优秀的开源程序

上节课我们了解到了Android开发的基础知识，那我们就开始第二节课《跨入Android大门的Kotlin语言篇》

本节课成分为一下几小结：

开始
基础
类与对象
函数与Lambda表达式
集合

我们先大概的了解一下kotlin所用到的语法，然后逐步深入。

开始

基本用法

基础语法

包的定义与导入

package my.demo
import kotlin.text.*
// ...

程序的入口

Kotlin应用程序的入口点是main函数：

for main(){
	println("Hello World！")
}

函数

带有两个Int参数，返回Int的函数：

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

将表达式作为函数体、返回值类型自动推断的函数：

fun sum(a:Int, b:Int) = a+b

函数返回无意义的值：

fun printSum(a:Int, b:Int):Unit{
	printl("sum of $a and $b is ${a+b}")
}

Unit返回类型可以省略：

fun printSum(a:Int, b:Int){
	printl("sum of $a and $b is ${a+b}")
}

变量

定义只读局部变量使用关键字val定义。只能为其赋值一次。

val a:Int=1 //立即赋值
val b=2 //自动推断出`Int`类型
val c:Int //如果没有初始值类型不能省略
c = 3 //明确赋值

可重新赋值的变量使用var关键字：

var x = 5 //自动推断出Int类型
x += 1

顶层变量：

val PI = 3.14
var x = 0
fun incrementX(){
	x += 1
}

注释

与大多数现代语言一样，Kotlin支持单行（或行末）与多行（块）注释。

// 这是一个行注释
/* 这是一个多行的
	块*/

Kotlin中的块注释可以嵌套。

/*注释从这里开始
/*包含嵌套的注释*/
并且再这里结束*/

字符串模板

var a = 1
// 模板中的简单名称：
val s1 = "a is $a"

a = 2
//模板中的任意表达式
val s2 = "${s1.replace("is", "was")}, but now is $a"

条件表达式

fun maxOf(a:Int, b:Int):Int{
	if(a>b){
		return a
	} else {
		return b
	}
}

再Kotlin中，if也可以用作表达式：

fun maxOf(a:Int, b:Int) = if (a>b) a else b

空值与null检测

当某个变量的值可以为null的时候，必须再声明处的类型后添加？来标识引用可为空。
如果str的内容不是数字返回null：

fun parseInt(str:String):Int?{
	//...
}

使用返回可空值的函数：

fun printProduct(arg1:String, arg2:String){
	val x = parseInt(arg1)
	val y = parseInt(arg2)
	//直接使用x*y会导致编译错误，因为它们可能为null
	if(x != null && y!= null) {
		//再空检测后，x与y会自动转换为非空值（non-nullable）
		println(x * y)
	} else {
		println("'$arg1")
	}
}

或者

// ...
// ……
if (x == null) {
    println("Wrong number format in arg1: '$arg1'")
    return
}
if (y == null) {
    println("Wrong number format in arg2: '$arg2'")
    return
}

// 在空检测后，x 与 y 会自动转换为非空值
println(x * y)

类型检测与自动类型转换

is运算符检测一个表达式是否某类型的一个实例。如果一个不可变的局部变量或属性已经判断出为某类型，那么检测后的分支中可以当作该类型使用，无需显示转换：

fun getStringLength(obj: Any): Int? {
    if (obj is String) {
        // `obj` 在该条件分支内自动转换成 `String`
        return obj.length
    }

    // 在离开类型检测分支后，`obj` 仍然是 `Any` 类型
    return null
}

或者
fun getStringLength(obj: Any): Int? {
    if (obj !is String) return null

    // `obj` 在这一分支自动转换为 `String`
    return obj.length
}
甚至
fun getStringLength(obj: Any): Int? {
    // `obj` 在 `&&` 右边自动转换成 `String` 类型
    if (obj is String && obj.length > 0) {
      return obj.length
    }

    return null
}

for循环

val items = listOf("apple", "banana", "kiwifruit")
for (item in items) {
    println(item)
}

或者
val items = listOf("apple", "banana", "kiwifruit")
for (index in items.indices) {
    println("item at $index is ${items[index]}")
}

while循环

val items = listOf("apple", "banana", "kiwifruit")
var index = 0
while (index

when表达式

fun describe(obj: Any): String =
    when (obj) {
        1          -> "One"
        "Hello"    -> "Greeting"
        is Long    -> "Long"
        !is String -> "Not a string"
        else       -> "Unknown"
    }

使用区间（range）

使用in运算符来检测某个数字是否再指定区间内

val x = 10
val y = 9
if (x in 1..y+1) {
    println("fits in range")
}

检测某个数字是否再指定区间外：

val list = listOf("a", "b", "c")

if (-1 !in 0..list.lastIndex) {
    println("-1 is out of range")
}
if (list.size !in list.indices) {
    println("list size is out of valid list indices range, too")
}

区间迭代：

for (x in 1..5){
	print(x)
}

或数列迭代：

for (x in 1..10 step 2){
	print(x)
}
println()
for (x in 9 downTo 0 step 3){
	print(x)
}

集合

对集合进行迭代：

for (item in items){
	println(item)
}

使用in运算符来判断集合内是否包含某实例：

when {
	"orange" in items -> println("juicy")
	"apple" in items -> println("apple is fine too")
}

使用lambda表达式(filter)与映射(map)集合：

val fruits = listof("banana", "avocado", "apple", "kiwifruit")
fruits
	.filter{ it.startsWith("a") }
	.sortedBy { it }
	.map { it.toUpperCase() }
	.forEach { println(it) }

习惯用法

创建数据类

data class Customer(val name:String, val email:String)

会为Customer类提供以下功能：

所有属性的getters（对var定义的还有setters）
equals()
hashCode()
toString()
copyt()
所有属性的component1()、component()…等等

函数的默认参数

fun foo(a:Int = 0, b:String = “”) { … }

过滤list

val positives = list.filter {x -> x > 0}

或者可以更短
val positives = list.filter { it > 0 }

检测元素是否攒在于集合中

if("john@example.com" in emailsList) { ... }
if("john@example.com" !in emailsList) { ... }

字符串内插

println(“Name $name”)

类型判断

when(x){
	is FOO //->...
	is Bar //->...
	else //-> ...
}

遍历map/pair型list

for((k,v) in map) {
	println("$k -> $v")
}

k、v可以改成任意名字

使用区间

for (i in 1..100) { …… }  // 闭区间：包含 100
for (i in 1 until 100) { …… } // 半开区间：不包含 100
for (x in 2..10 step 2) { …… }
for (x in 10 downTo 1) { …… }
if (x in 1..10) { …… }

只读list

val list = listOf(“a”, “b”, “c”)

只读map

val map = mapOf(“a” to 1, “b” to 2, “c” to 3)

访问map

println(map[“key”])
map[“key”]=value

延迟属性

val p:String by lazy{
//计算该字符串
}

扩展函数

fun String.spaceToCamelCase() {......}
"Convert this to camelcase".spaceToCamelCase()

创建单例

object Resource {
    val name = "Name"
}

if not null 缩写

val files = File("Text").listFiles()
println(files?.size)

if not null and else 缩写

val files = File("Test").listFiles()

println(files?.size ?: "empty")

if null 执行一个语句

val values = ……
val email = values["email"] ?: throw IllegalStateException("Email is missing!")

在可能会空的集合中取第一元

val emails = …… // 可能会是空集合
val mainEmail = emails.firstOrNull() ?: ""

if not null 执行代码

val value = ……

value?.let {
    …… // 代码会执行到此处, 假如data不为null
}

映射可空值（如果非空的话）

val value = ……

val mapped = value?.let { transformValue(it) } ?: defaultValue 
// 如果该值或其转换结果为空，那么返回 defaultValue。

返回when表达式

fun transform(color: String): Int {
    return when (color) {
        "Red" -> 0
        "Green" -> 1
        "Blue" -> 2
        else -> throw IllegalArgumentException("Invalid color param value")
    }
}

“try/catch”表达式

fun test() {
    val result = try {
        count()
    } catch (e: ArithmeticException) {
        throw IllegalStateException(e)
    }

    // 使用 result
}

“if”表达式

fun foo(param: Int) {
    val result = if (param == 1) {
        "one"
    } else if (param == 2) {
        "two"
    } else {
        "three"
    }
}

返回类型为 Unit 的方法的 Builder 风格用法

fun arrayOfMinusOnes(size: Int): IntArray {
    return IntArray(size).apply { fill(-1) }
}

单表达式函数

fun theAnswer() = 42

等价于

fun theAnswer(): Int {
    return 42
}

单表达式函数与其它惯用法一起使用能简化代码，例如和 when 表达式一起使用：

fun transform(color: String): Int = when (color) {
    "Red" -> 0
    "Green" -> 1
    "Blue" -> 2
    else -> throw IllegalArgumentException("Invalid color param value")
}

对一个对象实例调用多个方法（with）

class Turtle {
    fun penDown()
    fun penUp()
    fun turn(degrees: Double)
    fun forward(pixels: Double)
}

val myTurtle = Turtle()
with(myTurtle) { // 画一个 100 像素的正方形
    penDown()
    for (i in 1..4) {
        forward(100.0)
        turn(90.0)
    }
    penUp()
}

配置对象的属性（apply）

val myRectangle = Rectangle().apply {
    length = 4
    breadth = 5
    color = 0xFAFAFA
}

这对于配置未出现在对象构造函数中的属性非常有用。

Java 7 的 try with resources

val stream = Files.newInputStream(Paths.get("/some/file.txt"))
stream.buffered().reader().use { reader ->
    println(reader.readText())
}

对于需要泛型信息的泛型函数的适宜形式

//  public final class Gson {
//     ……
//     public  T fromJson(JsonElement json, Class classOfT) throws JsonSyntaxException {
//     ……

inline fun  Gson.fromJson(json: JsonElement): T = this.fromJson(json, T::class.java)

使用可空布尔

val b: Boolean? = ……
if (b == true) {
    ……
} else {
    // `b` 是 false 或者 null
}

交换两个变量

var a = 1
var b = 2
a = b.also { b = a }

服务器托管，北京服务器托管，服务器租用 http://www.fwqtg.net
机房租用，北京机房租用，IDC机房托管， http://www.fwqtg.net

相关推荐: 飞书自建无需代码连接短信宝的方法

1. 飞书自建用户使用场景：公司要举行一场重要会议，需要在飞书群里统计数据，并向所有参会人员通过短信宝发送短信提醒。然而，由于工作繁忙，管理员没有时间一个一个编辑并发送短信，常常发生遗漏的情况，不利于会议顺利开展。因此，管理员常常在想这一套流程是否可以实现自…