柚子快報(bào)激活碼778899分享：Kotlin語(yǔ)法學(xué)習(xí)總結(jié)

http://yzkb.51969.com/

目錄

一、前言：

二、變量的定義和使用

三、函數(shù)的定義和使用

四、流程控制

五、類和對(duì)象

六、接口

七、權(quán)限修飾符

八、數(shù)據(jù)類

九、lambda的使用

十、函數(shù)式API的使用

十一、let函數(shù)的使用

十二、內(nèi)嵌表達(dá)式

一、前言：

最近由于工作需要用到kotlin語(yǔ)言，所以學(xué)習(xí)了相關(guān)的語(yǔ)法知識(shí)，現(xiàn)在將學(xué)習(xí)到的東西進(jìn)行一個(gè)總結(jié)。用于方便后續(xù)的使用。主要從以下幾個(gè)方面來(lái)記錄

1、變量的定義和使用

2、函數(shù)的定義和使用

3、流程控制關(guān)鍵字的使用

4、類和對(duì)象的使用

5、接口的使用

6、權(quán)限修飾符

7、數(shù)據(jù)類

8、lambda的使用

9、函數(shù)式API的使用

10、let函數(shù)的使用

11、內(nèi)嵌表達(dá)式的使用

在這邊說(shuō)明一下kotlin基本的使用原則

kotlin每個(gè)語(yǔ)句可以以;結(jié)尾，也可以不加。但是java必須要加。

如果不以kotlin結(jié)尾的時(shí)候，需要確保你的語(yǔ)句要有換行，如果沒有換行則必須要加;

二、變量的定義和使用

1、定義：

kotlin的變量的定義使用var和val來(lái)進(jìn)行定義，并且分為靈活定義和非靈活定義。

所謂的靈活定義就是變量聲明的時(shí)候沒有指定類型，而是通過(guò)賦值的初始值來(lái)決定類型，例如var a = 1。這種方式類似于js中的變量定義，但是跟js不一樣的是，在kotlin中如果一個(gè)變量被賦初始值之后，那么這個(gè)變量的類型也就隨之確定了。后續(xù)也不能再賦值成其他類型，而在js中這種操作是支持的

例如var a = 1? ?a = "test"? //這種操作是不允許的

所謂的非靈活定義就是在聲明的時(shí)候就已經(jīng)指明這個(gè)是什么類型，格式就是 name : type。

其中name就是變量的名字，type是變量的類型

例如

var a : Int = 1? ?//正確

var a : Int = "test"? //錯(cuò)誤，已經(jīng)明確指明是int類型了，無(wú)法再賦值成string類型

var和val的區(qū)別就是var定義了之后可以再次修改，val定義了之后無(wú)法再修改。可以認(rèn)為是java的final類型的變量

2、使用：

使用的話與java沒有什么區(qū)別，就是通過(guò)變量名進(jìn)行操作，還可以通過(guò)美元符$配合使用，后面細(xì)說(shuō)

三、函數(shù)的定義和使用

1、定義：

函數(shù)的定義與java有著一些不一樣，java的函數(shù)定義的格式如下：

type name(type arg1, type arg2,?...) {

? ? ? ? function body

}

而在kotlin中函數(shù)的定義的標(biāo)準(zhǔn)格式如下：

fun name(arg1 : type, arg2: type,....) : returnType {

? ? ? ? function body

}

其中 fun關(guān)鍵字、name是必須的。參數(shù)和返回值不是必須的。如果沒有定義參數(shù)那調(diào)用的時(shí)候就不用傳參，同樣的如果沒有定義了返回值類型，那就直接有函數(shù)體就夠了，需要把:returnType一起去掉，如果沒有定義返回值類型的話，那么默認(rèn)返回的是unit類型，也就是java中的void類型，只是在kotlin中可以省略不寫

2、簡(jiǎn)化定義：

上面寫的是函數(shù)的一個(gè)標(biāo)準(zhǔn)的定義的過(guò)程。kotlin還支持一種簡(jiǎn)化版本的定義。格式如下：

fun name(arg1: type...) : returnType = fun body。這種格式下需要遵守以下條件：

a、函數(shù)體內(nèi)部不能使用return語(yǔ)句，默認(rèn)最后一句當(dāng)作返回值

b、如果函數(shù)體內(nèi)部有if的話，必須要有else，即使最后一句有返回值(這邊留個(gè)疑問點(diǎn)？這么規(guī)定的原因是什么？理論上我最后一句有返回值就可以了)

c、如果有returnType的話，那么返回值類型必須要跟returnType類型一致，否則報(bào)錯(cuò)

d、如果函數(shù)體有用{}包含的話，不能規(guī)定返回值類型，因?yàn)榇藭r(shí)返回的不是具體的類型

下面的具體的例子：

fun myAge() = 10 //正確，沒有定義函數(shù)返回值，默認(rèn)以最后一句作為返回值

fun myAge() : Int = 10 //正確，明確要求返回值是Int類型，實(shí)際返回也是Int類型

fun myAge() : String = 10 //錯(cuò)誤，明確要求返回的是String 類型，實(shí)際返回的確是Int類型

fun myAge(name : String) = if(name == "Tom") "10" else 20 //正確，沒有規(guī)定返回值，按照默認(rèn)的最后一句返回，如果參數(shù)是Tom的話，則返回字符串10，如果不是Tom的話，返回?cái)?shù)字20

fun myAge(name: String) = return 10 //錯(cuò)誤，以=命名的情況下，不允許使用return語(yǔ)句，必須按照默認(rèn)最后一句當(dāng)作返回值

fun myAge(name: String) = {return 10} //錯(cuò)誤，以=命名的情況下，不允許使用return語(yǔ)句，必須按照默認(rèn)最后一句當(dāng)作返回值

fun myAge(): Int = {10} //錯(cuò)誤，加了{(lán)}的情況下返回的是kotlin.Int，而不是Int類型

3、函數(shù)的默認(rèn)值：

kotlin的函數(shù)的定義允許使用默認(rèn)值，具體的格式如下

fun name(arg1 type = xxx....) {body}

例如 fun myAge(name: String = "Tom") {}

如果有多個(gè)參數(shù)的默認(rèn)值，正常情況下從有到左連續(xù)的都有默認(rèn)值，如果沒有的話，那再調(diào)用的時(shí)候就要指定參數(shù)

fun myPrint(name: String = "Tom", age : Int, score: Int = 100) {

println("name is $name, age is $age, score is $score")

}

fun main() {

myPrint(10) //錯(cuò)誤，這個(gè)時(shí)候按照默認(rèn)的第一個(gè)參數(shù)，要求是string，但是傳遞的是int

myPrint("Jimmy", 10) //正確，按照默認(rèn)的順序傳遞參數(shù)，第三個(gè)參數(shù)使用默認(rèn)值

myPrint(10, "Jimmy") //錯(cuò)誤，按照默認(rèn)的順序傳遞參數(shù)，類型不匹配

myPrint(age = 10) //正確，指定參數(shù)賦值

myPrint(age = 10, name = "Jimmy") //正確，指定參數(shù)名賦值，不使用默認(rèn)的順序

}

四、流程控制

在kotlin中，流程的控制主要用到了if、when、循環(huán)這幾個(gè)

1、if：

if的使用于java中基本上類似，有一個(gè)特別注意的地方，就是在函數(shù)簡(jiǎn)化定義的時(shí)候，if后面必須要跟else，否則會(huì)報(bào)錯(cuò)

2、when：

when的使用有點(diǎn)類似與java的switch/case。主要區(qū)別點(diǎn)如下：

a、switch必須要帶一個(gè)參數(shù)，而when帶不帶參數(shù)都行(其實(shí)不帶參數(shù)的時(shí)候就是外面有一個(gè)作用域更大的參數(shù)可以直接使用)。

b、case使用的是：，而在when里面使用->。case和when里面都可以使用復(fù)雜操作

c、case只能單純的判斷相等，而when可以執(zhí)行復(fù)雜的判斷，例如判斷數(shù)據(jù)類型等

d、如果是在簡(jiǎn)便的函數(shù)定義內(nèi)部使用when，并且這個(gè)when是最后一個(gè)流程。那么必須要保證有結(jié)束分支(使用else或者在when外部有返回)

例子如下：

1、//正確，返回值是Unit

fun myAge(name: String) {

when {

name == "Tom" -> 111

}

}

2、//錯(cuò)誤，沒有else分支，導(dǎo)致數(shù)據(jù)類型缺失

fun myAge(name: String) = {

when {

name == "Tom" -> 111

}

}

3、//正確，返回的是kotlin.Any

fun myAge(name: String) = {

when {

name == "Tom" -> 111

else -> "222"

}

}

4、//正確，返回的是kotlin.String

fun myAge(name: String) = {

when {

name == "Tom" -> 111

}

"2222"

}

上面的第2個(gè)和第4個(gè)例子，大家可以對(duì)比一下，為什么第四個(gè)沒有else也是正確的？因?yàn)檫@個(gè)時(shí)候when沒有在最后一個(gè)流程，最后一個(gè)是"2222"，我們上面說(shuō)過(guò)，簡(jiǎn)便形式的函數(shù)定義是以最后一句當(dāng)作返回值的，如果這個(gè)最后一句是when或者if的話，那就必須要有else

3、循環(huán)

在kotlin中循環(huán)通過(guò)兩種方式，一個(gè)是while，一種是for-in。while跟java一樣，這里不講解。for-in的話跟java也是大同小異，只不過(guò)java中基本上用的是各種集合，kotlin可能區(qū)間用的更多。這邊順便講解一下kotlin的區(qū)間的定義以及for-in的示例

//升序閉合區(qū)間使用..定義

val range = 0 ..10

//升序左閉右開區(qū)間使用until定義

val range2 = 0 until 10

//降序區(qū)間使用downTo定義

val range3 = 10 downTo 0

//for-in默認(rèn)步長(zhǎng)的使用方式

for(i in range) {.....}

//for-in 指定步長(zhǎng)的使用方式

for(i in range step 2) {......}

五、類和對(duì)象

1、類定義：

kotlin中類定義跟java中類似，使用class關(guān)鍵字，其中成員變量的聲明也是參照var和val的區(qū)別定義

成員函數(shù)的定義也跟普通的函數(shù)定義一樣

2、對(duì)象創(chuàng)建

kotlin中的對(duì)象的創(chuàng)建與java不太一樣，他直接摒棄了new關(guān)鍵字。例如

class Test?

var? t = Test();

3、類的繼承

kotlin中類的繼承主要使用：來(lái)繼承，在：后面需要跟上父類的構(gòu)造函數(shù)，跟上構(gòu)造函數(shù)主要是為了后續(xù)實(shí)例化傳參

另外有一個(gè)注意的點(diǎn)就是如果按照普通的class聲明的方式的類是不可被繼承的，因?yàn)槟菢颖宦暶鞒闪薴inal的class。需要在class前面加上open關(guān)鍵字，這樣才能被繼承

4、構(gòu)造函數(shù)

kotlin中類的構(gòu)造函數(shù)分為主構(gòu)造函數(shù)和次構(gòu)造函數(shù)。

主構(gòu)造函數(shù)，就是直接在類的聲明的時(shí)候使用括號(hào)進(jìn)行聲明，并且在主構(gòu)造函數(shù)里面可以添加init函數(shù)體進(jìn)行參數(shù)的初始化處理，init不能帶括號(hào)，因?yàn)樗皇且粋€(gè)正常的函數(shù)

open class Person {

fun dump() {

println("this is person dump")

}

}

class Student(score:Int) : Person() {

init{

println("init score: $score") //正確，在構(gòu)造函數(shù)里面的訪問，正常

}

fun dumpS() {

println("this is student dump")

println("this is student dump $score") //錯(cuò)誤，沒有成員變量score，無(wú)法訪問

}

}

次構(gòu)造函數(shù)，通過(guò)constructor關(guān)鍵字來(lái)定義，如果在次構(gòu)造函數(shù)里面想調(diào)用父類的構(gòu)造函數(shù)的話，可以使用super，如果調(diào)用子類的其他構(gòu)造函數(shù)的話，可以使用this，這里要注意的一個(gè)點(diǎn)是，如果定義了主函數(shù)，那么這個(gè)主函數(shù)必須要被調(diào)用到，其他的次構(gòu)造函數(shù)需要間接或者直接的調(diào)用到主構(gòu)造函數(shù)??

fun myAge1(name: String) = {10}

fun myAge(name: String) = {

when {

name == "Tom" -> 111

}

"222"

}

fun myPrint(name : String = "Tom", age: Int, score: Int = 100) {

if (name == "Tom")

println("name is $name, age is $age, score: $score");

}

open class Person(name: String, age: Int) {

init {

println("person name : $name, age: $age");

}

fun dump() {

println("this is person dump")

}

}

class Student(score:Int) : Person("Tom",20) {

init{

println("init score: $score")

}

//正確，通過(guò)主構(gòu)造函數(shù)再進(jìn)行父類構(gòu)造函數(shù)的初始化

constructor(score: Int, name: String, age: Int) : this(score) {

}

//錯(cuò)誤，沒有簡(jiǎn)介的調(diào)用主構(gòu)造函數(shù)

//constructor(score: Int, name: String, age: Int): super(name ,age) {

}

fun dumpS() {

println("this is student dump")

}

}

fun main() {

//println("Hello, World: " + myAge("Tom"))

//myPrint(age = 10, name = "Tom")

//var p = Person()

//p.dump()

var s = Student(100,"Jimmy", 30)

s.dumpS()

}

5、成員變量：

我們聲明一個(gè)類的成員變量可以在類的里面使用var或者val聲明，但是也可以在構(gòu)造函數(shù)里面使用val或者var來(lái)聲明，這樣可以在傳遞參數(shù)的時(shí)候默認(rèn)聲明這個(gè)類包含這個(gè)成員變量，同時(shí)還可以用權(quán)限修飾符來(lái)修飾

class Student(name: String) {

init{ //正確，在init里面可以訪問構(gòu)造函數(shù)的參數(shù)

println("init student name $name")

}

fun printFun() {

println("on print function name $name") //錯(cuò)誤，沒有name這個(gè)成員變量

}

}

class Student(var name: String) {

init{ //正確，在init里面可以訪問構(gòu)造函數(shù)的參數(shù)

println("init student name $name")

}

fun printFun() {

println("on print function name $name") //正確，此時(shí)name這個(gè)成員變量是public的

}

}

var student = Student("Tom")

println("name is " + student.name) //正確，public成員可以訪問

class Student(private var name: String){}

var student = Student("Tom")

println("student name " + student.name) //錯(cuò)誤，private成員不可直接訪問

6、單例類

在java中單例模式通常是在類的內(nèi)部定義一個(gè)static成員，在kotlin中，直接使用object關(guān)鍵字替代class來(lái)聲明一個(gè)單例類，其他成員變量和成員函數(shù)的定義和普通的類一樣，這邊主要記錄一下注意點(diǎn)：

object單例類不能像普通的類一樣進(jìn)行實(shí)例化，只能通過(guò)類名調(diào)用

由于不能進(jìn)行實(shí)例化，所以聲明的時(shí)候不允許有構(gòu)造函數(shù)，也就是聲明的時(shí)候不允許帶()

可以通過(guò)普通類的聲明方式來(lái)聲明一些成員變量，然后進(jìn)行一些其他操作

疑問點(diǎn)：這邊有遇到一個(gè)問題，就是如果單例類聲明了一個(gè)變量name，那么我如果聲明一個(gè)setName的函數(shù)的話，編譯器就會(huì)提示報(bào)錯(cuò)，具體原因待研究

六、接口

kotlin中的接口與java中一樣，都是使用interface進(jìn)行定義，然后再實(shí)現(xiàn)這個(gè)接口的時(shí)候用“，”定義，然后在類里面實(shí)現(xiàn)對(duì)應(yīng)的接口函數(shù)就可以了，另外就是接口包含已經(jīng)實(shí)現(xiàn)的函數(shù)，這個(gè)與jdk1.8的功能一樣

注意：如果一個(gè)類只是單純的實(shí)現(xiàn)一個(gè)接口的話，用"："實(shí)現(xiàn)，如果繼承了一個(gè)父類，那么后面用"，"跟著表示實(shí)現(xiàn)這個(gè)接口。如果沒有繼承任何父類直接用，實(shí)現(xiàn)接口的話，會(huì)出現(xiàn)編譯異常

open class Person(name: String, age: Int) {

var name = ""

var age = 10

init {

println("person name : $name, age: $age");

this.name = name

this.age = age

}

fun dump() {

println("this is person dump")

}

}

interface study {

fun learnChinese()

fun learEnglish()

fun defaultMethod() {

println("this is defaultMethod")

}

}

class Student : Person, study{

init{

println("init score")

}

constructor(score: Int, name: String, age: Int) : super(name,age) {

}

fun dumpS() {

println("this is student dump")

}

override fun learnChinese() {

println("$name is learning chinese")

}

override fun learEnglish() {

println("$name is learning english")

}

}

七、權(quán)限修飾符

kotlin中的權(quán)限修飾符與java中的差別不大，主要還是public、protect、private三個(gè)為主，唯一的區(qū)別是kotlin中增加了internal關(guān)鍵字來(lái)代替java中的default，另外i就是kotlin中的成員默認(rèn)是public的，而java中默認(rèn)是private的

八、數(shù)據(jù)類

在java中經(jīng)常會(huì)出現(xiàn)一種場(chǎng)景，定義一個(gè)類，只用來(lái)保存數(shù)據(jù)，然后我們需要寫一堆的get和set。在kotlin中有一種簡(jiǎn)便的使用方法，這就是數(shù)據(jù)類，數(shù)據(jù)類的定義就是在class前面使用data關(guān)鍵字進(jìn)行聲明

data class userBean(val arg1: Int, val arg2: String)

var user = userBean(111, "222")

println("user arg1: "+ user.component1())

九、lambda的使用

所謂的lambda，其實(shí)可以理解成c里面的函數(shù)指針，java里面的函數(shù)參數(shù)的傳遞只允許傳遞基本類型和對(duì)象類型，不允許傳遞函數(shù)指針，而kotlin是支持這個(gè)特性的，也就是lambda的使用。lambda的格式如下：

{參數(shù)名1：參數(shù)類型，參數(shù)名2：參數(shù)類型->函數(shù)體}

其實(shí)這種語(yǔ)法有點(diǎn)像groovy里面的閉包，

其實(shí)說(shuō)白了就是可以指定某種函數(shù)，然后在另外一個(gè)函數(shù)內(nèi)部可以調(diào)用這個(gè)函數(shù)。整體的使用可以參照groovy的閉包使用的方式

上面只是說(shuō)明了lambda的聲明，但是在實(shí)際場(chǎng)景中最終還是要應(yīng)用到函數(shù)中，那么如果lambda作為函數(shù)參數(shù)的時(shí)候又要如何聲明呢？我們知道普通的參數(shù)是name:type的形式，lambda也可以參照這個(gè)格式，只不過(guò)他的type比較特殊，需要按照函數(shù)的類型來(lái)定義，需要有形參的類型和個(gè)數(shù)以及返回值，格式如下

fun testFun(callbackName: (arg1: type, arg2: type) -> returnType) {}

其中callbackName跟普通的函數(shù)形參名字一樣，arg1、arg2、type也是跟普通的函數(shù)一樣，returnType就是定義普通的函數(shù)返回值類型，如果沒有返回的話就指定為Unit

調(diào)用的話就直接將整個(gè)lambda表達(dá)式當(dāng)作參數(shù)傳進(jìn)去，這里可以選擇直接傳遞或者先聲明賦值給某個(gè)變量后再傳遞。下面將lambda的使用總結(jié)一下：

a、lambda參數(shù)可以直接傳遞也可以聲明成一個(gè)變量后再傳遞

b、如果lambda表達(dá)式是最后一個(gè)參數(shù)的話，可以把這個(gè)表達(dá)式放到（）外面，但是這種情況只適用于直接傳遞表達(dá)式的情況

c、如果整個(gè)函數(shù)只有一個(gè)lambda參數(shù)，并且這個(gè)參數(shù)是直接整個(gè)表達(dá)式傳遞進(jìn)去的，那么可以將這個(gè)（）去除

d、如果lambda表達(dá)式只有一個(gè)參數(shù)的話，那么在函數(shù)體內(nèi)部可以用it代替這個(gè)參數(shù)

fun testPrint(callback : (name: String) -> Unit) {

callback("testName")

}

fun testPrint2(name: String, callback:(name:String)->Unit) {

callback(name)

}

//正確，直接當(dāng)作參數(shù)傳遞

testPrint({name:String -> println("testcallback name: $name)})

//正確，先聲明參數(shù)后再傳遞

var testLambda = {name:String -> println("testcallback name: $name")}

testPrint(testLambda)

//正確,當(dāng)lambda參數(shù)是最后一個(gè)的時(shí)候，可以選擇放到括號(hào)外面

testPrint2("Tom"){name:String -> println("testcallback name: $name")}

//錯(cuò)誤，只有在使用表達(dá)式當(dāng)作參數(shù)的時(shí)候才能移到外面

testPrint2("Tom")testLambda

//正確，當(dāng)labmda是唯一的一個(gè)參數(shù)的時(shí)候，可以省略括號(hào)

testPrint{name:String -> println("testcallback name: $name")}

十、函數(shù)式API的使用

所謂的函數(shù)式API其實(shí)也就是標(biāo)準(zhǔn)方式的函數(shù)調(diào)用，至于為什么要單獨(dú)拎出來(lái)講是因?yàn)槭褂脳l件限制比較特殊。當(dāng)kotlin調(diào)用java接口的時(shí)候，如果這個(gè)接口是單抽象方法接口的時(shí)候，那么就可以使用函數(shù)式API，所謂的單抽象的方法接口就是只有一個(gè)方法的接口。

下面用一個(gè)創(chuàng)建多線程的例子來(lái)說(shuō)明函數(shù)式API的使用演變

1、對(duì)比一下正常的java和kotlin的使用。由于kotlin沒有new關(guān)鍵字，所以要使用內(nèi)部類的話就必須要使用object關(guān)鍵字

//java調(diào)用

new Thread(new Runnable() {

@override

public void run() {

System.out.println("test");

}

}).start();

//kotlin調(diào)用

Thread(object:Runnable{

override fun run() {

println("test")

}

}).start()

2、因?yàn)镽unnable是單抽象接口，所以可以將runnable對(duì)象的聲明和實(shí)例化去除，代碼可以簡(jiǎn)化成如下兩種

Thread({

println("test")

}).start()

Thread(Runnable {

println("test")

}).start()

3、又因?yàn)橹挥衦unnable一個(gè)參數(shù)，根據(jù)上面lambda的使用所講的，可以將()去除，所以又演變了以下方式

Thread {

println("test")

}.start()

以上就是函數(shù)式API的使用，記住只適合于單抽象接口的方法

十一、let函數(shù)的使用

這個(gè)let函數(shù)可以理解成原子操作。使用這個(gè)let函數(shù)之后，不會(huì)因?yàn)榫€程調(diào)度等引發(fā)多線程的問題。格式如下:

obj.let {

? ? ? ? it->...? ?//其中it就是這個(gè)obj。這個(gè)也是lambda的使用

}

舉個(gè)例子

//由于線程調(diào)度的關(guān)系，在main函數(shù)中執(zhí)行test1的時(shí)候，傳進(jìn)來(lái)的參數(shù)是不為空的

//但是當(dāng)判斷結(jié)束后切換到另外一個(gè)線程B。這個(gè)線程會(huì)將student置為空，這個(gè)時(shí)候再切換回主線程

//就會(huì)出現(xiàn)崩潰問題

fun test1(student : Student) {

if (student != null) {

student.xxx();

}

}

//這種情況下，如果main函數(shù)調(diào)用test2的時(shí)候就不會(huì)出現(xiàn)上述的那個(gè)問題，因?yàn)樗谂袛喾强盏臅r(shí)候會(huì)立即執(zhí)行l(wèi)et函數(shù)里面的東西

fun test2(student : Student) {

student?.let{

it.xxx()

}

}

var student = Student()

fun main() {

test1(student);

Thread {student = null}.start()

}

其中上面例子里面的？表示的是不為空，這個(gè)比較簡(jiǎn)單，就不做詳細(xì)解釋了

十二、內(nèi)嵌表達(dá)式

所謂的內(nèi)嵌表達(dá)，就是在一個(gè)表達(dá)式中，可以引用其他的變量，跟shell語(yǔ)言引用變量的方式類似，shell中也是通過(guò)$來(lái)引用變量，這邊也是

//正常情況下的打印

println("name is : " + name + ", age is: " + age)

//使用內(nèi)嵌表達(dá)式的打印，其實(shí)就是引用變量

println("name is $name, age is $age")

//可以使用復(fù)雜的表達(dá)式來(lái)判斷

//println("name is ${if(age > 10) "Tom" else "Jim"} age is $age")

以上就是關(guān)于kotlin語(yǔ)言學(xué)習(xí)的一些總結(jié)了

柚子快報(bào)激活碼778899分享：Kotlin語(yǔ)法學(xué)習(xí)總結(jié)

http://yzkb.51969.com/

文章鏈接