kotlin学习（2）-程序结构

（1）常量与变量

package 程序结构



val FINAL_HELLO_WORLD:String="HelloWorld"//运行时常量，与Java的final还有区别

const val ADSDS:String="dsadsda"//编译期常量，与Java中final时一样的



var helloWorld:String="HelloWorld"

val FINAL_HELLO_CHINA="HelloStringl"


fun main(args: Array<String>) {
    helloWorld="HelloChina"
    println(FINAL_HELLO_CHINA)

}

（2）函数

kotlin中函数可以说是核心，kotlin之所以说比java方便使用，其实就是在于他的函数机制，目前的编程风格慢慢统一到了响应式编程，kotlin有大量的高阶函数，结合lambda表达式可以将很多复杂的代码使用一行搞定，带来代码简洁性的同时，也给程序员编程带来更多的挑战，我们需要记住更多的api和函数使用，如果原生的函数库还不能够满足你，kotlin还提供了自定义扩展函数，可以方便的去实现代码复用，函数这一块很大，这篇只能简单的介绍一下：

package 程序结构

fun main(args: Array<String>) {
//    var args1=args[0].toInt()
//    var args2=args[1].toInt()
//    println("$args1 + $args2 = ${sum(args1,args2)}")
    sum(1,2,3,4,1)
}

fun sum(args1:Int,args2:Int): Int {
    return args1+args2
}

fun sum(x: String, y: String)=x+y

//可变参数类型
fun sum(vararg x: Int){
    x.forEach (::print)
}

（3）lambda表达式

lambda表达式出来也有段时间了，但是其实一直是不温不火的，爱他的人爱不释手，不屑的人碰都懒得碰，在我看来吧，lambda表达式确实是方便，但是感觉不适应，代码有时候简洁的让你感到可怕，不过，感觉这是以后的潮流，谁让乔布斯曾经说过，减少bug的最好方式就是减少代码量呢？

package 程序结构


fun main(args: Array<String>) {
    println(sum(1,3))
    args.forEach foreach@{
        if (it=="5") return@foreach
        println(it)
    }
}
val sum={arg1:Int,arg2:Int ->
    println("$arg1 + $arg2 = ${arg1+arg2}")
    arg1+arg2
}

val minus={arg1:Int,arg2:Int -> print("$arg1  -  $arg2=${arg1 - arg2}")}
val printHello={ print("Hello")}

lambda表达式分为三个部分：以中间的 ->为基准，左边是参数，右边是函数主体，比如说在java中的这么一段代码：

  public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("lambda");
            }
        });
    }

如果你使用的是idea编译期的话，他会提示你使用lambda表达式进行代码简化，简化后的代码就是这样：

public static void main(String[] args) {
        new Thread(() -> System.out.println("lambda"));
    }

左边参数，没有参数，所以是（），右边函数主体，也就是打印语句，这就是lambda，这是java，如果在kotlin中，那就会想我刚刚说的，简洁的让你感到可怕：

Thread{ println("dsadasda")}

是的，没错，就是这样，莫慌莫慌，一步步来，他本来应该这样写：

Thread(object :Runnable{
        override fun run() {
            
        }
    })

然后变成这样：

 Thread(Runnable { println("dsadasda") })

再然后：

Thread(){ -> println("dasda")}

最后就变成刚开始的那样；

（4）运算符：

kotlin运算符和java中运算符没有什么大区别，但是有一点很重要，kotlin支持运算符重载，比如说，如果要实现虚数的加减，在kotlin中，你可以这样写：

class Complex(var real:Double, var viryual:Double){
    /**
     * '+' 运算符重载
     */
    operator fun plus(other: Complex):Complex{
        return Complex(real+other.real,viryual+other.viryual)
    }

    /**
     * '()'运算符重载
     */
    operator fun invoke():Double{
        return Math.hypot(real,viryual)
    }

    override fun toString(): String {
        return "$real + ${viryual}i"
    }

}

在这里实现+运算符的重载，使他具有虚数相加的功能；然后你可以这么调用

fun main(args: Array<String>) {
    val c1=Complex(3.0,4.0)
    val c2=Complex(2.0,7.5)

    println(c1())

    println(c1+c2)
}

（5）表达式，控制语句

《1》分支表达式由java的switch变为when

 val a=when{
        args.isNotEmpty()&&args[0]=="1"-> DEBUG
        else -> USER
    }

《2》中缀表达式

class Book{
    //infix 中缀表达式
    infix fun on(any:Any):Boolean{
        return false
    }
}

class Desk
fun main(args: Array<String>) {
    if (!(Book() on Desk())){

        println("sdafasfsadas")
    }
}

《3》循环语句

package 程序结构

fun main(args: Array<String>) {
    for (arg in args){
        println(arg)
    }


    for ((index,value)in args.withIndex()){
        println("$index -> $value")
    }

    while (args[0].isNotEmpty()){
        println(args)
    }
}

《4》异常捕获，try catch

package 程序结构

fun main(args: Array<String>) {
    println(message = try {
        args[0]+args[1]
    }catch (e:Exception){
        "0"
    })
}

（6）小案例：计算器

package 程序结构

fun main(args: Array<String>) {
    while (true) {
        try {
            println("请输入算式例如：3 + 4")
            val input = readLine() ?: break
            val splits = input.trim().split(" ")
            if (splits.size<3){
                throw IllegalArgumentException("参数个数错误")
            }
            val arg1 = splits[0].toDouble()
            val op = splits[1]
            val arg2 = splits[2].toDouble()
            val opC = Operator(op)
            println("$arg1 $op $arg2=${opC.apply(arg1, arg2)}")

        }catch (e:NumberFormatException){
            println("你确定输入的是数字么？")
        }catch (e:IllegalArgumentException){
            println("您确定输入的是三个参数么？（未使用空格分隔）")
        }catch (e:Exception){
            println("未知异常！"+e.message)
        }
        print("再来一次？【Y】")
        val cmd = readLine()
        if (cmd == null || cmd.toLowerCase() != "y") {
            break
        }
    }

}

class Operator(op: String) {
    val opFun: (left: Double, right: Double) -> Double

    init {
        opFun = when (op) {
            "+" -> { l, r -> l + r }
            "-" -> { l, r -> l - r }
            "*" -> { l, r -> l * r }
            "/" -> { l, r -> l / r }
            else -> {
                throw UnsupportedOperationException(op)
            }
        }
    }

    fun apply(l: Double, r: Double): Double {
        return opFun(l, r)
    }
}