入门Kotlin编程 — 《第一行代码》学习笔记 01入门 Kotlin 编程

169 阅读 0 评论 112 点赞

我是靠谱客的博主负责外套，这篇文章主要介绍入门Kotlin编程 — 《第一行代码》学习笔记 01入门 Kotlin 编程，现在分享给大家，希望可以做个参考。

入门 Kotlin 编程

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
We declare a package-level function main which returns Unit and takes an Array of strings as a parameter. Note that semicolons are optional.
**/
import kotlin.math.max

fun main(){
    val a = 37
    val b = 40
    val value = largerNumber(a, b)
    println("larger number is " + value)
}

fun largerNumber(num1: Int, num2: Int): Int {
    return max(num1, num2)
}
// 等同于 fun largerNumber(num1: Int, num2: Int): Int = max(num1, num2)
// 简化 fun largerNumber(num1: Int, num2: Int) = max(num1, num2) 函数体.

变量：

val - 赋初值后不变的变量. 对应Java中的final变量.
var - 赋初值后仍可变的变量. 对应Java中的非final变量.
显式声明变量类型：val a: Int = 10 // 显式声明了变量 a 的类型为 Int .
对象数据类型：类 —— Int 整型、 Long 长整型、 Short 短整型、 Float 单精度浮点型、 Double 双精度浮点型、 Boolean 布尔型 Char 字符型、 Byte 字节型 .

函数：

关键字：fun（定义函数），使用 fun 进行声明. —— fun + 函数名（参数）
参数声明：“参数名：参数类型”

语句：

if 条件语句：if(num1 > num2){ num1 } else { num2 }
when 条件语句：允许传入一个任意类型的参数，然后可以在 when 结构体中定义一系列的条件 —— 匹配值 -> { 执行逻辑 }

Number -> 抽象类 . is 关键字是类型匹配的核心 .

== ：关键字，判断字符串或对象是否相等 . 参数名.startsWith("") -> 以…开头
while 循环
for 循环：—— for - in 循环 .

闭区间：val range = 0…10 -> [0, 10] . “…” 是创建两端闭区间的关键字 .

半开区间：val range = 0 until 10 -> [0,10) . until 关键字用来创建一个左闭右开的区间 .

步数：step 关键字 .

降序区间：downTo 关键字 . num1 downTo num2

类与对象：

class 关键字：声明类 . class Person { }
实例化对象不需要 new 关键字 . val p = Person( )

继承与构造函数：

小类继承大类. 例如 Student类继承 Person类 .

（1）令 Person类可以被继承. Kotlin 中任意一个非抽象类默认都是不可以被继承. ！（open 关键字）

（2）继承的关键字 -> “：” class Student : Person( ) { }
主构造函数：没有函数体，直接定义在类名后面. （默认不带参数）

init 结构体 -> 存放主构造函数的逻辑.
次构造函数：constructor 关键字定义.

通过 this 关键字调用主构造函数.

通过 super 关键字调用父类.

接口：

interface 关键字.
接口中的函数不要求有函数体. 使用 “：” 实现接口.
override 关键字重写父类或者接口类中的函数

函数的可见性修饰符：

public：所有类可见（默认）
private：当前类可见
protected：当前类、子类可见
default：无.
internal：同一模块中的类可见

数据类与单例类：

M：数据类（如常见的架构模式名词）
data 关键字：声明数据类，自动生成 equals( ) 、hashCode( ) 、toString( ) 等方法.
单例类：避免创建重复的对象，某个类在全局最多只能拥有一个实例（单例模式）.
object 关键字：创建单例类. 调用实例 -> Singleton.singletonTest( )

Lambda 编程：

集合的创建与履历：

List：ArrayList 、LinkedList
Set：HashSet
Map：HashMap
listOf( ) 函数：简化初始化集合的方法. 利用 for - in 语句进行遍历集合. // 创建不可变的集合，只能用于读取.
mutableListOf( ) 函数：创建一个可变的集合，进行增删.
复制代码val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape") for (fruit in list){ println(fruit) } val list1 = mutableListOf("Apple", "Banana", "Orange", "Pear", "Grape") for (fruit1 in list1){ println(fruit1) }
```
1
2
3
4
5
6
7
8
9
10
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape")
for (fruit in list){
  println(fruit)
}

val list1 = mutableListOf("Apple", "Banana", "Orange", "Pear", "Grape")
for (fruit1 in list1){
  println(fruit1)
}
```
setOf( ) / mutableSetOf( ) 函数：创建 Set 集合，底层使用 hash 映射方式，无法保证有序.
复制代码val set = setOf("Apple", "Banana", "Orange", "Pear", "Grape") for (fruit in set){ println(fruit) }
```
1
2
3
4
5
val set = setOf("Apple", "Banana", "Orange", "Pear", "Grape")
for (fruit in set){
  println(fruit)
}
```

Map 集合：键值对式. ->

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
val map = HashMap<String, Int>()
map["Apple"] = 1
// map.put("Apple", 1)
map["Banana"] = 2
map["Orange"] = 3
map["Pear"] = 4
map["Grape"] = 5
// 读取数据
val number = map["Apple"]

//最简便的写法：直接传入初始化的键值对组合来完成集合的创建：
val map = mapOf("Apple" to 1, "Banana" to 2, "Orange" to 3, "Pear" to 4, "Grape" to 5)
// to -> infix 函数
// 遍历 map
for ((fruit, number) in map){
  println("fruit is $fruit, number is $number")
}

集合的函数式 API：

复制代码

//Sample：寻找单词最长的水果英文名 -> it.length
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val maxLengthFruit = list.maxBy { it.length }
println("Max length fruit is %maxLengthFruit")

// 理解 Lambda
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val lambda = { fruit: String -> fruit.length }
val maxLengthFruit = list.maxBy(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 }

// 令所有的水果名都变成大写模式 -> it.toUpperCase()
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val newList = list.map { it.toUpperCase() }
for (fruit in newList){
  println(fruit)
}

// 过滤集合中的数据 -> filter函数
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val newList = list.filter { it.length <= 5 }
									.map{ it.toUpperCase() }
for (fruit in newList){
  println(fruit)
}

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
// 判断集合中是否至少存在一个元素满足指定条件 -> any函数
val anyResult = list.any { it.length <= 5 }
// 判断集合中是否所有元素都满足指定条件 -> all函数
val allResult = list.all { it.length <= 5 }
println("anyResult is $anyResult, allResult is $allResult")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
//Sample：寻找单词最长的水果英文名 -> it.length
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val maxLengthFruit = list.maxBy { it.length }
println("Max length fruit is %maxLengthFruit")

// 理解 Lambda
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val lambda = { fruit: String -> fruit.length }
val maxLengthFruit = list.maxBy(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 }

// 令所有的水果名都变成大写模式 -> it.toUpperCase()
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val newList = list.map { it.toUpperCase() }
for (fruit in newList){
  println(fruit)
}

// 过滤集合中的数据 -> filter函数
val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
val newList = list.filter { it.length <= 5 }
									.map{ it.toUpperCase() }
for (fruit in newList){
  println(fruit)
}

val list = listOf("Apple", "Banana", "Orange", "Pear", "Grape", "Watermelon")
// 判断集合中是否至少存在一个元素满足指定条件 -> any函数
val anyResult = list.any { it.length <= 5 }
// 判断集合中是否所有元素都满足指定条件 -> all函数
val allResult = list.all { it.length <= 5 }
println("anyResult is $anyResult, allResult is $allResult")

Lambda 表达式的语法结构：{ 参数名1：参数类型，参数名2：参数类型 -> 函数体 }

函数式API 的使用：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// 创建接口类 - Java
public interface Runnable {
  void run();
}

// 匿名类
Thread(object : Runnable {
  override fun run() {
    println("Thread is running.")
  }
}) .start()

// 精简
Thread {
  println("Thread is running.")
}.start()

// 给按钮注册点击
button.setOnClickListener {
}

空指针检查：

可空类型系统

Kotlin 默认所有的参数和变量都不可为空 .
空指针异常的检查提前到了编译时期 .
可为空的类型系统：在类名后面加上一个问号 -> ?

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 没有空指针风险
fun doStudy(study: Study) {
  study.readBooks()
  study.doHomework()
}

// 传入的参数可为空 - 类名后面加上 '?'
fun main() {
  doStudy(null)
}
// 处理空指针异常
fun doStudy(study: Study?) {
  if (study != null) {
  	study.readBooks()
  	study.doHomework()
  }
}

判空辅助工具

?. -> 当对象不为空时正常调用相应的方法，当对象为空时则什么都不做 .
?: -> 操作符左右两边都接收一个表达式，如果左边表达式的结果不为空就返回左边表达式的结果，否则返回右边的结果 .
!! -> 非空断言工具，强行通过编译 .
let 函数 -> obj.let { obj2 -> //编写具体的业务逻辑 } 调用let函数，Lambda立即执行obj对象作为参数传递到表达式中 .

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
// doStudy()优化
fun doStudy(study: Study?) {
  study?.readBooks()
  study?.doHomework()
} // 借助 ?. 去掉了if判断语句

// ?: 操作符
val c = a ?: b

// 结合 ?: 和 ?.  —— 判断文本的长度
fun getTextLength(text: String?) = text?.length ?: 0

// 非空断言工具，强行通过编译
var content: String? = "hello"

fun main() {
    if (content != null) {
        printUpperCase()
    }
}
// !!  —— 有风险
fun printUpperCase() {
    val upperCase = content!!.toUpperCase()
    println(upperCase)
}

// 结合使用 ?.操作符和 let函数来对代码进行优化
fun doStudy(study: Study?) {
  study?.let { stu ->
   	  stu.readBooks()
      stu.doHomework()
   }
}

// 优化. 只有一个参数时，不用声明参数名，使用it关键字代替.
// 定义全局变量
var study: Study? = null

fun doStudy(study: Study?) {
  study?.let {
    it.readBooks()
    it.doHomework()
  }
}  // let函数可以处理全局问题.

字符串内嵌表达式：

复制代码

1
2
"xxx, ${obj.name}"       // 字符串内嵌表达式的语法规则.

语法结构 —— ${ } —— 当表达式只有一个变量时，{ } 可以省略 .

函数的参数默认值：

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
// 给参数设定默认值
fun printParams(num: Int, str: String = "hello") {
  println("num is $num, str is $str.")
}  // 在不传值的情况下自动使用默认值

fun main() {
  printParams(123)
  printParams(str = "Kotlin", num = 123)
  // Kotlin 可以通过键值对的方式来传参. 从而实现准确地匹配参数.
}

// 第一个参数设为默认值的传参方法
fun printParams(num: Int = 100, str: String) {
  println("num is $num, str is $str.")
}

fun main() {
  printParams(str = "Kotlin")
}

最后

以上就是负责外套最近收集整理的关于入门Kotlin编程 — 《第一行代码》学习笔记 01入门 Kotlin 编程的全部内容，更多相关入门Kotlin编程内容请搜索靠谱客的其他文章。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：android
浏览次数：169 次浏览
发布日期：2023-06-16 07:39:05
本文链接：https://www.kaopuke.com/article/k-p-k_14_uzo_26_fy_14_j_22_1.html

【Kotlin】类的初始化 ① ( 成员属性 | Kotlin 自动为成员字段生成 getter 和 setter 方法 | 手动设置成员的 getter 和 setter 方法 | 计算属性 )一、Kotlin 自动为成员字段生成 getter 和 setter 方法二、手动设置成员的 getter 和 setter 方法三、计算属性

入门Kotlin编程 — 《第一行代码》学习笔记 01入门 Kotlin 编程

入门 Kotlin 编程

变量：

函数：

语句：

类与对象：

继承与构造函数：

接口：

函数的可见性修饰符：

数据类与单例类：

Lambda 编程：

集合的创建与履历：

集合的函数式 API：

函数式API 的使用：

空指针检查：

可空类型系统

判空辅助工具

字符串内嵌表达式：

函数的参数默认值：

最后

评论列表共有 0 条评论

发表评论取消回复

入门Kotlin编程 — 《第一行代码》学习笔记 01入门 Kotlin 编程

入门 Kotlin 编程

变量：

函数：

语句：

类与对象：

继承与构造函数：

接口：

函数的可见性修饰符：

数据类与单例类：

Lambda 编程：

集合的创建与履历：

集合的函数式 API：

函数式API 的使用：

空指针检查：

可空类型系统

判空辅助工具

字符串内嵌表达式：

函数的参数默认值：

最后

微信扫一扫：分享

相关文章

评论列表共有 0 条评论

发表评论 取消回复

微信扫一扫：分享

发表评论取消回复