數據類型
Kotlin跟 java 相同，基本數據類型有八種 boolean，char，int，short，long，float，double，byte
| 類型 | 位寬 | 最小值 | 最大值 |
|---|---|---|---|
| Short | 16 | -32768 | 32767 |
| Int | 32 | (-2^31) | (2^31-1) |
| Long | 64 | (-2^63) | (2^63-1) |
| Byte | 8 | -128 | 127 |
| Float | 32 | - | - |
| Double | 64 | - | - |
根據數據類型，結合代碼看下
// 如果變量是數字，kotlin 的數據類型默認就是 Int 類型，如果超出了 Int 的取值范圍，編譯器就會自動推斷為 Long 類型
// 根據 number 的取值范圍，推斷出 number 為 Int 類型
val number = 100
// 顯示聲明為 Int 類型
val intNumber: Int = 100
// 由於 number2 的取值范圍超出 Int 的范圍，編譯器推斷該變量升級成 long 類型
val number2 = 9999999999
// 顯示聲明為 long 類型
val longNumber: Long = 100L
// Kotlin 對小數的默認推斷是 Double 類型（如同Java）
val number3 = 3.1415926535898
// 顯示聲明為 Double 類型
val doubleNumber: Double = 3.1415926535898
// 如需要聲明 Float 類型，則只需在變量后面添加 F/f 即可
val number4 = 3.1415926535898f
// 顯示聲明為 Float 類型
// val floatNumber:Float = 3.1415926535898 // 這邊編譯會報錯，原因如下
// 特別留意的是，kotlin 的 Float 類型十進制位數規定了6位，所以如果超出了6位，則會出現精度丟失的情況
println("number4: $number4") // 輸出結果為：number4: 3.1415927
// 多說一句，Kotlin 與 Java 有一點不同的是，Kotlin 是不會像 Java 進行變量的隱形轉換的，舉個栗子，
// 你如果聲明了 Double 變量，就只能接受 Double 類型的值，不能接收 Float 、 Int或者其他基本類型。
// 字符串類型（引用類型）
val str = "hello world"
// 顯示聲明為 String 類型
val strString: String = "hello world"
// 可通過下標值來取
val str1 = str[4] // 這里取出的值是 o ，並且是 char 類型
// 關於 Kotlin 的輸出方式可以通過模板模式來輸出，如下
println("str is $str1") // str is o
println("str length is ${str.length}") // str length is 11
// 其他類型就不一一演示了，跟上面演示的都差不多了。
Kotlin 是通過調用 to+基本類型來實現類型之間的強制轉換
| 類型 | 強轉方法 |
|---|---|
| Byte | toByte() |
| Char | toChar() |
| Short | toShort() |
| Int | toInt() |
| Long | toLong() |
| Float | toFloat() |
| Double | toDouble() |
| Boolean | - |
擴展: 由於不同的表示方式，較小類型並不是較大類型的子類型，較小的類型不能隱式轉換為較大的類型。 這意味着在不進行顯式轉換的情況下我們不能把 Byte 型值賦給一個 Int 變量。(菜鳥教程)例如：val b: Byte = 1 // OK，字面值是靜態檢測的 val i； Int = b // 錯誤 val i: Int = b.toInt() // OK
數組
數組是一種初始化時指定容器大小，不可以動態調整其大小的容器。kotlin為數組增加了一個Array類，為元素是基本類型的數組增加了IntArray、Double類等其他基本類型。
下面介紹Kotlin常用的數據創建方式
// 1.使用arrayOf創建數組，必須指定數組的元素，數組中的元素可以是任意類型
val arrayNumber = arrayOf(1, 2, 3, 4, 5)
// 顯示聲明 Int 類型
val arrayNumber2: Array<Int> = arrayOf(1, 2, 3, 4, 5)
// 可通過下標值來賦值
arrayNumber[4] = 6
// 不顯示聲明類型時，可以是任意類型
val arrayNumber3 = arrayOf(1, 2, "3", true, JSONObject())
// 也可以聲明為 Any 類型，相當於 Java 的 Object
val arrayNumber4: Array<Any> = arrayOf(1, 2, "3", true, JSONObject())
// 2.使用arrayOfNulls創建一個指定大小且所有元素為空的數組，必須指定集合中的元素類型以及長度
val list = arrayOfNulls<String>(5)
list[0] = "zhangsan"
...
// 3.利用array的構造函數，動態創建數組
// 用接受數組大小以及一個方法參數的 Array 構造方法，用作參數的方法能夠返回給定索引的每個元素初始值
val array = Array(10) { it -> (it * it).toString() }
// 普通的foreach方法，將數組里面的數據進行輸出
array.forEach { it -> println(it) }
// foreach增強版，會依次回調給我們數組中的索引和元素值
array.forEachIndexed { index, item ->
println("$index : $item")
}
當然，Kotlin中同樣也會提供專門的原生類型數組：
| 原生類型數組 | 解釋 |
|---|---|
| ByteArray | 字節型數組 |
| ShortArray | 短整型數組 |
| IntArray | 整型數組 |
| LongArray | 長整型數組 |
| BooleanArray | 布爾型數組 |
| CharArray | 字符型數組 |
| FloatArray | 浮點型數組 |
| DoubleArray | 雙精度浮點型數組 |
由於原生數組跟普通的數組定義一樣，具體怎么使用，就不一一展示了
擴展: 因為在Kotlin數組類型不屬於集合的一種，雖然用法跟集合很相似，數組和集合之間可以互相轉換，初始化集合的時候可以傳入數組
集合
集合在Kotlin中應用非常廣泛，例如普通的變量集，對象集，封裝json類型的請求參數集合等等。集合與數組最明顯的特點就是集合可以動態改變自己的長度，數組不可以。
- List：有序集合，可以通過索引下標來訪問元素。允許數據重復
- Set：無序且唯一的集合，set中的元素順序不會按照插入的順序一樣，並且不允許出現重復元素
- Map：也稱字典，是一種以鍵值對存在的集合，鍵是唯一的，每個鍵對應着特定的值，且值允許重復
| 創建方式 | 范例 | 說明 | 是否可變 |
|---|---|---|---|
| arrayListOf
|
arrayListOf
|
必須指定元素類型 | 是 |
| listOf
|
listOf
|
必須指定元素類型和初始化數據元素 | 否 |
| arraySetOf
|
arraySetOf
|
集合內元素會自動去重 | 是 |
| setOf
|
setOf
|
必須指定元素類型，自動去重 | 否 |
| arrayMapOf< K,V >() mutableListOf < K,V >() | arrayMapOf(Pair("key","value")) mutableMapOf() | 初始元素使用Pair包裝 | 是 |
| mapOf
|
mapOf(Pair("key","value")) | 必須指定初始元素，使用Pair包裝 | 否 |
mutableListOf的常用Api如下
- example.reverse() // 集合反轉（倒序輸出）
- example.shuffle() // 隨機排列元素（隨機輸出）
- example.sort() // 順序輸出（按a-z的順序） sortDescending 則相反
方法
下面將Kotlin的方法分為下面三個模塊進行講解
- 方法聲明
- 方法參數
- 方法用法
方法聲明
Kotlin有三種聲明方法的方式，分別為
- 普通類的方法
- 靜態類的方法
- companion object 伴生類的方法
普通類的方法
class Person {
fun test() {
println("成員方法")
}
}
fun main() {
// 普通類的成員方法聲明與調用
// 需要先構建實例對象，才能訪問成員方法
Person().test()
}
靜態類的方法
如果想要實現一個工具類的話，可以通過關鍵字object來創建一個靜態類
object commonUtil {
fun add(x: Int, y: Int): Int {
return x + 2
}
}
fun main() {
// 靜態類里面的方法，都是屬於靜態方法
// 不需要構建實例對象，可以通過類名來訪問靜態方法
commonUtil.add()
}
companion object伴生類的方法
雖然Kotlin中沒有static關鍵字，但是我們可以通過companion object來實現類靜態方法的目的
class Person {
fun test() {
println("成員方法")
}
companion object{
fun test2() {
println("靜態方法")
}
}
}
fun main() {
// 普通類的成員方法聲明與調用
// 需要先構建實例對象，才能訪問成員方法
Person().test()
// 可通過類名來調用方法
Person.test()
}
方法參數
- 默認參數
- 具名參數
- 可變數量的參數
默認參數
方法中的參數可以有默認值，可以通過類型后面的=來設置默認值
fun add(x: Int = 0, y: Int) {}
具名參數
如果一個默認參數在一個無默認值的參數之前，那么無默認值的參數，只能通過使用具名參數來調用該方法來使用
fun add(x: Int = 0, y: Int) {}
add( y = 1) // 僅通過給 y 賦值，而 x 使用默認值 0
如果最后一個參數是方法，那么它既可以作為具名參數在括號內傳入，也可以在括號外傳入
fun add(x: Int = 0, y: Int, action:() -> Unit) {}
read(y = 1){println("hello")} // 括號外傳入
read(y = 1, action = {println("hello")}) // 括號內傳入
可變數量的參數
方法的參數（通常是最后一個）可以用vararg修飾符標記
fun append(vararg str: Char): String {
val result = StringBuffer()
for (char in str){
result.append(char)
}
return result.toString()
}
傳遞可變數量的參數
append('k','o','t','l','i','n')
if表達式
帶返回值 if 表達式
在kotlin當中，由於if是一個表達式所以它會返回一個值，表達式的值為表達式作用域內最后一行的值。
fun max(a: Int, b: Int): Int {
return if ( a > b ) a else b
}
多級 if 表達式
fun eval(number: Number) {
if (number is Int) {
println("this is int number")
} else if (number is Double) {
println("this is double number")
}else if (number is Long) {
println("this is long number")
}
...
}
fun main() {
eval(100)
}
when表達式
fun eval(number: Number): String = when (number) {
is Int -> this is int number
is Double -> this is double number
is Long -> this is long number
...
}
fun main() {
eval(100)
}
循環控制
for循環
for循環可以對任何提供迭代器iterator的對象進行遍歷，寫法為 for item in elements，最常用的應用就是迭代集合
val items = listOf("kotlin","java","python")
for (item in items) {println(item)}
除此之外，擴展一下，for循環還有兩種其他遍歷方式
val items = listOf("kotlin","java","python")
items.forEach {item -> println("forEach:${item}")}
items.forEachIndexed {index, item -> println("forEachIndexed:${index},${item}")}
do-while
// 當 condition 為 true時執行循環體
while(condition) {
...
}
// 循環體第一次會無條件地執行。之后，當condition為true時才執行
do {
...
} while (condition)
迭代區間和數列
for 可以循環遍歷任何提供了迭代器的對象。即：有一個成員函數或者擴展函數 iterator()，它的返回類型，有一個成員函數或者擴展函數 next()，並且有一個成員函數或者擴展函數 hasNext()返回Boolean
for (i in 1..10) {
// 遍歷區間，kotlin的區間的包含 [1,10]
print("$i ") // 輸出結果為 ： 1 2 3 4 5 6 7 8 9 10
}
for (i in 1 until 10) {
// until 不包含最后一個元素，左閉右開的區間 [1,10)
print("$i ") // 輸出結果為 ： 1 2 3 4 5 6 7 8 9
}
for (i in 10 downTo 1 step 2) {
// 從 10 開始，每隔2個元素打印一次
print("$i ") // 輸出結果為 ： 10 8 6 4 2
}
break 和 continue
- break：終止最外層的循環
- continue：終止當前循環，開始下一次循環
泛型
泛型是一種語法糖，其實就是把類型參數化，它的引入給強類型編程語言加入了更強的靈活性。
好處
- 將代碼通用化，可應用到多個業務模塊
- 增強代碼的健壯性，避免了
ClassCastException類轉換異常 - 方便造輪子，解決實際的問題
常見的泛型應用有：泛型類、泛型接口、泛型方法和泛型屬性
泛型接口/泛型類（泛型類型）
定義泛型類型，是在類型名之后、主構造函數之前用尖括號括起的大寫字母類型參數指定：
泛型接口
interface Person<T> {
fun study(): T
fun run(t: T)
}
class Student : Person<String> {
override fun run(t:String) {
print("run:${t}")
}
}
fun main() {
val student = Student()
student.run("跑步")
}
泛型類
abstract class Color<T>(val t: T) {
abstract fun printColor()
}
class BlueColor(val color: String) : Color<String>(color) {
override fun printColor() {
print("printColor:${color}")
}
}
fun main() {
val blueColor = BlueColor("藍色")
}
泛型字段
定義泛型類型字段，可以完整地寫明類型參數，如果編譯器可以自動推定類型參數，也可以省略類型參數
abstract class Color<T>(val t: T /*泛型字段*/) {
abstract fun printColor()
}
泛型方法
fun <T> fromJson(json: String, tClass: Class<T>): T? {
val t: T? = tClass.newInstance()
return r
}
fun main() {
fromJson("{}", String::class.java)
}
至此，Kotlin的入門教程就告一段落了，后續要需要補充的再更新，感謝觀看 ✿✿ヽ(°▽°)ノ✿