前言
本文章只是用于記錄學習，所以部分地方如果有錯誤或者理解不對的地方，麻煩請指正。本篇為 csdn 原文章 轉移修改版 原文章
簡述：
- kotlin 中集合如何簡單的創(chuàng)建
- kotlin 中函數(shù)如何定義 及 更好、更明白的調用
- kotlin 中頂層函數(shù) 和頂層屬性的簡單使用
- kotlin 中擴展函數(shù) 和 擴展屬性的講解
- kotlin 中中綴 方法的使用 和 簡單了解
- kotlin 中解構 使用
1. 集合
// set
val set = hashSetOf(1,2,3)
// list
val arr = arrayListOf(2,3,4,5)
// hashmap
val map = hashMapOf(1 to "A",2 to "B")
?? 上述代碼 展示的是一半的 set ， arraylist ， hashmap 三種數(shù)據(jù)結構的創(chuàng)建方法，kotlin 中的 集合部分都是沿用了 java 的 集合類，在java 的基礎上包裹了一層，更方便開發(fā)者的調用 和 創(chuàng)建。在java 的基礎上 還進行了一部分api 的封裝。
// 獲取數(shù)組中最后一個
arr.last()
// 獲取數(shù)組中最大的一個
arr.max()
?? 為了 方便開發(fā)人員，更好的知道函數(shù)的用法，我們也可以在 方法頭部添加注釋，包括方法名稱的定義和參數(shù) 名稱的設置，合理的設置，可以提升代碼的閱讀力，當然，kotlin也為我們做了一些事情
fun getColor(color :Color){
when(color){
Color.BLUE ,Color.RED -> println("this is blue or red")
Color.GREEN -> println("this is GREEN")
}
}
// 普通調用
getColor(Color.GREEN)
// 優(yōu)化后的調用
getColor(color = Color.GREEN)
?? 如果你是開發(fā)人員，在看著 第二種調用方法，會更加簡單明了的知道這個參數(shù)是干什么的 ，我們應該怎么傳，but，如果我們在調用的時候 指明了參數(shù)的名稱，為了避免混淆，后邊的參數(shù)也有點要 指明 參數(shù)名稱。
2.函數(shù)定義、頂層函數(shù) 和屬性
2.1 函數(shù)的定義 及調用
1、函數(shù)的定義使用關鍵字"fun",函數(shù)參數(shù)格式為: "參數(shù):類型",函數(shù)返回值類型 "fun(...): Int"
fun sum(a: Int, b: Int, c: Int): Int {
return a + b + c
}
2、表達式作為函數(shù)體，返回值的類型可以省略，可以利用Kotlin的類型推導功能，推測出函數(shù)返回值的類型。
fun sum(a: Int, b: Int, c: Int) = a + b + c
3、無返回值的函數(shù)(類似Java中的void空類型返回值)
// Unit 也可以省略不寫
fun printSum(a: Int, b: Int, c: Int): Unit {
println(a + b + c)
}
4、可變長參數(shù)函數(shù)可以使用 "vararg" 關鍵字標識類似Java中的public void setData(Object... objects)。
fun vars(vararg args: Int) {
for (arg in args) {
print(arg)
}
}
5、lambda(匿名函數(shù))
val sumLambda: (Int, Int, Int) -> Int = { a, b, c -> a + b + c }
6 函數(shù)調用
在Kotlin函數(shù)中有這么一種參數(shù)叫做命名參數(shù),它能允許在函數(shù)調用的地方指定函數(shù)名，這樣就能很好使得調用地方的參數(shù)和函數(shù)定義參數(shù)一一對應起來，不會存在傳遞參數(shù)錯亂問題。
println(printSum(a=1,b=2,c=3))
AndroidStudio3.0帶命名參數(shù)的函數(shù)調用高亮提示更加醒目
?2.2 頂層函數(shù)
?? 該節(jié)點我們先使用兩段代碼，就很好的了解頂層函數(shù)說的什么意思了。
main
import util.*
fun main(args: Array<String>) {
HelloWorld()
}
Util
package util
fun HelloWorld(){
println("hello")
}
?? 看完上邊兩個代碼塊，我們就大致了解 頂層函數(shù)，類似于 我們java 中的 Util類，我們在main 中通過 依賴util .* ，就可以直接在類中使用 util中的方法，并且不用想java 中的 還有前邊加上 類名.方法名 來調用。
java的Util 情況。相對于我們寫過的項目，不管大小，都會有一個Util文件將愛專門放一些 靜態(tài)函數(shù)，我們一個界面或者 一個Model 里邊都會引用很多其他地方的類。
Kotlin 中的 頂層函數(shù)：根本不需要創(chuàng)建那么多類，我們可以繼續(xù)寫util 類，但是我們直接把函數(shù)放在文件的頂層，這樣不用從屬與任何的類，并且還是 該類中的一部分，如果在包外，我們就可以通過 import 的方式引入，并且外邊也不用包一層。
2.3 關于頂層函數(shù)實質原理
要想知道內部調用原理很簡單，我們只需要把上面例子代碼反編譯成Java代碼就一目了然了。這里科普一下反編譯Kotlin代碼步驟，因為這是查看Kotlin語法糖背后實質很好的方法。
步驟一: 確認IDE安裝好了Kotlin Plugin
步驟二: 在IDE中打開你需要查看反編譯的代碼文件，然后打開頂部的"Tools",選擇"Kotlin",再選擇"Show Kotlin ByteCode"
步驟三: 左邊是Kotlin的源碼，右邊是Kotlin的ByteCode
步驟四: 點擊右側“Decompile”
通過以上的代碼可以總結出兩點內容:
1、頂層文件會反編譯成一個容器類。(類名一般默認就是頂層文件名+"Kt"后綴，注意容器類名可以自定義)
2、頂層函數(shù)會反編譯成一個static靜態(tài)函數(shù)，如代碼中的formateFileSize和main函數(shù)
對于Java中如何調用Kotlin中的頂層函數(shù)了吧。調用方式很簡單，就是利用反編譯生成的類作為靜態(tài)函數(shù)容器類直接調用對應的函數(shù)
System.out.println("文件大小: " + FormateFileKt.formateFileSize(1111));// Java中調用Kotlin中定義頂層函數(shù)，一般是頂層文件名+"Kt"后綴作為靜態(tài)函數(shù)的類名調用相應函數(shù)
2.4 頂層函數(shù)名稱修改
Kotlin中的頂層函數(shù)反編譯成的Java中的容器類名一般是頂層文件名+“Kt”后綴作為類名，但是也是可以自定義的。也就是說頂層文件名和生成容器類名沒有必然的聯(lián)系。通過Kotlin中的@file: JvmName("自定義生成類名")注解就可以自動生成對應Java調用類名，注意需要放在文件頂部，在package聲明的前面
@file: JvmName("FormateUtil")
package com.ymc.kotlindemo
import java.math.BigDecimal
fun formateFileSize(size: Double): String { ... }
我們通過同樣的方法看下 kotlin 會生成怎么的文件內容
這樣Java調用自定義類名頂層函數(shù)就更加自然，一般建議使用注解修改類名，這樣在Java層調用還是我們習慣工具類的命名，完全無法感知這個函數(shù)是來自Java中還是Kotlin中定義的，做到完全透明。
System.out.println("文件大小: " + FormateUtil.formateFileSize(1111));
2.5 頂層屬性
?? 和 頂層函數(shù) 相似，屬性也是可以放在文件的頂層
BUtil
var index = 0
const val indexx = 0
fun todoSomething(){
index ++
}
main
import util.indexx
fun main(args: Array<String>) {
println(indexx)
}
?? 和頂層函數(shù)一樣的，不過這里學到了新的關鍵詞 const ，他等同于 java 中的 public static final ，因為不可變，所以 const val 標配。
?? 總結：使用頂層函數(shù)和屬性從此消除Java中的static、中綴表達式調用和解構聲明等。
3.擴展函數(shù)和屬性
擴展部分 算是kotlin 的一大特色，擴展函數(shù) 擴展屬性 同理，其實 他就是成員內的函數(shù)或者 屬性，但是寫在了 成員外部。
?3.1 擴展函數(shù)
?? 只需要把擴展的類或者接口名稱，放到即將要添加的函數(shù)名前面。這個類或者名稱就叫做接收者類型，類的名稱與函數(shù)之間用"."調用連接。this指代的就是接收者對象，它可以訪問擴展的這個類可訪問的方法和屬性。
// 擴展 函數(shù)
fun String.lastData() : Char{
return this.get(this.length-1)
}
// 獲取最后一個單詞
import util.lastData
println("Kotlin".lastData())
?? 從上邊代碼中，我們可以看出 我們想要擴展的類 或者接口名稱，添加在函數(shù)名稱的前面 ，這個 類的名稱 稱為 接收者類型，所以在本例中 String 就是接收者類型，而 “kotlin” 就是接收者對象，其實我們這樣寫，就相當于給String 添加了一個方法。但是擴展函數(shù)是 不希望你打破 原有類的封裝性的，所以擴展函數(shù)是無法 訪問到 私有的或者受保護的成員。
?? 注意： 一個類定義有一個成員函數(shù)與一個擴展函數(shù)，而這兩個函數(shù)又有相同的接收者類型、相同的名字并且參數(shù)都沒有 或者參數(shù)類型都一樣，這種情況總是取成員函數(shù)。（成員函數(shù)優(yōu)先級高）
class C {
fun foo() { println("member") }
}
fun C.foo() { println("extension") }
// 如果這里調用 foo 方法 就會打印 member。
// 如果這里 調用 C().foo(1) ，就會打印 extension。（前提是參數(shù)不一樣）
fun C.foo(i: Int) { println("extension") }
使用的話 記得引用你寫的擴展函數(shù)地址就可以了 （import util.lastData）
如果你寫的函數(shù)比較多的話，也可以 import util.*
如果想要動態(tài)的換一個名字 （import util.lastData as lastD），這樣的話 引用就需要 println("Kotlin".lastD())
?3.2 從java 中調用擴展函數(shù)
?? 如果我們的 擴展函數(shù)所在 文件位置在 Func.kt ，如果在java 中調用
Char c = Func.lastData("Kotlin")
擴展函數(shù)的靜態(tài)性質，也決定了不可以被子類重寫。
? 3.3 不可以被重寫的 擴展函數(shù)
open class View{
open fun click(){
print("view")
}
}
class Button : util.View() {
override fun click() {
print("Button")
}
}
// 探討 擴展函數(shù) 的不可繼承
fun View.shutOff(){
println("view shut off")
}
fun Button.shutOff(){
println("Button shut off")
}
// 調用語句
val view : View = Button()
view.shutOff()
輸出語句
view shut off
?? 擴展屬性的基本使用 擴展屬性實際上是提供一種方法來訪問屬性而已，并且這些擴展屬性是沒有任何的狀態(tài)的，因為不可能給現(xiàn)有Java庫中的對象額外添加屬性字段，只是使用簡潔語法類似直接操作屬性，實際上還是方法的訪問。
?? 擴展函數(shù) 并不算是類的一部分，他是聲明在類之外的，這里的函數(shù)調用 取決于 該變量的靜態(tài)類型所決定的，而不是編譯時 的數(shù)據(jù)類型所決定的。
所以 擴展函數(shù)是不可以 繼承的，因為kotlin 是 將他當做靜態(tài)函數(shù)來看待的
如果擴展函數(shù) 和 成員函數(shù) 簽名一樣，調用的時候會優(yōu)先使用 成員函數(shù)。
4.擴展屬性
例子 1
var StringBuffer.lastDataString : Char
get() {
return this.get(this.length -1 )
}
set(value) {
this.setCharAt(this.length-1 ,value)
}
?? 和擴展函數(shù)差不多，不過擴展屬性一定要寫 getter 方法，因為沒有默認字段，所以沒有默認的getter方法，同理，初始化也不可以，因為沒有存儲地址。
例子2
inner class CButton {
var b: Int = a
val MeButton.dd: Int
get() = 1
}
如果 不添加get 方法，編譯器 也會給我們報錯 “extension property cannot be initialized because it has no backing field” 。
5. 擴展函數(shù)及屬性的原理
- 通過對文章全邊的閱讀，我們這里還是使用 同樣的方法 閱讀 kotlin code
// 以這個擴展函數(shù)為例
fun View.shutOff(){
println("view shut off")
}
以下為 kotlin code 轉換后的代碼
public final void shutOff(@NotNull View $receiver) {
Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
String var2 = "view shut off";
System.out.println(var2);
}
??總結：擴展函數(shù)實際上就是一個對應Java中的靜態(tài)函數(shù)，這個靜態(tài)函數(shù)參數(shù)為接收者類型的對象，然后利用這個對象就可以訪問這個類中的成員屬性和方法了，并且最后返回一個這個接收者類型對象本身。這樣在外部感覺和使用類的成員函數(shù)是一樣的。
- 接下來我們看下擴展屬性。 擴展屬性實際上就是提供某個屬性訪問的set,get方法，這兩個set，get方法是靜態(tài)函數(shù)，同時都會傳入一個接收者類型的對象，然后在其內部用這個對象實例去訪問和修改對象所對應的類的屬性。
// kotlin code
public final char getLastDataString(@NotNull StringBuffer $receiver) {
Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
return $receiver.charAt($receiver.length() - 1);
}
public final void setLastDataString(@NotNull StringBuffer $receiver, char value) {
Intrinsics.checkParameterIsNotNull($receiver, "$receiver");
$receiver.setCharAt($receiver.length() - 1, value);
}
總結:
- 擴展函數(shù)和成員函數(shù)使用方式類似，可以直接訪問被擴展類的方法和屬性。(原理: 傳入了一個擴展類的對象，內部實際上是用實例對象去訪問擴展類的方法和屬性)
- 擴展函數(shù)不能打破擴展類的封裝性，不能像成員函數(shù)一樣直接訪問內部私有函數(shù)和屬性。(原理: 原理很簡單，擴展函數(shù)訪問實際是類的對象訪問，由于類的對象實例不能訪問內部私有函數(shù)和屬性，自然擴展函數(shù)也就不能訪問內部私有函數(shù)和屬性了)
- 擴展函數(shù)實際上是一個靜態(tài)函數(shù)是處于類的外部，而成員函數(shù)則是類的內部函數(shù)。
- ]父類成員函數(shù)可以被子類重寫，而擴展函數(shù)則不行
6. 可空接收者
fun Any?.toString(): String? {
if (this == null) return "null"
// 空檢測之后，“this”會自動轉換為非空類型，所以下面的 toString()
// 解析為 Any 類的成員函數(shù)
return toString()
}
??上段代碼，我們看到 在函數(shù)方法名 后邊和 返回值后邊都有 “？” ，kotlin 中問號表示可以為空，所以我們代碼中要對 null 進行判斷。
7. 擴展聲明為成員
??在一個類內部你可以為另一個類聲明擴展。在這樣的擴展內部，有多個 隱式接收者 —— 其中的對象成員可以無需通過限定符訪問。擴展聲明所在的類的實例稱為 分發(fā)接收者，擴展方法調用所在的接收者類型的實例稱為 擴展接收者.(雖然我也不懂字面意思 但是看完代碼就懂了)
class D {
fun bar() { …… }
}
class C {
fun baz() { …… }
fun D.foo() {
bar() // 調用 D.bar
baz() // 調用 C.baz
}
fun caller(d: D) {
d.foo() // 調用擴展函數(shù)
}
}
class C {
fun D.foo() {
toString() // 調用 D.toString()
this@C.toString() // 調用 C.toString()
}
}
8. 中綴語法
先來看一組代碼
//普通使用字符串對比調用StringUtils.equals(strA, strB)
fun main(args: Array<String>) {
val strA = "A"
val strB = "B"
if (StringUtils.equals(strA, strB)) {//這里對比字符串是了apache中的StringUtils
println("str is the same")
} else {
println("str is the different")
}
}
//利用中綴調用sameAs對比兩個字符串
fun main(args: Array<String>) {
val strA = "A"
val strB = "B"
if (strA sameAs strB) {//中綴調用 sameAs
println("str is the same")
} else {
println("str is the different")
}
}
通過 中綴 語法 可以節(jié)省 部分代碼的 書寫 （類 + “.”+ 方法 的調用方式的省略）
再來看一組
//普通調用集合contains方法判斷元素是否在集合中
fun main(args: Array<String>) {
val list = listOf(1, 3, 5, 7, 9)
val element = 2
if (list.contains(element)) {
println("element: $element is into list")
} else {
println("element: $element is not into list")
}
}
//利用中綴調用into判斷元素是否在集合中
fun main(args: Array<String>) {
val list = listOf(1, 3, 5, 7, 9)
val element = 2
if (element into list) {
println("element: $element is into list")
} else {
println("element: $element is not into list")
}
}
中綴調用，這樣的寫法，會更加接近我們自然語言的表達，更容易理解
1、前面所講into，sameAs實際上就是函數(shù)調用，如果把infix關鍵字去掉，那么也就純粹按照函數(shù)調用方式來。比如 1.to("A"), element.into(list)等，只有加了中綴調用的關鍵字infix后，才可以使用簡單的中綴調用例如 1 to "A", element into list等
2、并不是所有的函數(shù)都能寫成中綴調用，中綴調用首先必須滿足一個條件就是函數(shù)的參數(shù)只有一個。然后再看這個函數(shù)的參與者是不是只有兩個元素，這兩個元素可以是兩個數(shù)，可以是兩個對象，可以是集合等。
9 解構 使用
解構聲明實際上就是將對象中所有屬性，解構成一組屬性變量，而且這些變量可以單獨使用，為什么可以單獨使用，是因為每個屬性值的獲得最后都編譯成通過調用與之對應的component()方法,每個component()方法對應著類中每個屬性的值，然后在作用域定義各自屬性局部變量，這些局部變量存儲著各自對應屬性的值，所以看起來變量可以單獨使用，實際上使用的是局部變量。
我們先來舉個例子
// data class 是重點
data class Student(var name: String, var age: Int, var grade: Double)
---------------
fun main(args: Array<String>) {
val student = Student("mikyou", 18, 99.0)
val (name, age, grade) = student//將一個student對象解構成一組3個單獨的變量
println("my name is $name , I'm $age years old, I get $grade score")//解構后的3個變量可以脫離對象，直接單獨使用
}
很納悶怎么可以這么寫？我們這里通過 kotlin code 看下 真面目
public final class DestructTestKt {
public static final void main(@NotNull String[] args) {
Intrinsics.checkParameterIsNotNull(args, "args");
Student student = new Student("mikyou", 18, 99.0D);
String name = student.component1();//返回對應就是Student中name屬性
int age = student.component2();//返回對應就是Student中age屬性
double grade = student.component3();//返回對應就是Student中屬性
//注意: 這里單獨使用的name, age, grade實際上是局部變量
String var6 = "my name is " + name + " , I'm " + age + " years old, I get " + grade + " score";
System.out.println(var6);
}
}
當然 我們也可以 部分解構，不需要全部解構對象，我們可以使用 “_” 符號表示不解構。
val (_, age, grade) = student//下劃線_ 忽略name屬性
當然我們也可以不加 任何東西 省略掉 name，這樣也是可以的
val (age, grade) = student//直接不寫name屬性
注意點：解構聲明的對象類型一定是data class，普通的class是不會生成對應的component的方法。
