入坑 Kotlin_kotlin1.9.20-程序员宅基地
（后续更新见原文：https://blog.iyatt.com/?p=12060）
1 前言
准备入 Android，抽空了解一下 Kotlin 语法。
2 环境
JDK 17.0.9
Kotlin 1.9.20
环境配置：https://blog.iyatt.com/?p=12040
3 编码规范
https://book.kotlincn.net/text/coding-conventions.html
这个编码规范可以作为参考，当然我个人而言还是喜欢沿用自己的方案。主要来自 C/C++ 的习惯风格，比如大括号独立成行，条件、循环必须加大括号（即使只有一个语句）。不过还是遇到一个特殊的，Kotlin 不建议使用下划线命名法，在 IDEA 中编辑的时候，只要用了就会出现波浪号。这个和目前的风格有点冲突还不可调和，我最开始学编程的时候是用驼峰法，后面感觉驼峰法太紧密了，不够清晰，之后就改用下划线法了，结果 Kotlin 不让用下划线法（看到波浪线太难受了，还是得妥协）。
4 探索
when 语句
Kotlin 中没有 switch，但是有 when，其作用类似
fun main()
{
val value = 10
when (value)
{
1 ->
{
println("结果为 1")
}
5 ->
{
println("结果为 5")
}
10 ->
{
println("结果为 10")
}
else ->
{
println("其它")
}
}
}
4.2 条件控制语句的返回值
Kotlin 中条件控制语句可以有返回值，这个在以前接触的语言里没见过。最终的返回值来自于匹配的代码块里最后一个语句，且接收返回值的时候，必须存在 else 以保证在没有匹配到的情况下有默认值。
Kotlin 没有类似 C/C++/Java（后有提到就简称 C 系） 的三元运算符，但是可以通过 if-else 做到三元运算符的效果，还可以提供更多 else if 条件的判断。Python 中的三元运算符语法上是用的 if-else，但是那是专用的，只是相当于把C系的问号冒号换成 if-else 而已，仅是三元运算符的符号，而不是改了 if 条件判断的用途。
if
fun main()
{
val value = 10
val ret = if (value == 1)
{
"匹配 1"
true
}
else if (value == 2)
{
println("匹配 2")
true
}
else
{
"其它"
false
}
println(ret)
}
when
fun main()
{
val value = 11
val ret = when (value)
{
1 ->
{
"结果为 1"
}
5 ->
{
"结果为 5"
}
10 ->
{
"结果为 10"
}
else ->
{
"其它"
}
}
println(ret)
}
4.3 循环控制
4.3.1 for
fun main()
{
val items = listOf("小红", "小明", "小张")
// for 遍历
for (item in items)
{
print("$item，")
}
println()
// for 遍历索引
for (idx in items.indices)
{
print("$idx ${
items[idx]}，")
}
println()
// forEach 遍历
items.forEach {
item ->
print("$item，")
}
println()
// forEach 遍历索引
items.forEachIndexed {
idx, item ->
print("$idx $item，")
}
println()
val map = mapOf("value1" to 1, "value2" to 2, "value3" to 3)
for ((key, value) in map)
{
print("$key:$value, ")
}
println()
map.forEach {
(key, value) ->
print("$key:$value, ")
}
println()
}
4.3.2 while
while 和 do-while 这一点和 C 系是一样的，前者是在每次循环开始前判断是否满足条件，后者是循环结束一次后判断一次条件
fun main()
{
var x = 0
var y = 10
while (x > 0)
{
print(x--)
print(" ")
}
println()
do
{
print(y--)
print(" ")
}
while (y > 10)
println()
}
4.3.3 返回和跳转
这点和 C 系差不多，return 结束当前所在函数，break 终止所在的一层循环，continue 所在循环的当此循环结束，进入所在循环的下一轮次循环。
不过 Kotlin 中有了标签的概念，标签名可以自己设置
3.3.3.1 break 标签
break 只能跳出当前所在的一层循环，使用标签后可以跳到标签所在循环的外面，也就是可以一次性可以跳出指定层数的循环
fun main()
{
for (x in 1..3)
{
myLabel@ for (y in 1..3)
{
for (z in 1..3)
{
if (z > 1)
{
break@myLabel
}
println("$x $y $z")
}
}
}
}
3.3.3.2 break 标签
continue 只能略过所在循环的当次循环，使用标签后，可以略过标签所在位置循环的当次循环，即可以略过指定层数的循环
fun main()
{
myLabel@ for (x in 1..3)
{
for (y in 1..3)
{
for (z in 1..3)
{
if (z > 1)
{
continue@myLabel
}
println("$x $y $z")
}
}
}
}
3.3.3.3 return 标签
直接使用 return 会结束当前函数，在一些情况下只是需要局部返回，并不是要整个函数的返回。
fun foo()
{
val items = listOf(10, 11, 12, 13)
items.forEach {
item ->
if (item == 11)
{
return
}
println(item)
}
println("foo 结束")
}
fun main()
{
foo()
}
使用标签限制后，这里只会在当前 Lambda 表达式返回
fun foo()
{
val items = listOf(10, 11, 12, 13)
items.forEach myLabel@{
item ->
if (item == 11)
{
return@myLabel
}
println(item)
}
println("foo 结束")
}
fun main()
{
foo()
}
这里可以简化使用隐式标签，只要标签和接受这个 Lambda 表达式的函数同名就行
fun foo()
{
val items = listOf(10, 11, 12, 13)
items.forEach {
item ->
if (item == 11)
{
return@forEach
}
println(item)
}
println("foo 结束")
}
fun main()
{
foo()
}
4.4 入口函数
Kotlin 比 Java 各方面都简洁很多，特别是入口函数。因为习惯了 C/C++，刚接触 Java 的时候太不理解把入口函数放在类中的行为，必须写个类来包起来就显得很复杂。我觉得还是像 C++ 形式的最好，支持函数式，同时支持面向对象，Kotlin 这点就类似。完全面向对象太怪异了，入口函数本身也没有作为类成员的意义，像是为了面向对象设计而强制这样搞一样，不是必要的，也可能是现阶段我没理解到它的精神吧。
另外一点 Java 要求入口函数必须有参数，即使不用也要写，这一点上 Kotlin 和 C/C++ 一样不用可以省略。
然而实际上这些工作只是 Kotlin 编译器帮我们做了
fun main()
{
println("你好，世界！")
}
将编译后的字节码文件反编译为 Java，可以看到编译器给加上了类，而用 Kotlin 写的入口函数只是作为成员函数被 Java 的入口函数调用，这样 Kotlin 中的入口函数就可以没有参数。
import kotlin.Metadata;
@Metadata(
mv = {
1, 9, 0},
k = 2,
d1 = {
"\u0000\b\n\u0000\n\u0002\u0010\u0002\n\u0000\u001a\u0006\u0010\u0000\u001a\u00020\u0001¨\u0006\u0002"},
d2 = {
"main", "", "untitled"}
)
public final class MainKt {
public static final void main() {
String var0 = "你好，世界！";
System.out.println(var0);
}
// $FF: synthetic method
public static void main(String[] var0) {
main();
}
}
但是如果给入口函数加上参数，那么此时 Kotlin 中入口函数和 Java 的入口函数就等同于一样了
fun main(args: Array<String>)
{
println(args.size)
}
import kotlin.Metadata;
import kotlin.jvm.internal.Intrinsics;
import org.jetbrains.annotations.NotNull;
@Metadata(
mv = {
1, 9, 0},
k = 2,
d1 = {
"\u0000\u0014\n\u0000\n\u0002\u0010\u0002\n\u0000\n\u0002\u0010\u0011\n\u0002\u0010\u000e\n\u0002\b\u0002\u001a\u0019\u0010\u0000\u001a\u00020\u00012\f\u0010\u0002\u001a\b\u0012\u0004\u0012\u00020\u00040\u0003¢\u0006\u0002\u0010\u0005¨\u0006\u0006"},
d2 = {
"main", "", "args", "", "", "([Ljava/lang/String;)V", "untitled"}
)
public final class MainKt {
public static final void main(@NotNull String[] args) {
Intrinsics.checkNotNullParameter(args, "args");
int var1 = args.length;
System.out.println(var1);
}
}
4.5 函數
一般函数定义格式
// 默认返回值类型为 Unit
fun foo1()
{
}
// 显式返回值类型
fun foo2(): Unit
{
}
// 参数格式
fun sum1(num1: Int, num2: Int): Int
{
return num1 + num2
}
// 单行语句简化
fun sum2(num1: Int, num2: Int): Int = num1 + num2
// 参数默认值
fun sum3(num1: Int, num2: Int = 10) = num1 + num2
fun main()
{
println(sum1(9, 1))
println(sum2(11, 9))
println(sum3(10))
println(sum3(10, 20))
}
4.5.1 infix
infix fun Int.sum(num: Int) = this + num
infix fun Float.sum(num: Int) = this + num
fun main()
{
println(4.sum(6))
println(13 sum 7)
println(6.7F sum 4)
}
4.5.2 重载
函数名相同，参数个数或类型不同
fun foo()
{
println("空参数")
}
fun foo(str: String)
{
println(str)
}
fun foo(num: Int)
{
println(num)
}
fun main()
{
foo()
foo("你好，世界！")
foo(10)
}
4.5.3 Lambda 表达式
fun main()
{
// 无参数
val printHello: () -> Unit = {
println("你好，世界！") }
printHello()
// 带参数
val showInfo: (String, Int) -> Unit = {
name, age -> println("$name $age") }
showInfo("小红", 20)
// 带类型推断
// 无显式声明参数类型，it 关键字代表参数
val greet: (String) -> Unit = {
println("你好，$it") }
greet("小强")
// 作为函数参数
// 为了提高代码可读性，一般使用不同关键词区分用途
// action：用于执行某种副作用操作或处理
// operator：用于定义运算符重载或特定的逻辑
// callback：作为回调函数的参数
// predicate：作为谓词函数的参数
// transform：作为转换函数的参数
// comparator：作为比较器的参数
// validator：作为验证函数的参数
fun funGreet(name: String, action: (String) -> Unit)
{
action(name)
}
funGreet("小明", greet)
fun calculate(x: Int, y: Int, operator: (Int, Int) -> Int): Int
{
return operator(x, y)
}
// 简化形式
val sum = {
x: Int, y: Int -> x + y }
println(sum(4, 6))
println(calculate(11, 9, sum))
}
4.5.4 可变参数
fun show(vararg items: String)
{
items.forEach {
print("$it ")
}
println("\n-------------------------")
}
fun show(s: String, vararg items: String)
{
println(s)
items.forEach {
print("$it ")
}
println("\n-------------------------")
}
fun show(s1: String, s2: String = "AAA", vararg items: String)
{
println(s1)
println(s2)
items.forEach {
print("$it ")
}
println("\n-------------------------")
}
fun main()
{
val items = arrayOf("苹果", "香蕉", "菠萝")
show(*items)
show(s = "水蜜桃", *items)
show("芒果", "柿子", items = items) // 指定参数的时候，可以不加星号（展开数组，将每个元素作为一个独立参数传递），将整个数组作为一个参数传递
show(s1 = "榴莲", items = items)
}
4.6 类
4.6.1 属性
class ClassA
{
var num1 = 0
// get 方法在取属性值时会调用
// set 方法在给属性赋值时会调用
// 下面的 get 和 set 是会默认添加的，可以省略
// field 关键字代表变量自身
var num2 = 0
get() = field
set(value)
{
field = value
}
// 可以根据需要修改取值赋值规则
var num3 = 0
get() = field + 2 // 取值结果加 2
set(value)
{
field = value - 3 // 赋值结果减 3
}
}
fun main()
{
// 创建对象
val ca = ClassA()
ca.num1 = 10
println(ca.num1)
// num3 定义的取值赋值方法是默认会添加的
// 所以最终效果和 num1 不重写取值赋值方法的一样
ca.num2 = 10
println(ca.num2)
// 演示自定义的取值赋值方法
println(ca.num3) // num3 初始值为 0，但是取值方法会 +2，所以会输出 2
ca.num3 = 10 // 赋值 10，但是赋值方法会 -3，所以实际赋值是 7
println(ca.num3) // num3 实际值是 7，但是取值方法会 +2，所以会输出 9
}
4.6.2 构造函数
class ClassA
{
// 初始化代码段
init
{
println("A 执行初始化")
}
}
class ClassB constructor(name:String, age: Int) // 主构造函数
{
init
{
print("B 执行初始化：")
println("$name $age") // 主构造函数的参数可以在初始化代码段里使用
}
// 二级构造函数
// 需要使用主构造函数的参数，可以在此基础上添加额外参数
// 调用二级构造函数，首先会执行 init 代码块，再执行二级构造函数的代码块
constructor(name: String, age: Int, height: Float) : this(name, age)
{
print("B 二级构造函数：")
println("$name $age $height")
}
}
// 主构造函数可以省略 constructor 关键字
// 如果需要使用无参构造，则主构造函数不写参数，再写一个无参的二级构造函数即可
//
// 我觉得这种方案更接近于 C++/Python/Java 的构造函数风格
// 直接不管主构造函数，统一使用二级构造函数，显得较为简洁
// 至于 init 的存在，可以方便统一初始化，如果有多个构造函数
// 且都需要执行同样初始化可以放在里面，没需要可以不写 init
class ClassC
{
init
{
println("C 执行初始化")
}
// 用二级构造函数实现无参构造的效果
constructor()
{
println("C 无参构造函数")
}
// 用二级构造函数实现有参构造函数
constructor(name: String, age: Int)
{
print("C 有参构造函数：")
println("$name $age")
}
}
fun main()
{
val ca = ClassA()
val cb1 = ClassB("小明", 20) // 主构造函数
val cb2 = ClassB("小张", 19, 1.77F) // 二级构造函数
val cc1 = ClassC() // 无参构造函数
val cc2 = ClassC("小强", 22)
}
4.6.3 修饰符
4.6.3.1 访问权限修饰符
- public：默认的访问权限修饰符，如果没有显式指定访问权限修饰符，那么默认为public。public修饰的成员在任何地方都可见。
- private：private修饰的成员只在定义它的类中可见，其他类无法访问。
- protected：protected修饰的成员在定义它的类中和它的子类中可见，其他类无法访问。
- internal：internal修饰的成员在同一个模块中可见。模块是指编译在一起的一组Kotlin文件。
C++ 中只有 public、private 和 protected，Java 中没有 internal，但是有一个 default，default 在同一个包里可见，也是不使用修饰符时默认的修饰符，而 Kotlin 默认是 public，只不过感觉 Java 的 default 和 Kotlin 的 internal 实际意义相近。
4.6.3.2 类属性修饰符
abstract // 抽象类
final // 类不可继承，默认属性
enum // 枚举类
open // 类可继承
annotation // 注解类
智能推荐
分布式光纤传感器的全球与中国市场2022-2028年：技术、参与者、趋势、市场规模及占有率研究报告_预计2026年中国分布式传感器市场规模有多大-程序员宅基地
文章浏览阅读3.2k次。本文研究全球与中国市场分布式光纤传感器的发展现状及未来发展趋势，分别从生产和消费的角度分析分布式光纤传感器的主要生产地区、主要消费地区以及主要的生产商。重点分析全球与中国市场的主要厂商产品特点、产品规格、不同规格产品的价格、产量、产值及全球和中国市场主要生产商的市场份额。主要生产商包括：FISO TechnologiesBrugg KabelSensor HighwayOmnisensAFL GlobalQinetiQ GroupLockheed MartinOSENSA Innovati_预计2026年中国分布式传感器市场规模有多大
07_08 常用组合逻辑电路结构——为IC设计的延时估计铺垫_基4布斯算法代码-程序员宅基地
文章浏览阅读1.1k次，点赞2次，收藏12次。常用组合逻辑电路结构——为IC设计的延时估计铺垫学习目的：估计模块间的delay，确保写的代码的timing 综合能给到多少HZ，以满足需求！_基4布斯算法代码
OpenAI Manager助手（基于SpringBoot和Vue）_chatgpt网页版-程序员宅基地
文章浏览阅读3.3k次，点赞3次，收藏5次。OpenAI Manager助手（基于SpringBoot和Vue）_chatgpt网页版
关于美国计算机奥赛USACO，你想知道的都在这_usaco可以多次提交吗-程序员宅基地
文章浏览阅读2.2k次。USACO自1992年举办，到目前为止已经举办了27届，目的是为了帮助美国信息学国家队选拔IOI的队员，目前逐渐发展为全球热门的线上赛事，成为美国大学申请条件下，含金量相当高的官方竞赛。USACO的比赛成绩可以助力计算机专业留学，越来越多的学生进入了康奈尔，麻省理工，普林斯顿，哈佛和耶鲁等大学，这些同学的共同点是他们都参加了美国计算机科学竞赛（USACO)，并且取得过非常好的成绩。适合参赛人群USACO适合国内在读学生有意向申请美国大学的或者想锻炼自己编程能力的同学，高三学生也可以参加12月的第_usaco可以多次提交吗
MySQL存储过程和自定义函数_mysql自定义函数和存储过程-程序员宅基地
文章浏览阅读394次。1.1 存储程序1.2 创建存储过程1.3 创建自定义函数1.3.1 示例1.4 自定义函数和存储过程的区别1.5 变量的使用1.6 定义条件和处理程序1.6.1 定义条件1.6.1.1 示例1.6.2 定义处理程序1.6.2.1 示例1.7 光标的使用1.7.1 声明光标1.7.2 打开光标1.7.3 使用光标1.7.4 关闭光标1.8 流程控制的使用1.8.1 IF语句1.8.2 CASE语句1.8.3 LOOP语句1.8.4 LEAVE语句1.8.5 ITERATE语句1.8.6 REPEAT语句。_mysql自定义函数和存储过程
半导体基础知识与PN结_本征半导体电流为0-程序员宅基地
文章浏览阅读188次。半导体二极管——集成电路最小组成单元。_本征半导体电流为0
随便推点
常用机器学习的模型和算法_常见机器学习模型算法整理和对应超参数表格整理-程序员宅基地
文章浏览阅读102次。本篇介绍了常用机器学习的模型和算法_常见机器学习模型算法整理和对应超参数表格整理
【Unity3d Shader】水面和岩浆效果_unity 岩浆shader-程序员宅基地
文章浏览阅读2.8k次，点赞3次，收藏18次。游戏水面特效实现方式太多。咱们这边介绍的是一最简单的UV动画（无顶点位移），整个mesh由4个顶点构成。实现了水面效果（左图），不动代码稍微修改下参数和贴图可以实现岩浆效果（右图）。有要思路是1，uv按时间去做正弦波移动2，在1的基础上加个凹凸图混合uv3，在1、2的基础上加个水流方向4，加上对雾效的支持，如没必要请自行删除雾效代码(把包含fog的几行代码删除)S..._unity 岩浆shader
广义线性模型——Logistic回归模型（1）_广义线性回归模型-程序员宅基地
文章浏览阅读5k次。广义线性模型是线性模型的扩展，它通过连接函数建立响应变量的数学期望值与线性组合的预测变量之间的关系。广义线性模型拟合的形式为：其中g(μY)是条件均值的函数（称为连接函数）。另外，你可放松Y为正态分布的假设，改为Y 服从指数分布族中的一种分布即可。设定好连接函数和概率分布后，便可以通过最大似然估计的多次迭代推导出各参数值。在大部分情况下，线性模型就可以通过一系列连续型或类别型预测变量来预测正态分布的响应变量的工作。但是，有时候我们要进行非正态因变量的分析，例如：（1）类别型.._广义线性回归模型
HTML+CSS大作业 环境网页设计与实现(垃圾分类) web前端开发技术 web课程设计 网页规划与设计_垃圾分类网页设计目标怎么写-程序员宅基地
文章浏览阅读69次。环境保护、 保护地球、 校园环保、垃圾分类、绿色家园、等网站的设计与制作。 总结了一些学生网页制作的经验：一般的网页需要融入以下知识点：div+css布局、浮动、定位、高级css、表格、表单及验证、js轮播图、音频 视频 Flash的应用、ul li、下拉导航栏、鼠标划过效果等知识点，网页的风格主题也很全面：如爱好、风景、校园、美食、动漫、游戏、咖啡、音乐、家乡、电影、名人、商城以及个人主页等主题，学生、新手可参考下方页面的布局和设计和HTML源码（有用点赞△） 一套A+的网_垃圾分类网页设计目标怎么写
C# .Net 发布后,把dll全部放在一个文件夹中,让软件目录更整洁_.net dll 全局目录-程序员宅基地
文章浏览阅读614次，点赞7次，收藏11次。之前找到一个修改 exe 中 DLL地址 的方法, 不太好使,虽然能正确启动, 但无法改变 exe 的工作目录,这就影响了.Net 中很多获取 exe 执行目录来拼接的地址 ( 相对路径 ),比如 wwwroot 和 代码中相对目录还有一些复制到目录的普通文件 等等,它们的地址都会指向原来 exe 的目录, 而不是自定义的 “lib” 目录,根本原因就是没有修改 exe 的工作目录这次来搞一个启动程序,把 .net 的所有东西都放在一个文件夹,在文件夹同级的目录制作一个 exe._.net dll 全局目录
BRIEF特征点描述算法_breif description calculation 特征点-程序员宅基地
文章浏览阅读1.5k次。本文为转载，原博客地址：http://blog.csdn.net/hujingshuang/article/details/46910259简介 BRIEF是2010年的一篇名为《BRIEF:Binary Robust Independent Elementary Features》的文章中提出，BRIEF是对已检测到的特征点进行描述，它是一种二进制编码的描述子，摈弃了利用区域灰度..._breif description calculation 特征点