Hello World

fun main() {
    println("Hello World")
}

每一行代碼無需加分號，

變數和函式

變數

val 不可變變數
var 可變變數

// 寫法一：型別推倒機制
fun main(){
	val a = 10
	println("a = "+ a)
}
// 寫法二：顯示宣告變數型別
fun main(){
	val a ：Int = 10
	println("a = "+ a)
}

優先使用val宣告變數，當無法滿足時再使用var，這樣程式會更健壯，更規范，

函式

// 無參，無回傳值
fun methodName(){

}
// 有參，無回傳值
fun methodName(param1: Int,param2: Int){

}
// 有參，有回傳值
fun demo(param1: Int,param2: Int): Int{
    return a + b
}

demo:

 fun main() {
        val a = 10
        val b = 2
        val value = sumNum(a, b)
        println(value)
    }

    fun sumNum(a: Int, b: Int): Int {
        return a + b
    }

Kotlin 語法糖，不寫函式體和return，

fun main(){
    val a = 10
    val b = 2
    val value = sumNum(a,b)
    println(value)
}

fun sumNum(a:Int,b:Int):Int = a + b
// 簡寫
fun sumNum(a:Int,b:Int) = a + b

程式邏輯控制

if 條件陳述句

fun main() {
    val a = 10
    val b = 2
    val value = maxNum(a, b)
    println(value)
}
// 1、一般寫法
fun maxNum(a: Int, b: Int): Int {
    var value = 0
    if (a > b) {
        value = a
    } else {
        value = b
    }
    return value
}
// 2、精簡寫法
fun maxNum(a: Int, b: Int): Int = if (a > b) a else b

when 條件陳述句

類似 java 的 switch，強于 switch，

fun main() {
    val a = "a"
    val value = getScore(a)
    println(value)
}

fun getScore(name: String) = when (name) {
    "a" -> 86
    "b" -> 26
    "c" -> 36
    "d" -> 31
    else -> 0
}

可傳入任意型別引數，格式：匹配值 -> { 執行邏輯 }，當執行邏輯為一行代碼時，{}可省略，is關鍵字時型別匹配的核心，

fun main() {
    val a = 1
    checkNum(a)
}

fun checkNum(num: Number) {
    when (num) {
        is Int -> println("Int")
        is Double -> println("Double")
        else -> println("other")
    }
}

當 when 中不傳入引數，可以這么寫：

fun main() {
        val a = "a"
        val value = getScore(a)
        println(value)
    }

    fun getScore(name: String) = when {
        name == "a" -> 86
        name == "b" -> 26
        name == "c" -> 36
        name == "d" -> 31
        else -> 0
    }

Kotlin 中判斷字串或物件是否相等可以直接使用 ==，

fun main() {
    val a = "ade"
    val value = getScore(a)
    println(value)
}

fun getScore(name: String) = when{
    name.startsWith("a") -> 86
    name == "b" -> 26
    name == "c" -> 36
    name == "d" -> 31
    else -> 0
}

字符a開頭的分數都是 86，

回圈陳述句

for 回圈,..創建兩端閉區間的關鍵字，0..10相當于[0,10]，

fun main() {
   for(i in  0..10){
       println(i)
   }
}

左閉右開區間，使用until關鍵字，

// [0,10)
val range = 0 until 10

step 關鍵字，step 2相當于i = i + 2，每次回圈遞增2，

fun main() {
   for(i in  0 until 10 step 2){
       println(i)
   }
}

降序區間使用關鍵字downTo，如創建一個[10,1]的降序區間，

fun main() {
   for(i in  10 downTo 1){
       println(i)
   }
}

面向物件編程

類和物件

fun main() {
   val p = Person()
        p.name = "oo"
        p.age = 10
        p.eat()
}
class Person {
    var name = ""
    var age = 0

    fun eat() {
        println(name + " eat " + " age:" + age)
    }
}

繼承與建構式

如果一個類需要被繼承，那么得在類名前加上關鍵字open，子類繼承父類，需要關鍵字 :

fun main() {
   val p = Student()
        p.name = "oo"
        p.age = 10
        p.eat()
}
// 父類
open class Person {
    var name = ""
    var age = 0

    fun eat() {
        println(name + " eat " + " age:" + age)
    }
}
// 子類，注意父類需要加上 ()
class Student:Person() {
    var sno = ""
    var grade = 0
}

建構式分為兩種：主建構式、次建構式，任何類只能有一個主建構式，可有多個次建構式，

fun main() {
   val p = Student("01",89)
        p.name = "oo"
        p.age = 10
        p.eat()
        println(p.sno+" "+p.grade)
}
open class Person {
    var name = ""
    var age = 0

    fun eat() {
        println(name + " eat " + " age:" + age)
    }
}
// 主建構式 父類()為無參建構式
class Student(val sno:String,val grade:Int):Person() {
    
}

fun main() {
   val p = Student("01",89,"lisi",12)
   p.eat()
   println(p.sno+" "+p.grade)
}
open class Person (val name:String,val age:Int){
    fun eat() {
        println(name + " eat " + " age:" + age)
    }
}
// 主建構式 父類()為有參建構式，子類不需要宣告 val
class Student(val sno:String,val grade:Int,name:String,age:Int):Person(name,age) {
    
}

當一個類有主次建構式時，所有次建構式必須呼叫主建構式（包括間接呼叫），通過this關鍵字呼叫主建構式，

class Student(val sno:String,val grade:Int,name:String,age:Int):Person(name,age) {
    constructor(name:String,age:Int):this("",0,name,age){
        
    }
    constructor():this("",0){
        
    }
}

介面

interface Study {
    fun readBook()
    fun doHomeWork(){
        // 如未實作則默認實作
    }
}

class Student(name: String, age: Int) : Person(name, age), Study {
    override fun readBook() {
        println("$name is reading")
    }

    override fun doHomeWork() {
        println("$name is doing homework")
    }
}

可見修飾符

public（默認）、private（當前類內部可見）、protecte（當前類子類可見）、internal（同一模塊中可見）

資料類和單例類

資料類，只需要data關鍵字，會將equals()、hashCode()、toString()等方法自動生成，

data class Cellphone(val brand: String, val price: Double)

單例類，使用關鍵字object，

object Singleton {
    fun singletonTest(){
        //
    }
}

呼叫方式：Singleton.singletonTest()

Lambda編程

集合的創建和遍歷

List

fun main(){
    // 初始化集合 listOf->不可變集合
    val list = listOf("a","b","c","d")
    for(s in list){
        println(s)
    }
}

// 初始化集合 mutableListOf->可變集合
    val mutableList = mutableListOf("a","b","c","d")
    mutableList.add("e")
    for(s in mutableList){
        println(s)
    }

Set

fun main(){
    // 不可變，無序
    val set = setOf("a","b","c","d")
    for(s in set){
        println(s)
    }
    // 可變，無序
    val mutableSet = mutableSetOf("a","b","c","d")
    mutableSet.add("g")
    for(s in mutableSet){
        println(s)
    }
}

Map

fun main() {
        // 不可變
        val map = mapOf("a" to 1, "b" to 2, "c" to 3)
        for ((k, v) in map) {
            println("key:$k-value:$v")
        }
        // 可變
        val mutableMap = mutableMapOf("a" to 1, "b" to 2, "c" to 3)
        val d = "d"
        mutableMap[d] = 4
        for ((k, v) in mutableMap) {
            println("key:$k-value:$v")
        }
    }

集合的函式式API

Lambda運算式：

{引數名1: 引數型別, 引數名2: 引數型別 -> 函式體}

fun main(){
 	val list = listOf("this","share","and")
//     val maxLen = list.maxByOrNull({word:String->word.length}) 
//     val maxLen = list.maxByOrNull() {word:String->word.length}
//     val maxLen = list.maxByOrNull{word:String->word.length}
// 	   val maxLen = list.maxByOrNull{word->word.length} 
    val maxLen = list.maxByOrNull{it.length}
    println(maxLen)
}

map

集合中map函式，將集合中每個元素映射成一個另外的值，映射規則在lambda運算式指定，最終生成一個新的集合，

fun main(){
 	val list = listOf("this","share","and")
    val newList = list.map{it.toUpperCase()}
    for(s in newList){
        println(s)
    }
}

filter

集合中filter函式，過濾集合中資料，

fun main() {
        val list = listOf("this", "share", "and")
        val newList = list.filter { it.length < 4 }.map { it.toUpperCase() }
        for (s in newList) {
            println(s)
        }
    }

注意：先過濾再映射

all、any、count、find

all：如果對所有元素都滿足運算式，則使用all函式，回傳Boolean值，

any ：如果所有元素是否至少存在一個元素匹配，則使用any函式，回傳Boolean值，

count ：如果想知道多少個元素滿足，則使用count ，回傳Int值，

find ：要找到一個滿足條件的元素，使用find函式，回傳符合條件元素，

fun main(){
 	val list = listOf("this","share","and","yes")
    val anyResult = list.any{it.length < 4}
    val allResult = list.all{it.length < 4}
    val countResult = list.count{it.length < 4}
    val findResult = list.find{it.length < 4}
    print("anyResult:$anyResult -- allResult:$allResult -- countResult:$countResult -- findResult:$findResult")
    // anyResult:true -- allResult:false -- countResult:2 -- findResult:and
}

空指標檢查

可空型別

fun Study(study:study?){
    if(study != null){
       fun readBook()
       fun doHomeWork() 
    }
}

判空輔助工具

？.

物件不為空時呼叫相應方法（如果接收者非空，就呼叫一個方法或訪問一個屬性），

if (a != null){
    a.doFun()
}
// 簡化寫法
a?.doFun()


fun Study(study:study?){
     study?.readBook()
     study?.doHomeWork() 
}

? :

如果 ?: 左側運算式?空，elvis 運算子就回傳其左側運算式，否則回傳右側運算式，請注意，當且僅當左側為空時，才會對右側運算式求值，

val c = b?.length ?:-1

作用域函式

let

let 將物件本身作為引數傳遞到 Lambda 運算式中，

fun doStudy(syudy:Study?){
    study?.let{stu ->
        stu.readBook()
        stu.doWork()
    }
}
// 簡化
fun doStudy(syudy:Study?){
    study?.let{
        it.readBook()
        it.doWork()
    }
}

轉載請註明出處，本文鏈接：https://www.uj5u.com/yidong/299363.html

標籤：其他

上一篇：iOS逆向之深入決議函式本質·函式呼叫堆疊與相關指令

下一篇：Android Studio 打開專案后無故爆紅

Kotlin 快速入門