1,Boolean 類型

Boolean 類型的值只有true和false ,相當于java中的boolean和Boolean

var aBoolean: Boolean = true
var bBoolean: Boolean = false

2,Number類型

/**
 * Byte類型
 */

var abByte: Byte = 123
var bbByte: Byte = Byte.MAX_VALUE
var cbByte: Byte = Byte.MIN_VALUE


/**
 * Short類型
 */

var aShort: Short = 123
var bShort: Short = Short.MAX_VALUE
var cShort: Short = Short.MIN_VALUE


/**
 * Int類型數據寫法
 */
var anInt: Int = 100
//16進制寫法
var bInt: Int = 0xff
//二進制
var bbInt: Int = 0b00000001
var cInt: Int = Int.MAX_VALUE
var dInt: Int = Int.MIN_VALUE

/**
 * Long類型數據寫法
 */
var aLong: Long = 100
var bLong: Long = 178784932941798
var cLong: Long = Long.MAX_VALUE
var dLong: Long = Long.MIN_VALUE
//未定義整數默認是Int類型,若要使用Long類型則需要在數字后加L或l
fun main() {
    print(100L)
}

/**
 * Float類型
 */
var aFloat: Float = 1.2F
//1乘10的3次方
var bFloat: Float = 1E3f
var cFloat: Float = Float.MAX_VALUE
//Float的最小負數
var ccFloat: Float = -Float.MAX_VALUE
//Float中最小的非0正數
var dFloat: Float = Float.MIN_VALUE
//Float的最大負數
var ddFloat: Float = Float.MIN_VALUE
//不是數字的數字例如  0/0  NaN跟任何不是數的數  都不相等  因為這樣比較無意義
var eFloat: Float = Float.NaN


/**
 * Double類型
 */
var aDouble: Double = 1.0
var bDouble: Double = Double.MAX_VALUE
var cDouble: Double = Double.MIN_VALUE

Kotlin中的Int類型是Java中int和Integer的集合體,編譯器會在需要時進行裝箱和拆箱

基本數據類型的轉換,不可隱式轉換;較低位數不能直接賦值給較高位數的變量,必須通過顯示轉換才行

var ttInt: Int = 1
var ttLong: Long = ttInt.toLong();

3,Char類型

• Char類型對應Java中的Character類型
• 占兩個字節,標示一個16位的 Unicode字符
• 字符用' '(單引號)引起來

var aChar: Char = 'a'
var bChar: Char = '中'
//Unicode編碼形式
var cChar: Char = '\u000f'

轉義字符

4,字符串類型

• 字符串是一串Char
• 用""引起來
• 字符串比較內容使用==
• 字符串比較對象是否相同使用===

/**
 * 字符串;類型
 */
var aString: String = "ABC"
var bString: String = String(charArrayOf('A', 'B', 'C'))
fun main(args: Array<String>) {
    //相當于java中eques
    println(aString == bString)
    //判斷這兩個是不是同一個對象
    println(aString === bString)
}
//原始字符串
var cString: String = """  
     \n
     \t
     \\""
   1
     2
     3
"""

這里需要注意的是-判斷對象的引用使用"===";判斷對象的值使用"=="(相當于Java中的equels)

5，區間(Range)

• 數學上的概念,表示范圍
• CloseRange 的子類 最常用的是IntRange

//離散型區間
val rangeA: IntRange = 0..10//[0,100]閉區間
val rangeB: IntRange = 0 until 10//[0,99)半開區間
var rangeC: IntProgression = 10 downTo 0//倒序閉區間和..的值順序相反
var rangeD = 1..10 step 2//步長,相當于隔多少值再取1,3,5
var rangeE = 'a'..'z' step 3

//連續性區間
var rangeF = 1.0f..2.0f
//var rangeG = 1.0f until 2.0f  不可半開區間
//var rangeK = 1.0f..2.0f step 0.2   不可加步長,沒有意義

//無符號區間
var rangeH = 1U..10U

fun main(args: Array<String>) {
    //判斷包含關系
    println(rangeA.contains(50))
    println(50 in rangeA)
    println(rangeB.contains(100))
    println(100 in rangeB)
    //遍歷區間A
    for (i in rangeA) {
        print("$i,")
    }
    println(rangeA.joinToString())
    //遍歷區間B
    rangeB.forEach {
        print("$it")
    }
    println()
    for (i in rangeC) {
        print("$i,")
    }
    println()
    for (i in rangeD) {
        print("$i,")
    }
    println()
    rangeD.forEach {
        print("$it")
    }

}

區間的應用

• 遍歷數組時獲取當前位置的索引

var arrint = intArrayOf(1, 2, 3, 4)

    //區間的應用,獲取數組的索引
    //方式一
    for (i in 0 until arrint.size) {
        print(arrint[i])
    }
    //方式二
    for (i in arrint.indices) {
        print(arrint[i])
    }

6,數組

• 對應英文單詞Array
• 跟數沒有關系,數列只是數組的一個特性形式
• 是一系列對象

基本數據類型數組:為了避免不必要的裝箱和拆箱,基本類型的數組是定制的

//獲取數組的長度
    println(arrayOfAny.size)
    //遍歷數組
    for (i in arrayOfInt) {
        println(i)
    }
    arrayOfString.forEach { ele ->
        print(ele)
    }
    //和上面等效
    arrayOfString.forEach {
        println(it)
    }
    //判斷字符串是否在該數組中
    if ("中國" in arrayOfString) {
        println("中國在字符串中")
    }


    //數組取值并替換
    arrayOfChar[0] = 'X'
    println(arrayOfChar[0])
    //字符數組連接
    println(arrayOfChar.joinToString(""))
    //數組切片即取出數組中一個范圍內的值
    println(arrayOfString.slice(0..1))
    println(arrayOfString.slice(0 until 2))

7,Kotlin的集合框架

• 增加了 "不可變"集合框架接口
• 沒有另起爐灶,復用Java Api 的所有實現形式
• 提供了豐富易用的方法

//不可變list,里面元素不能增加和減少
var listA = listOf<String>("A", "b", "c")
//可變list同Java中的list相同可增刪
var ListB: MutableList<String> = mutableListOf<String>("A")
//和java中的經典寫法兒相同
val listC = ArrayList<String>()
//map創建方式
val mapA = mapOf<String, Any>("name" to "wjf", "age" to 25)
var mapB = mutableMapOf<String, Any>("name" to "wjf", "age" to 25)
var mapC = mutableMapOf<String, Any>(Pair("name", "wjf"), Pair("age", 25))

fun main(args: Array<String>) {
    //正常的add添加
    for (i in 1..10) {
        listC.add("$i")
    }
    //kotlin中可以使用+=的方式來添加元素,但是listC定義的時候應該用val不能
    //使用var要不會有編譯的錯誤
    for (i in 1..10) {
        listC += "$i"
    }
    //普通遍歷
    for (s in listC) {
        print(s)
    }
    //利用區間獲取帶索引的遍歷
    for (s in listC.indices) {
        print(listC[s])
    }
    //forEach形式
    listC.forEach {
        print(it)
    }
    //普通的移除方法
    for (i in 1..10) {
        listC.remove("$i")
    }
    for (s in listC) {
        print(s)
    }
    //-=形式移除元素
    for (i in 1..10) {
        listC -= "$i"
    }
    for (s in listC) {
        print(s)
    }
    //獲取map中的元素并賦值
    mapB["name"] = "WJF"
    //map遍歷方式1
    for (entry in mapA) {
        val key = entry.key
        val value = entry.value
        println("key is ${key}; value is $value")
    }
    //map遍歷方式2
    val asIterable = mapB.asIterable()
    for (entry in asIterable) {
        val key = entry.key
        val value = entry.value
        println("key is ${key}; value is $value")
    }
    //map遍歷方式3
    val keys = mapB.keys
    for (key in keys) {
        val value = mapB[key]
        println("key is ${key}; value is $value")
    }
    //map遍歷方式4
    for (entry in mapB.entries) {
        val key = entry.key
        val value = entry.value
        println("key is ${key}; value is $value")
    }
}

另外的一個kotlin的獨有類

• Pair

• Triple

8,函數(function)

<1>基本定義

• 函數:以特定功能組織起來的代碼塊
• 函數可以有自己的類型,所以是"一等公民"
• 可以賦值,傳遞并在合適的條件下調用

函數的定義

fun [函數名] (參數列表):[返回值類型]{[函數體]}
fun [函數名](參數列表)=[表達式]
//匿名函數,需要使用變量或常量進行接收
var|val [變量名]=fun([參數列表]):返回值類型{[函數體]}

• 如果函數的返回值為Unit(Unit相當于Java中的void)時可以省略,編譯器會智能的類型推導

fun main(args: Array<String>) {
    val arg1 = 1
    val arg2 = 2
    println(sum(arg1, arg2))
    println(sumSimple(arg1, arg2))
    println(sumDate)
    println(sumDate(arg1, arg2))
}
fun sum(arg1: Int, arg2: Int): Int {
    return arg1 + arg2
}
fun sumSimple(arg1: Int, arg2: Int) = arg1 + arg2
val sumDate = fun(arg1: Int, arg2: Int): Int {
    return arg1 + arg2
}

<2>方法和函數

• 方法可以認為是函數的一種特殊形式
• 簡單的理解就是定義在類中的函數就是方法

class Food {
    //方法
    fun eat() {}
}
//函數
fun eat() {}

<3>函數的類型

個人見解:當定義完一個函數后,函數的類型也就確定了,函數的類型和基本類型如Int,String等都一樣可以是參數,也可以賦值,理解的時候就把函數的類型理解為跟String一樣就行,就是寫法兒有點兒特殊

class Food {
    //方法
    fun eat() {}
}

//String  是參數類型
fun eat(arg: String) {}

//() -> Unit是參數類型:空參數并且返回值為Unit類型的函數類型
fun eat(arg: () -> Unit) {}

//Food.() -> Unit是參數類型:receiver為Food中參數并且返回值為Unit類型的函數類型
fun eat(arg: Food.() -> Unit) {}

//receiver可以當成函數的第一個參數
fun eats(arg: (Food) -> Unit) {}//跟上個等效所以函數名不能相同

<4>函數的引用

當定義完一個函數之后,就有了一個函數的具體實現,就相當于實例化了一個字符串對象,這個時候就可以拿這個函數給變量進行賦值

引用方式

• 對于一個在一個類中的函數使用 <類名>::<方法名>
• 對于普通的函數使用 ::<方法名>

fun eat(arg: String) {}
var a: (String) -> Unit = ::eat//eat函數的引用
//() -> Unit是參數類型:空參數并且返回值為Unit類型的函數類型
fun eatb(arg: () -> Unit) {}
var b: (() -> Unit) -> Unit = ::eatb//eatb函數的引用
//Food.() -> Unit是參數類型:receiver為Food中參數并且返回值為Unit類型的函數類型
fun eatc(arg: Food.() -> Unit) {}
var c: ((Food) -> Unit) -> Unit = ::eatc//eatc函數的引用

class Food {
    fun eat() {} //方法
}
//String  是參數類型
fun eat(arg: String) {}
fun eatU() {}
//() -> Unit是參數類型:空參數并且返回值為Unit類型的函數類型
fun eatb(arg: () -> Unit) {}
//Food.() -> Unit是參數類型:receiver為Food中參數并且返回值為Unit類型的函數類型
fun eatc(arg: Food.() -> Unit) {}
//receiver可以當成函數的第一個參數
fun eats(arg: (Food) -> Unit) {}//跟上個等效所以函數名不能相同

fun main(args: Array<String>) {
     //普通函數調用
    eat("ABC")
    //函數引用調用
    val test: () -> Unit = ::eatU
    eatb { test }
    val test2: (Food) -> Unit = Food::eat
    eatc { test2 }
    eats(test2)
    //實例化對象后函數調用
    val food:Food=Food()
    val test3=food::eat
    eatb(test3)
}

需要注意的是當實例化一個對象后,此實例化的對象對函數的引用,不再是(對象,函數參數)->返回值類型 的形式,而是(函數參數)->返回值類型

<5>變長參數

• 函數調用時候參數的個數才能確定的函數
• 使用vararg 修飾

fun multiParameters(vararg arg1: Int){
    print(arg1.joinToString("_"))
}

multiParameters(1,2,3,4,5)

<6>多返回值

• 其實Kotlin中是"偽"的多返回值的,是通過Pair和Triple進行組裝實現的

fun multiReturn(): Triple<Long, String, Int> {
    return Triple(1L, "WJF", 25)
}

val tt: Triple<Long, String, Int> = multiReturn()
//解構
val (a, b, c) = multiReturn()

<7>函數的默認參數

• 當一個函數調用時,其中一個參數大多數場景下為一個值時,可以為其定一個默認值
• 需要注意的是一般默認參數要放在最后

fun defaultParameter(name:String,age:Int,sex:String="男"){}
defaultParameter("WJF",25)

<8>編寫函數的注意事項

• 功能要單一
• 函數名要做到顧名思義
• 參數個數不要太多(在某些機器上會影響執行效率)

<9>四則運算計算器實例

通過在運行窗口輸入內容獲得簡單的四則運行結果

fun main(vararg args: String) {
    //當輸入的字符少3個時提示用戶
    if (args.size < 3) {
        return help()
    }
    //利用函數的引用對應操作符
    val opres = mapOf<String, (Int, Int) -> Int>(
        "+" to ::plus,
        "-" to ::jian,
        "*" to ::time,
        "/" to ::div
    )
    //從map中獲取當前操作符對應的函數
    val nowOp = opres[args[1]] ?: return help()
    //打印輸入內容
    println("你輸入了:${args.joinToString(" ")}")
    //結算結果
    println("結果:${args[0]}${args[1]}${args[2]}=${nowOp(args[0].toInt(), args[2].toInt())}")
}

fun plus(arg1: Int, arg2: Int): Int {
    return arg1 + arg2
}

fun jian(arg1: Int, arg2: Int): Int {
    return arg1 - arg2
}

fun time(arg1: Int, arg2: Int): Int {
    return arg1 * arg2
}

fun div(arg1: Int, arg2: Int): Int {
    return arg1 / arg2
}

fun help() {
    println(
        """
            這是一個四則運算的小程序
            請輸入: 3*4
            得到結果:12
            """
    )
}

輸入 3 * 5
得到結果

你輸入了:3 * 5
結果:3*5=15