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

98 阅读 0 评论 65 点赞

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

概述

入门 Kotlin 编程

/**
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)
}

setOf( ) / mutableSetOf( ) 函数：创建 Set 集合，底层使用 hash 映射方式，无法保证有序.

val set = setOf("Apple", "Banana", "Orange", "Pear", "Grape")
for (fruit in set){
  println(fruit)
}

Map 集合：键值对式. ->

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")

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

函数式API 的使用：

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

// 没有空指针风险
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对象作为参数传递到表达式中 .

// 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函数可以处理全局问题.

字符串内嵌表达式：

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

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

函数的参数默认值：

// 给参数设定默认值
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")
}