1,常量与变量(val,val)

只读变量

• 使用val表示
• 类似Java中final
• 不可重复进行赋值,只能被赋值一次
• 可分为运行时常量和编译器常量

运行时常量:编译器在编译时并不能确切的知道它的值是什么;编译器在引用到该常量时使用的是

编译器常量:编译器在编译时已经知道该常量的值,并且在引用到改常量的地方直接赋值为该常量的值,以提高执行效率

//运行时常量
val FINAL_STRING: String = "HelloWord"
//编译器常量需要加const修饰
const val FINAL_STRING_01: String = "HelloWord"
//等同于Java中 public static final String FINAL_STRING_01 = "HelloWord";

关于const的限制

• 只能定义在全局范围内
• 只能修饰基本类型(String也可以)
• 必须立即用字面量进行初始化

同时有一点需要注意的是:val 只读变量作为类的属性值时可以为其复写一个getter,这样每次读取的值就是不相同的

class Person {
    val age: Int
        get() {
            return (Math.random() * 10).toInt()
        }
}

fun main() {
    val person = Person()
    for (i in 1..5) {
        println(person.age)
    }
}

变量

• var 可被重复赋值

var str: String = "HelloWord"
fun main(args: Array<String>) {
    str = "HiBaby"
}

类型推导

• 编译器可以推导出的类型

fun main(args: Array<String>) {
    //类型推导
    var intA = 1//编译器推导出是Int
    var StringA = "AAAA"//编译器推导出是String
    var StringB = "BBBB" + 6//编译器推导出是String
}

2,分支表达式

<1> if ..else..

• Kotlin中if else 是表达式,而java中语句

    var c = 0
    var a = 2
    if (a == 2) {
        c = 3
    } else {
        c = 4
    }
//两者含义相同,和Java中三元表达式相同
    c = if (a == 2) 3 else 4

<2> when

• when 对应Java中swith语句

 when (a) {
        2 -> c = 3
        3 -> c = 4
        else -> c = 5
    }
    c = when (a) {
        2 -> 3
        3 -> 4
        else -> 5
    }

也可以将条件写在when语句内部

 var d: Any = "String"

    c = when {
        d is String -> d.length
        d == 1 -> 2
        else -> 5
    }

<3> try ..catch

• 也可以作为表达式

 try {
        c = a / b
    } catch (e: Exception) {
        c = 0
    }

    c = try {
        a / b
    } catch (e: Exception) {
        0
    }

3,运算符和中缀表达式

<1>运算符

• Kotlin中支持运算符重载
• 运算符重载的范围仅限于官方指定的符号

常见运算符

• == 与 equals

"Hello".equals("Word")
"Hello" == "Word"

• +与 plus

2 + 3
2.plus(3)

• in 与 contains

    var list = listOf(1, 2, 3)
    2 in list
    list.contains(2)

• [] 与 get
• [] 与 set

var map = mutableMapOf(
        "h" to 1,
        "e" to 2
    )
    var a = map["h"]
    map["h"] = 3

• 大于号和comPareTo

    1>2
    1.compareTo(2)>0

• () 与invoke

    var tt = fun(arg1: Int, arg2: Int): Int {
        return arg1 + arg2
    }
    tt(1,2)
    tt.invoke(1,2)

也就是什么意思呢.比如我定义了一个类 我想让这个的对象,能够相加和相减 或者>等等,我只要重载了他的plus(),minus(),compareTo()等方法就可以实现对象的操作

定义形式 :
1,类的外部 operator fun <类名>.plus(参数):<返回值类型>
2,类的内部 operator fun plus(参数):<返回值类型>

<2>中缀表达式

var book = Book()
var desk = Desk()
book on desk
---
class Book
class Desk
infix fun Book.on(other: Desk) {

}

<4>,Lambda表达式

• Kotlin中Lambda表达式就是匿名函数的简写
• 和Java中不同的是,Java的Lambda表达式更像是一种接口形式的语法糖,所有Java中的Lanbda表达式都需要一个接收类型,该接受类型,必须是一个接口并只有一个方法
• Lambda表达式返回值的类型就是表达式最后一句的返回类型

具体写法

var func = fun(i: Int) {
    println("----$i-----")
}

var fund = { i: Int ->
    println("----$i-----")
}
//当一个函数只有一个参数没写时默认就是it
var fune: Function1<Int, Unit> = {
    println("----$it-----")
}
var funf = { it: Int ->
    println("----$it-----")
}

调用

    func(1)
    func.invoke(1)
    fund(2)
    fune(3)
    funf(4)

小案例:给字符串增加四则运算

fun main() {
    println("WJF" * 2)
    println("HelloWorld" - 'l')
    println("HelloWorld" / 'l')
}


operator fun String.minus(char: Char): String =
    if (this.contains(char)) {
        this.replace("$char", "", false)
    } else {
        this
    }


operator fun String.times(times: Int): String {
//    var result = this
//    for (i in 1..times) {
//        result = result.plus(this)
//    }
//    return result
    return (1..times).joinToString(""){ this }
}

operator fun String.div(right: Any): Int {
//    return if (char in this) {
//        var count = 0
//        this.forEach {
//            if (it == char) {
//                count++
//            }
//        }
//        count
//    } else {
//        0
//    }
    val toString = right.toString()
    return this
        .windowed(toString.length, 1) { it == toString }
        .count { it }
}