1,常量與變量(val,val)
只讀變量
- 使用val表示
- 類似Java中final
- 不可重復進行賦值,只能被賦值一次
- 可分為運行時常量和編譯器常量
運行時常量:編譯器在編譯時并不能確切的知道它的值是什么;編譯器在引用到該常量時使用的是
編譯器常量:編譯器在編譯時已經知道該常量的值,并且在引用到改常量的地方直接賦值為該常量的值,以提高執(zhí)行效率
//運行時常量
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"http://編譯器推導出是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()等方法就可以實現(xiàn)對象的操作
定義形式 :
1,類的外部 operator fun <類名>.plus(參數(shù)):<返回值類型>
2,類的內部 operator fun plus(參數(shù)):<返回值類型>
<2>中綴表達式
var book = Book()
var desk = Desk()
book on desk
---
class Book
class Desk
infix fun Book.on(other: Desk) {
}
<4>,Lambda表達式
- Kotlin中Lambda表達式就是匿名函數(shù)的簡寫
- 和Java中不同的是,Java的Lambda表達式更像是一種接口形式的語法糖,所有Java中的Lanbda表達式都需要一個接收類型,該接受類型,必須是一個接口并只有一個方法
- Lambda表達式返回值的類型就是表達式最后一句的返回類型
具體寫法
var func = fun(i: Int) {
println("----$i-----")
}
var fund = { i: Int ->
println("----$i-----")
}
//當一個函數(shù)只有一個參數(shù)沒寫時默認就是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 }
}
