BNB丨BSC链项目系统开发DAPP模式分析解析方案

package my.demo
import java.awt.Rectangle
import java.util.*

// --- 单行注释---
/* --- 多行注释 ---*/

// 带有两个Int参数、返回Int的函数：
fun sum(a:Int, b:Int):Int{
    return a + b  // 返回的是Int
}

// 主函数入口，程序执行：定义函数
fun main(args:Array<String>){
    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<String>){
    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<String>){
    print_sum(-1, 8)
}

 //  Unit 返回类型可以省略：
fun printSum(a:Int, b:Int){
    println("sum of $a and $b is ${a + b}")
}

fun main(args: Array<String>){
    printSum(-1, 8)
}

// 一次赋值--只读--局部变量
fun main(args: Array<String>){
    val a: Int = 1 // 立即赋值
    val b = 2  // 自动推断出 ‘Int’ 类型
    val c:Int  // 如果没有初始值类型不能省略
    c = 3
    println("a = $a, b = $b, c = $c")
}

// 可变变量
fun main(args: Array<String>){
    var x = 5  // 自动推断出“Int”类型
    x += 1
    println("x = $x")
}

// 顶层变量：
val PI = 3.14
var x = 0
fun incrementX(){
    x += 1
}

fun main(args: Array<String>){
    println("x = $x, PI = $PI")
    incrementX()
    println("incrementX()")
    println("x = $x, PI = $PI")
}
/*变量还可以作为属性和字段使用 */

fun main(args:Array<String>){
    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<String>){
    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<String>){
    println("maxOf of 0 and 42 is ${maxOf(0, 42)}")
}

// 当变量的值可以为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<String>){
    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<String>){
    fun printLength(obj: Any){
        println("'$obj' string length is ${getStringLength(obj) ?: " ... err, not a string"}")
    }
    printLength("Incomprehensibilities")
    printLength(1000)
    printLength(listOf(Any()))
}

fun main(args:Array<String>){
    val items = listOf("apple", "banana", "kiwi")
    for (item in items){
        println(item)
    }
}

fun main(args: Array<String>){
    val items = listOf("apple", "banana", "kiwi")
    var index = 0
    while (index < items.size){
        println("item at $index is ${items[index]}")
        index++
    }
}

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<String>){
    println(describe(1))
    println(describe("Hello"))
    println(describe(1000L))
    println(describe(2))
    println(describe("other"))
}

// 使用 in 运算符来检测某个数字是否在指定区间内：
fun main(args:Array<String>){
    val x = 10
    val y = 9
    if (x in 1..y+1){
        println("fits in range")
    }
}

// 检测某个数字是否在指定区间外：
fun main(args:Array<String>){
    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<String>){
    for (x in 1..5){
        print(x)
    }
}

// 数列迭代
fun main(args:Array<String>){
    for (x in 2..10 step 2){
        print(x)
    }
}