Kotlin基础学习第5章—表达式

一丶常量与变量

package com.wangrui.kotlin.chapter01

    /*常量*/
//1、只能定义在全局范围
//2、只能修饰基本类型
//3、必须立即用字面量初始化
const val b = 3


fun main(){

    /*变量*/
    var a = 2
    a = 3

    /*只读变量*/
    val b:Int

    /*常量引用*/    //  了解即可
    //Person(18,"Bennyhuo") 堆上创建对象
    val person = Person(18,"Bennyhuo")
    //对象改变但饮用没变
    person.age = 19

    /*编译期和运行时常量*/
    //编译时即可确定常量的值，并用只替换掉用处
    const val b = 3
    //运行时才能确定值，调用处通过引用获取值
    val c:Int


}


// val作为只读变量原因举例：

class X{
    val b:Int
        //此时每次返回b的值都是不一样的，random —— 随机数
    get() {
        return (Math.random()*100).toInt()
    }

}

二丶分支表达式

package com.wangrui.kotlin.chapter02

import java.lang.Exception

fun main(){
    /*表达式一：if...else*/
    //1、跟Java语法一样
    //2、kotlin里没有三目表达式



    /*表达式二：when...*/
    //1、与Java switch 意思一样
    //Java语法：
    switch(a){
        case 0: c=5;break;
        case 1: c=100;break
        default: c=20;
    }
    //kotlin语法一：
    when(a){
        0 -> c = 5
        1 -> c = 100
        else -> c = 20
    }
    /*    kotlin语法二：*/
        c = when(a){
        0 -> 5
        1 -> 100
        else -> 20
    }

    //when...其他用法
    //表示先接收用户输入的值，并且赋给input再进行开关语句
    c = when(val input = readLine()){
        null -> 0
        else ->input.length
    }



    /*表达式三：try...catch*/
    //kotlin 写法一：
    try {
        c = a/b
    }catch (e:Exception){
        e.printStackTrace()
        c = 0
    }
    //kotlin 写法二：
    c = try {
        a/b
    }catch (e:Exception){
        e.printStackTrace()
        0
    }

}

三丶运算符与中缀表达式

package com.wangrui.kotlin.chapter03

fun main(){
    /*运算符*/
//1、== 与 equals 等价
//2、+ 与 plus 等价
//3、in 与 contarins 等价
//4、[] 与 get、set等价
举例一：
        val value = map["Hello"]
                等价于
        val value = map.get("Hello")*/

举例二：
        map["Hello"] = 4
        map.set("Hello",4)*/
//5、> 与 compareTo 等价
//6、() 与 invoke

    /*中缀表达式 '.xx'*/
    //1、 to 等价于 .to
//    举例：
//        2to3    等价于 2.to(3)
    //2、 .on
}

四丶Lambda 表达式

package com.wangrui.kotlin.chapter04

fun main(){
    /*匿名函数的传递*/
    val func = fun(){
        println("Hello")
    }
    /*匿名函数的类型*/
    val func:()->Unit = fun(){
        println("Hello")
    }



    /*Lambda 表达式的类型*/
    val lambda:()->Unit = {
        println("Hello")
    }


    Java的Lambda 使用代码：
//  定义接口，并且只有一个方法
    interface Function1{
        void invoke(int p)
    }
    //使用Lambda
    Function1 f1 = (p) -> {
        System.out.println(p);
    }

    /*Lambda 表达式的类型*/
    //写法一：
    val f1:(Int)->Unit = {p:Int ->
        println(p)
    }
    //写法二：
    //原理：表达式参数类型从表达式类型推断而来
    val f1:Function<Int,Unit> = {p ->
        println(p)
    }
    //写法三：
    //原理：表达式的类型从声明推断而来
    val v1 = {p:Int ->
        println(p)
    }


    //举例：
    val v1 = {p:Int ->
        println(p)
        "Hello"    //表达式的最后一行为返回值
    }



    /*Lambda 表达式的参数省略形式*/
    val f1:Function<Int,Unit> = {
        //如果Lambda表达式只有一个参数，参数名可默认为it
        println(it)
    }

}

五丶案例：为 Person 实现 equals 和 hashCode

六丶案例：为String 实现四则运算

七丶本章小结