作为一种可能的Web3.0底层技术，区块链以去中心化、不可篡改、可溯源等特点，构建起数字经济时代的全新信任体系。
从技术角度分析，区块链让数字资产价值流转的每一个节点都公开透明、有迹可循且不可篡改，这将会让Web3.0时代的一切交易变得更加真实可信。
定义包的规范应位于源文件的顶部
package my.demo
import java.awt.Rectangle
import java.util.*
复制
Kotlin 中的注释
// --- 单行注释---
/ --- 多行注释 ---/
复制
定义函数
// 带有两个Int参数、返回Int的函数：
fun sum(a:Int, b:Int):Int{
return a + b // 返回的是Int}
// 主函数入口，程序执行：定义函数
fun main(args:Array){
print("sum of 3 and 5 is ") // print 打印不换行
println(sum(3,5)) // println 打印换行}
复制
// 将表达式作为函数体、返回值类型自动推断的函数：
fun sum(a:Int, b:Int) = a + b
fun main(args:Array){
println("sum of 19 and 23 is ${sum(19, 23)}") // ${} 占位}
复制
// 函数返回无意义的值
fun print_sum(a:Int, b:Int): Unit{
println("sum of $a and $b is ${a + b}") // $ 占位}
fun main (args: Array){
print_sum(-1, 8)}
复制
// Unit 返回类型可以省略：
fun printSum(a:Int, b:Int){
println("sum of $a and $b is ${a + b}")}
fun main(args: Array){
printSum(-1, 8)}
复制
定义变量
// 一次赋值--只读--局部变量
fun main(args: Array){
val a: Int = 1 // 立即赋值
val b = 2 // 自动推断出 ‘Int’ 类型
val c:Int // 如果没有初始值类型不能省略
c = 3
println("a = $a, b = $b, c = $c")}
// 可变变量
fun main(args: Array){
var x = 5 // 自动推断出“Int”类型
x += 1
println("x = $x")}
复制
// 顶层变量：
val PI = 3.14
var x = 0
fun incrementX(){
x += 1}
fun main(args: Array){
println("x = $x, PI = $PI")
incrementX()
println("incrementX()")
println("x = $x, PI = $PI")}
/变量还可以作为属性和字段使用 /
复制
使用字符串模板
fun main(args:Array){
var a = 1
// 模板中的简单名称
val s1 = "a is $a"
a = 2
// 模板中的任意表达式：
val s2 = "${s1.replace("is", "was")}, but now is $a"
println(s2)}
复制
使用条件表达式
fun maxOf(a:Int, b:Int):Int{
return if (a > b){
a
}else{
b
}}
fun main(args:Array){
println("max of 0 and 42 is ${maxOf(0, 42)}")}
复制
// 使用if作为表达式：
fun moxOf(a:Int, b:Int) = if (a > b) a else b
fun main(args: Array){
println("maxOf of 0 and 42 is ${maxOf(0, 42)}")}
复制
使用可空值及null检测
// 当变量的值可以为null的时候，必须在声明处的类型后添加? 用来标识该应用可为空。
fun parseInt(str:String):Int?{
// ......}
复制
// 使用返回可空值的函数
fun parseInt(string: String):Int?{
return string.toIntOrNull()
fun printProduct(arg1:String, arg2:String){
val x = parseInt(arg1)
val y = parseInt(arg2)
// 直接使用 x * y 会导致编译器错误，因为他们可能为null
if (x == null) {
println("Wrong number format in arg1:'$arg1'")
return
}
if (y == null){
println("Wrong number format in arg2: '$arg2'")
return
}}
// 在空检测后，x 和 y自动转换为非空值（non-nullable）
println(x * y)}
fun main(args:Array){
printProduct("6", "7")
printProduct("a", "7")
printProduct("6", "b")
printProduct("a", "b")}
复制
使用类型检测及自动类型转换
/* is 运算符检测一个表达式是否某类型的一个实例。
- 如果一个不可变的局部变量或属性已经判断出为某类型
- 那么检测后的分支中可以直接当作该类型使用，无需显示转换*/
fun getStringLength(obj: Any):Int?{
if (obj is String) {
// 'obj'在条件分支内自动转换成'String'
return obj.length
}
// 在离开类型检测分支后，'obj'仍然是'Any'类型
return null}
fun main(args:Array){
fun printLength(obj: Any){
println("'$obj' string length is ${getStringLength(obj) ?: " ... err, not a string"}")
}
printLength("Incomprehensibilities")
printLength(1000)
printLength(listOf(Any()))}
复制
使用for循环
fun main(args:Array){
val items = listOf("apple", "banana", "kiwi")
for (item in items){
println(item)
}}
复制
使用while表达式
fun main(args: Array){
val items = listOf("apple", "banana", "kiwi")
var index = 0
while (index < items.size){
println("item at $index is ${items[index]}")
index++
}}
复制
使用when表达式
fun describe(obj:Any):String =
when(obj){
1 -> "One"
"Hello" -> "Greeting"
is Long -> "Long"
!is String -> "Not a string"
else -> "Unknown"
}
fun main(args:Array){
println(describe(1))
println(describe("Hello"))
println(describe(1000L))
println(describe(2))
println(describe("other"))}
复制
使用区间range
// 使用 in 运算符来检测某个数字是否在指定区间内：
fun main(args:Array){
val x = 10
val y = 9
if (x in 1..y+1){
println("fits in range")
}}
复制
// 检测某个数字是否在指定区间外：
fun main(args:Array){
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")
}}
复制
// 区间迭代
fun main(args:Array){
for (x in 1..5){
print(x)
}}
复制
// 数列迭代
fun main(args:Array){
for (x in 2..10 step 2){
print(x)
}}
