From Java To Kotlin, 空安全、擴展、函數、Lambda
概述（Summarize）
- Kotlin 是什麼？
- 可以做什麼？
- Android 官方開發語言從Java變為Kotlin,Java 有哪些問題？
- Kotlin的優點
- Kotlin 特性（Features）
Kotlin 是什麼？
Kotlin 出自於捷克一家軟件研發公司 JetBrains ，這家公司開發出很多優秀的 IDE，如 IntelliJ IDEA、DataGrip 等都是它的傑作，包括 Google 官方的 Android IDE -- Android Studio ，也是 IntelliJ IDEA 的插件版。
Kotlin 源於 JetBrains 的聖彼得堡團隊，名稱取自聖彼得堡附近的一個小島 ( Kotlin Island ) ，和 Java一樣用島嶼命名，JetBrains 在 2010 年首次推出 Kotlin 編程語言，並在次年將之開源。
- Kotlin 是一種在 Java 虛擬機上運行的靜態類型編程語言，被稱之為 Android 世界的Swift。
- Kotlin 可以編譯成Java字節碼。也可以編譯成 JavaScript，方便在沒有 JVM 的設備上運行。
- 在Google I/O 2017中，Google 宣佈 Kotlin 成為 Android 官方開發語言,替代 Java 語言。
Kotlin 代碼會被編譯成Java字節碼，所以和 Java 兼容
<img src="http://seachal-blog-picture-host.oss-cn-beijing.aliyuncs.com/MWeb/2023/03/16/16789367124770.jpg" class="m-0 h-110 rounded shadow" />
可以做什麼？
- Android
- Server-side
-
Multiplatform Mobile
Kotlin Multiplatform Mobile is in Beta!
-
Multiplatform libraries
Create a multiPlatform library for JVM, JS, and Native platforms.
<img src="http://seachal-blog-picture-host.oss-cn-beijing.aliyuncs.com/MWeb/2023/03/13/16786878005647.jpg" class="m-0 h-40 rounded shadow" />
可以做很多方向的開發！
Android 官方開發語言從Java變為Kotlin,Java 有哪些問題？
- 空引用（Null references）：Java 中的 null 值是經常導致程序運行出錯的原因之一，因為 Java 不支持空安全。
- 更少的函數式編程特性：Java 語言在函數式編程方面的支持相對較弱，雖然 Java 8 引入了 Lambda 表達式和 Stream API，但是 Kotlin 語言在這方面的支持更加全面和友好。
- 不夠靈活，缺乏擴展能力：我們不能給 第三方 SDK 中的classes 或者 interfaces 增加新的方法。。
- 語法繁瑣，不夠簡潔：Java 語言比 Kotlin 語言更為冗長，需要寫更多的代碼來完成相同的任務，這可能會降低開發效率。
Kotlin的優點
Modern, concise and safe programming language
- 簡約：使用一行代碼創建一個包含
getters、setters、equals()、hashCode()、toString()以及copy()的 POJO： - 安全：徹底告別那些煩人的 NullPointerException
- 互操作性： Kotlin 可以與 Java 混合編程，Kotlin 和 Java 可以相互調用，目標是 100% 兼容。
Kotlin 特性（Features）
- 空安全（Null safety）
- 類型推斷（Type inference）
- 數據類 (Data classes)
- 擴展函數 (Extension functions)
- 智能轉換（Smart casts）
- 字符串模板（String templates）
- 單例（Singletons）
- 函數類型 (Function Type )
- Lambda 表達式
- 高階函數（Primary constructors）
- 函數字面量和內聯函數（Function literals & inline functions）
- 類委託（Class delegation）
- 等等......
基本語法 （Basic Syntax ）
- 變量（Variables）
- 基本數據類型（ Basic Data Type ）
- 空安全（Null Safety ）
- 函數聲明（ Define Function ）
-
讓函數更好的調用（ Making functions easier to call ）
- 命名參數/具名參數 （Named arguments）
- 參數默認值（Default arguments）
變量（Variables）
在 Java/C 當中，如果我們要聲明變量，我們必須要聲明它的類型，後面跟着變量的名稱和對應的值，然後以分號結尾。就像這樣：
Integer price = 100;而 Kotlin 則不一樣，我們要使用val或者是var這樣的關鍵字作為開頭，後面跟“變量名稱”，接着是“變量類型”和“賦值語句”，最後是分號結尾。就像這樣：
/*
關鍵字 變量類型
↓ ↓ */
var price: Int = 100; /*
↑ ↑
變量名 變量值 */在 Kotlin 裏面，代碼末尾的分號省略不寫，就像這樣：
var price = 100 // 默認推導類型為： Int另外，由於 Kotlin 支持類型推導，大部分情況下，我們的變量類型可以省略不寫，就像這樣：
var price = 100 // 默認推導類型為： Intvar 聲明的變量，我們叫做可變變量，它對應 Java 裏的普通變量。
val 聲明的變量，我們叫做只讀變量，它相當於 Java 裏面的 final 變量。
var price = 100
price = 101
val num = 1
num = 2 // 編譯器報錯var, val 反編譯成 Java ：
我們已經知道了 val 屬性只有 getter，只能保證引用不變，不能保證內容不變。例如，下面的代碼：
class PersonZ {
var name = "zhang"
var age = 30
val nickname: String
get() {
return if (age > 30) "laozhang" else "xiaozhang"
}
fun grow() {
age += 1
}屬性 nickname 的值並非不可變，當調用 grow() 方法時，它的值會從 "xiaozhang" 變為 "laozhang"，
不過因為沒有 setter,所以無法直接給 nickname 賦值
編譯時常量
const 只能修飾沒有自定義 getter 的 val 屬性，而且它的值必須在編譯時確定。
val time = System.currentTimeMillis()
// 這種會報錯
const val constTime = System.currentTimeMillis()基本數據類型（ Basic Data Type ）
Kotlin 的基本數值類型包括 Byte、Short、Int、Long、Float、Double 等。
| 類型 | 位寬度 | 備註 |
|---|---|---|
| Double | 64 | Kotlin 沒有 double |
| Float | 32 | Kotlin 沒有 float |
| Long | 64 | Kotlin 沒有 long |
| Int | 32 | Kotlin 沒有 int/Intege |
| Short | 16 | Kotlin 沒有 short |
| Byte | 8 | Kotlin 沒有 byte |
在 Kotlin 語言體系當中，是沒有原始類型這個概念的。這也就意味着，在 Kotlin 裏，一切都是對象。
空安全（Null Safety ）
既然 Kotlin 中的一切都是對象，那麼對象就有可能為空。如果我寫這樣的代碼：
val i: Double = null // 編譯器報錯以上的代碼並不能通過 Kotlin 編譯。
<img src="http://seachal-blog-picture-host.oss-cn-beijing.aliyuncs.com/MWeb/2023/03/13/16786156409163.jpg" class="m-0 h-30 rounded shadow" />
這是因為 Kotlin 強制要求開發者在定義變量的時候，指定這個變量是否可能為 null。
對於可能為 null 的變量，我們需要在聲明的時候，在變量類型後面加一個問號“?”：
val i: Double = null // 編譯器報錯
val j: Double? = null // 編譯通過並且由於 Kotlin 對可能為空的變量類型做了強制區分，這就意味着，“可能為空的變量”無法直接賦值給“不可為空的變量”，反過來 “不可為空的變量” 可以賦值給“可能為空的變量” 。
var i: Double = 1.0
var j: Double? = null
i = j // 編譯器報錯
j = i // 編譯通過這麼設計的原因是，從集合邏輯上：可能為空 包含 不可為空
而如果我們實在有這樣的需求，也不難實現，只要做個判斷即可：
var i: Double = 1.0
val j: Double? = null
if (j != null) {
i = j // 編譯通過
}
函數聲明（ Define Function ）
在 Kotlin 當中，函數的聲明與 Java 不太一樣。
Java：
public String helloFunction(@NotNull String name) {
return "Hello " + name + " !";
}Kotlin ：
/*
關鍵字 函數名 參數類型 返回值類型
↓ ↓ ↓ ↓ */
fun helloFunction(name: String): String {
return "Hello $name !"
}/* ↑
花括號內為：函數體
*/- 使用了 fun 關鍵字來定義函數；
- 返回值類型，緊跟在參數的後面，這點和 Java 不一樣。
如果函數體中只有一行代碼，可以簡寫
- return可以省略
- { } 花括號可以省略
-
直接用
=連接，變成一種類似 變量賦值的 函數形式fun helloFunton(name:String)：String = "Hello $name !"
我們稱之為單表達式函數
由於Kotlin支持類型推導，返回值類型可以省略：
fun helloFunton(name:String)：= "Hello $name !"這樣看起來就更簡潔了。
讓函數更好的調用（ Making functions easier to call ）
命名參數/具名參數 （Named arguments）
以前面的函數為例子，我們調用它：
helloFunction("Kotlin")和 Java 一樣。
不過，Kotlin 提供了一些新的特性，如命名函數參數
舉個例子，現在有一個函數：
fun createUser(
name: String,
age: Int,
gender: Int,
friendCount: Int,
feedCount: Int,
likeCount: Long,
commentCount: Int
) {
//..
}如果像 Java 那樣調用：
createUser("Tom", 30, 1, 78, 2093, 10937, 3285)就要嚴格按照參數順序傳參：
- 參數順序調換，參數就傳錯了，不好維護。
- 當參數是一堆數字，很難知道數字對應的形參，可讀性不高。
Kotlin 參數調用：
createUser(
name = "Tom",
age = 30,
gender = 1,
friendCount = 78,
feedCount = 2093,
likeCount = 10937,
commentCount = 3285
)我們把函數的形參加了進來，形參和實參用 = 連接，建立了兩者的對應關係。這樣可讀性更強。
如果想修改某個參數例如feedCount也可以很方便的定位到參數。 這樣易維護
參數默認值（Default arguments）
fun createUser(
name: String,
age: Int,
gender: Int = 1,
friendCount: Int = 0,
feedCount: Int = 0,
likeCount: Long = 0L,
commentCount: Int = 0
) {
//..
}gender、likeCount 等參數被賦予了默認值，當我們調用時，有些有默認值的參數就可以不傳參，Kotlin編譯器自動幫我們填上默認值。
createUser(
name = "Tom",
age = 30,
friendCount = 50
)在 Java 當中要實現類似的邏輯，我們就必須手動定義新的“3 個參數的 createUser 函數”，或者是使用 Builder 設計模式。
Classes and Objects
- 類 （Class）
- 抽象類 (Abstract Class)
- 繼承（Extend）
- 接口和實現 （Interface and implements）
- 嵌套類和內部類（ Nested and Inner Classes ）
- 數據類（Data Class ）
-
object 關鍵字
- object：匿名內部類
- object：單例模式
- object：伴生對象
-
擴展 (Extension)
- 什麼是擴展函數和擴展屬性？
- 擴展函數在 Android 中的案例
類 （Class）
Java
public class Person {
private String name;
private int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
// 屬性 name 沒有 setter
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}Class
Kotlin
class Person(val name: String, var age: Int)Kotlin 定義類，同樣使用 class 關鍵字。
Kotlin 定義的類在默認情況下是 public 的。
編譯器會幫我們生成“構造函數”，
對於類當中的屬性，Kotlin 編譯器也會根據實際情況，自動生成 getter 和 setter。
和Java相比 Kotlin 定義一個類足夠簡潔。
抽象類與繼承
抽象類 (Abstract Class)
abstract class Person(val name: String) {
abstract fun walk()
// 省略
}繼承（Extend）
// Java 的繼承
// ↓
public class MainActivity extends Activity {
@Override
void onCreate(){ ... }
}// Kotlin 的繼承
// ↓
class MainActivity : AppCompatActivity() {
override fun onCreate() { ... }
}接口和實現 （Interface and implements）
Kotlin 當中的接口（interface），和 Java 也是大同小異的，它們都是通過 interface 這個關鍵字來定義的。
interface Behavior {
fun walk()
}
class Person(val name: String): Behavior {
override fun walk() {
// walk
}
// ...
}可以看到在以上的代碼中，我們定義了一個新的接口 Behavior，它裏面有一個需要被實現的方法 walk，然後我們在 Person 類當中實現了這個接口。
Kotlin 的繼承和接口實現語法基本上是一樣的。
Kotlin 的接口，跟 Java 最大的差異就在於，接口的方法可以有默認實現，同時，它也可以有屬性。
interface Behavior {
// 接口內的可以有屬性
val canWalk: Boolean
// 接口方法的默認實現
fun walk() {
if (canWalk) {
// do something
}
}
}
class Person(val name: String): Behavior {
// 重寫接口的屬性
override val canWalk: Boolean
get() = true
}我們在接口方法當中，為 walk() 方法提供了默認實現，如果 canWalk 為 true，才執行 walk 內部的具體行為。
Kotlin 當中的接口，被設計得更加強大了。
在 Java 1.8 版本當中，Java接口也引入了類似的特性。
嵌套類和內部類（ Nested and Inner Classes ）
Java 當中，最常見的嵌套類分為兩種：非靜態內部類、靜態內部類。Kotlin 當中也有一樣的概念。
class A {
class B {
}
}以上代碼中，B 類，就是 A 類裏面的嵌套類。
注意: 無法在 B 類當中訪問 A 類的屬性和成員方法。
因為Kotlin 默認嵌套類（B類）是一個靜態內部類
Kotlin 嵌套類反編譯成 Java 代碼：
<img src="http://seachal-blog-picture-host.oss-cn-beijing.aliyuncs.com/MWeb/2023/03/16/16788807777726.jpg" class="m-5 rounded shadow" />
public class JavaOuterInnerClass2 {
// 內部類
public class InnerClass {
}
// 靜態內部類
public static final class StaticInnerClass{
}
}通過 javac 命令 編譯成 class 文件後：
- InnerClass
- StaticInnerClass
通過.class 可以發現，
$InnerClass 持有外部類的引用。
$StaticInnerClass 不持有外部類的引用。
Java 當中的嵌套類，默認情況下，沒有 static關鍵字 時，它就是一個內部類，這樣的內部類是會持有外部類的引用的。
所以，這樣的設計在 Java 當中會非常容易出現內存泄漏！ 而我們之所以會犯這樣的錯誤，往往只是因為忘記加static關鍵字。
Kotlin 則恰好相反，在默認情況下，嵌套類變成了靜態內部類，而這種情況下的嵌套類是不會持有外部類引用的。只有當我們真正需要訪問外部類成員的時候，我們才會加上 inner 關鍵字。這樣一來，默認情況下，開發者是不會犯錯的，只有手動加上 inner 關鍵字之後，才可能會出現內存泄漏，而當我們加上 inner 之後，其實往往也就能夠意識到內存泄漏的風險了。
數據類（Data Class ）
Koltin 數據類 ，就是用於存放數據的類,等價於 POJO （Plain Ordinary Java Object）。要定義一個數據類，我們只需要在普通的類前面加上一個關鍵字 data，就可以把它變成一個"數據類"。
// 數據類當中，最少要有一個屬性
↓
data class Person(val name: String, val age: Int)編譯器會為數據類自動生成一些 POJO 常用的方法
- getter()
- setter()
- equals()；
- hashCode()；
- toString()；
- componentN() 函數；
- copy()。
Koltin 數據類反編譯成 Java代碼：
<img src="http://seachal-blog-picture-host.oss-cn-beijing.aliyuncs.com/MWeb/2023/03/15/16788793363013.jpg" class="m-0 h-110 rounded shadow" />
object 關鍵字
fun 關鍵字代表了定義函數，class 關鍵字代表了定義類，這些都是固定的，object 關鍵字，卻有三種迥然不同的語義，分別可以定義：
- 匿名內部類；
- 單例模式；
- 伴生對象。
之所以會出現這樣的情況，是因為 Kotlin 的設計者認為：
這三種語義本質上都是在定義一個類的同時還創建了對象。
在這樣的情況下，與其分別定義三種不同的關鍵字，還不如將它們統一成 object 關鍵字。
object：匿名內部類
在 Java 開發當中，我們經常需要寫類似這樣的代碼：
public interface Runnable {
void run();
}
public static void main(String[] args) {
// 創建Runnable對象並使用匿名內部類重寫run方法
Runnable runnable = new Runnable() {
public void run() {
System.out.println("Runnable is running");
}
};
// 創建Thread對象並將Runnable作為參數傳入
Thread thread = new Thread(runnable);
// 啓動線程
thread.start();
}這是典型的匿名內部類寫法。
在 Kotlin 當中，我們會使用 object 關鍵字來創建匿名內部類。
interface Runnable {
fun run()
}
@JvmStatic
fun main(args: Array<String>) {
// 創建Runnable對象並使用匿名內部類重寫run方法
val runnable: Runnable = object : Runnable {
override fun run() {
println("Runnable is running")
}
}
// 創建Thread對象並將Runnable作為參數傳入
val thread: Thread = Thread(runnable)
// 啓動線程
thread.start()
}object:單例模式
在 Kotlin 當中，要實現單例模式其實非常簡單，我們直接用 object 修飾類即可：
object UserManager {
fun login() {}
}可以看出，Kotlin 生成單例，代碼量非常少
反編譯後的 Java 代碼：
public final class UserManager {
public static final UserManager INSTANCE;
static {
UserManager var0 = new UserManager();
INSTANCE = var0;
}
private UserManager() {}
public final void login() {}
}Kotlin 編譯器會將其轉換成靜態代碼塊的單例模式。
雖然具有簡潔的優點，但同時也存在兩個缺點。
- 不支持懶加載。
- 不支持傳參構造單例。
object：伴生對象
Kotlin 當中沒有 static 關鍵字，所以我們沒有辦法直接定義靜態方法和靜態變量。不過，Kotlin 還是為我們提供了伴生對象，來幫助實現靜態方法和變量。
Kotlin 伴生：
companion object {
const val LEARNING_FRAGMENT_INDEX = 0
fun jumpToMe(context: Context, index: Int) {
context.startActivity(Intent(context, TrainingHomeActivity::class.java).apply {
putExtra(FRAGMENT_INDEX, index)
})
}
}反編譯後的 Java 代碼：
private Companion() { }
public static final Companion Companion = new Companion((DefaultConstructorMarker)null);
public static final int LEARNING_FRAGMENT_INDEX = 0;
public static final class Companion {
public final void jumpToMe(@NotNull Context context, int index) {
}
}可以看到jumpToMe()並不是靜態方法，它實際上是通過調用單例 Companion 的實例上的方法實現的。
擴展 (Extension)
Kotlin 的擴展（Extension），主要分為兩種語法：
第一個是擴展函數，
第二個是擴展屬性。
從語法上看，擴展看起來就像是我們從類的外部為它擴展了新的成員。
場景：假如我們想修改 JDK 當中的 String，想在它的基礎上增加一個方法“lastElement()”來獲取末尾元素，如果使用 Java，我們是無法通過常規手段實現的，因為我們沒辦法修改 JDK 的源代碼。任何第三方提供的 SDK，我們都無權修改。
不過，藉助 Kotlin 的擴展函數，我們就完全可以在語義層面，來為第三方 SDK 的類擴展新的成員方法和成員屬性。
擴展函數
擴展函數，就是從類的外部擴展出來的一個函數，這個函數看起來就像是類的成員函數一樣
Extension.kt
/*
① ② ③ ④
↓ ↓ ↓ ↓ */
fun String.lastElement(): Char? {
// ⑤
// ↓
if (this.isEmpty()) {
return null
}
return this[length - 1]
}
// 使用擴展函數
fun main() {
val msg = "Hello Wolrd"
// lastElement就像String的成員方法一樣可以直接調用
val last = msg.lastElement() // last = d
}- 註釋①，fun關鍵字，代表我們要定義一個函數。也就是説，不管是定義普通 Kotlin 函數，還是定義擴展函數，我們都需要 fun 關鍵字。
- 註釋②，“String.”，代表我們的擴展函數是為 String 這個類定義的。在 Kotlin 當中，它有一個名字，叫做接收者（Receiver），也就是擴展函數的接收方。
- 註釋③，lastElement()，是我們定義的擴展函數的名稱。
- 註釋④，“Char?”，代表擴展函數的返回值是可能為空的 Char 類型。
- 註釋⑤，“this.”，代表“具體的 String 對象”，當我們調用 msg.lastElement() 的時候，this 就代表了 msg。
擴展函數反編譯成 Java 代碼：
public final class StringExtKt {
@Nullable
public static final Character lastElement(@NotNull String $this$lastElement) {
// 省略
}
}而如果我們將上面的 StringExtKt 修改成 StringUtils，它就變成了典型的 Java 工具類
public final class StringUtils {
public static final Character lastElement(String $this) {
// 省略
}
}
public static final void main() {
Character last = StringUtils.lastElement(msg);
}所以 Kotlin 擴展函數 本質 上和 Java靜態方法 是一樣的。
只是編譯器幫我們做了很多事情， 讓代碼寫起來更簡潔。
擴展屬性
而擴展屬性，則是在類的外部為它定義一個新的成員屬性。
// 接收者類型
// ↓
val String.lastElement: Char?
get() = if (isEmpty()) {
null
} else {
get(length - 1)
}
fun main() {
val msg = "Hello Wolrd"
// lastElement就像String的成員屬性一樣可以直接調用
val last = msg.lastElement // last = d
}擴展函數/擴展屬性對比
轉換成Java代碼後，擴展函數和擴展屬性代碼一致，
和 ` StringUtils.lastElement(msg);
}` 用法是一樣的。
擴展最主要的用途，就是用來取代 Java 當中的各種工具類，比如StringUtils、DateUtils 等等。
擴展函數在 Android 中的案例
用擴展函數簡化Toast的用法：
這是Toast的標準用法,在界面上彈出一段文字提示，代碼很長。
Toast.makeText(context, "This is Toast",Toast.LENGTH_SHORT).show()還容易忘記調show()函數，造成Toast 沒有彈出。
用擴展函數改寫後：
fun String.showToast(context: Context) {
Toast.makeText(context, this, Toast.LENGTH_SHORT).show()
}調用時，只需要在要展示的內容後面調一下showToast（），這樣就簡潔了很多。
"This is Toast".showToast(context)函數與 Lambda 表達式
- 函數類型（Function Type）
- 函數引用 (Function reference）
- 高階函數（Higher-order function）
- 匿名函數 （Anonymous function）
- Lambda Expressions
- 函數式（SAM）接口
- SAM 轉換
- 高階函數應用
函數類型（Function Type）
函數類型（Function Type）就是函數<u>的</u>類型，
在 Kotlin 的世界裏，函數是一等公民
既然變量可以有類型，函數也可以有類型。
// (Int, Int) ->Float 這就是 add 函數的類型
// ↑ ↑ ↑
fun add(a: Int, b: Int): Float { return (a+b).toFloat() }將第三行代碼裏的“ Int Int Float”抽出來，就可以確定該函數的類型。
將函數的“參數類型”和“返回值類型”抽象出來後，加上（），-> 符號加工後，就得到了“函數類型”。
(Int, Int) ->Float 就代表了參數類型是兩個 Int，返回值類型為 Float 的函數類型。
函數引用(Function reference）
普通的變量有引用的概念，我們可以將一個變量賦值給另一個變量，這一點，在函數上也是同樣適用的，函數也有引用，並且也可以賦值給變量。
前面定義的 add 函數,賦值給另一個函數變量時，不能直接用的,
需要使用::操作符 , 後跟要引用的函數名,獲得函數引用後才可以去賦值。
fun add(a: Int, b: Int): Float { return (a+b).toFloat() }
// 變量 函數類型 函數引用
// ↑ ↑ ↑
val function: (Int, Int) -> Float = ::add
println(function(2, 3)) // 輸出 5加了雙冒號:: , 這個函數才變成了一個對象，只有對象才能被賦值給變量。
fun add(a: Int, b: Int): Float { return (a+b).toFloat() }
fun testGaojie() {
println( ::add )
println( (::add)(2, 3) )// 輸出 5.0
}
通過反編譯成 Java 代碼，可以看出。
::add 等價於 Function2 var1 = new Function2(...) ，
是一個FunctionN 類型的對象。
反編譯成 Java代碼：
public final void testGaojie() {
// println( ::add )
Function2 var1 = new Function2((GaojieFunTest)this) {
public Object invoke(Object var1, Object var2) {
return this.invoke(((Number)var1).intValue(), ((Number)var2).intValue());
}
public final float invoke(int p1, int p2) {
return ((GaojieFunTest)this.receiver).add(p1, p2);
}
};
System.out.println(var1);
// println( (::add)(2, 3) )
float var2 = ((Number)((Function2)(new Function2((GaojieFunTest)this) {
public Object invoke(Object var1, Object var2) {
return this.invoke(((Number)var1).intValue(), ((Number)var2).intValue());
}
public final float invoke(int p1, int p2) {
return ((GaojieFunTest)this.receiver).add(p1, p2);
}
})).invoke(2, 3)).floatValue();
System.out.println(var2);
} fun add(a: Int, b: Int): Float { return (a+b).toFloat() }
fun testGaojie() {
println( add(2, 3) )// 輸出 5.0
val function: (Int, Int) -> Float = ::add
println( function(2, 3) ) // 輸出 5.0
println( function.invoke(2, 3) ) // 輸出 5.0
}
將 testGaojie（）轉換成 Java 代碼。可以看到在 Java 裏,
函數類型被聲明為普通的接口：一個函數類型的變量是FunctionN接口的一個實現。Kotlin標準庫定義了一系列的接口，這些接口對應於不同參數數量的函數：Function0<R>（沒有參數的函數）、Function2<P1,P2,R>（2個參數的函數）...Function22<P1,P2 ... R>。每個接口定義了一個invoke()方法，調用這個方法就會執行函數。一個函數類型的變量就是實現了對應的FunctionN接口的實現類的實例。實現類的invoke()方法包含了 函數引用對應的函數的函數體
反編譯成 Java代碼：
public final void testGaojie() {
// println( add(2, 3) )
float var1 = this.add(2, 3);
System.out.println(var1);
// val function: (Int, Int) -> Float = ::add
Function2 function = (Function2)(new Function2((GaojieFunTest)this) {
// $FF: synthetic method
// $FF: bridge method
public Object invoke(Object var1, Object var2) {
return this.invoke(((Number)var1).intValue(), ((Number)var2).intValue());
}
public final float invoke(int p1, int p2) {
return ((GaojieFunTest)this.receiver).add(p1, p2);
}
});
// println( function(2, 3) ) // 輸出 5.0
float var2 = ((Number)function.invoke(2, 3)).floatValue();
System.out.println(var2);
// println( function.invoke(2, 3) ) // 輸出 5.0
var2 = ((Number)function.invoke(2, 3)).floatValue();
System.out.println(var2);
}總結
Kotlin中，函數引用和函數調用有以下區別：
- 函數引用可以視為函數類型的變量，它持有函數的引用。而函數調用則執行函數本身。因此，可以將函數引用傳遞給其他函數，並在需要時執行。
- 函數引用可以簡化調用代碼，避免冗長的代碼。而函數調用則需要編寫完整的函數名稱、參數和參數類型。
- 函數引用不會立即執行函數代碼，只有在需要時才執行。而函數調用則立即執行函數代碼。
例如，假設我們有一個名為“double”的函數，它接受一個整數並返回它的兩倍。那麼，函數引用和函數調用的代碼如下所示：
val doubleFunc: (Int) -> Int = ::double
// 函數調用
val result = double(5) // 返回 10在這個例子中，我們定義了一個函數引用，它可以在需要時傳遞給其他函數，也可以在需要時執行。
第 2 行代碼我們還調用了函數“double”，它立即執行代碼並返回結果。
高階函數 （Higher-order function）
高階函數的定義：高階函數是將函數用作參數或者返回值的函數。
如果一個函數的參數類型是函數類型或者返回值類型是函數類型，那麼這個函數就是就是高階函數 。
或者説，如果一個函數的參數或者返回值，其中有一個是函數，那麼這個函數就是高階函數。
// 函數類型的變量 函數類型
// ↓ ↓
fun higherOrderAdd( a:Int,b: Int,block: (Int, Int) -> Float):Float{
// 函數類型的變量
// ↓
var result = block.invoke(a,b)
// 函數類型的變量
// ↓
var result2 = block(a,b)
println("result:$result")
return result
}
higherOrderAdd 有一個參數是函數類型，所以它是高階函數
匿名函數
匿名函數看起來跟普通函數很相似，除了它的名字和參數類型被省略了外。
匿名函數示例如下：
fun(a :Int, b :Int) = a + b上面的匿名函數是沒法直接調用的，賦值給變量後才可以調用
val anonymousFunction = fun(a :Int, b :Int) = a + b fun anonymousFunctionTest() {
higherOrderAdd(2,2,::add) // 函數引用
higherOrderAdd(2,2,anonymousFunction) // 函數變量
higherOrderAdd(2,2,
fun (a:Int,b:Int):Float{ return (a+b).toFloat()}) // 匿名函數
}匿名函數本質上也是函數類型的對象，所以可以賦值給變量。
匿名函數不能單獨聲明在 （）外面，因為匿名函數是（函數的聲明與函數引用合二為一）
// 具名函數不能直接賦值給變量，因為它不是對象
// 函數（）內不能直接 聲明 具名函數，因為它不是對象
這幾個個報錯是因為，匿名函數是把函數的聲明與函數引用合二為一了，所以在需要匿名函數的地方，聲明一個具名函數是報錯的，正確的做法是改用具名函數引用 例如：
higherOrderAdd(2,2,::add) // 函數引用Lambda
Java 在 Java8中引入的Lambda。
Java Lambda 的基本語法是
(parameters) -> expression 或(請注意語句的花括號)
(parameters) -> { statements; }Kotlin 語言的是可以用 Lambda 表達式作為函數參數的，Lambda就是一小段可以作為參數傳遞的代碼，那麼到底多少代碼才算一小段代碼呢?Kotlin對此並沒有進行限制,但是通常不建議在Lambda 表達式中編寫太長的代碼,否則可能會影響代碼的可讀性。
Lambda也可以理解為是匿名函數的簡寫。
我們來看一下Lambda表達式的語法結構:
{參數名1: 參數類型, 參數名2: 參數類型 -> 函數體}首先最外層是一對花括號{ },如果有參數傳入到Lambda表達式中的話,我們還需要聲明參數列表,參數列表的結尾使用一個 '->' 符號 ,表示參數列表的結束以及函數體的開始,函數體中可以編寫任意行代碼,並且最後一行代碼會自動作為Lambda表達式的返回值。
fun higherOrderAdd( a:Int,b: Int,block: (Int, Int) -> Float):Float{
var result = block(a,b)
println("result:$result")
return result
}
@Test
fun anonymousFunctionTest() {
higherOrderAdd(2,2,::add) // 函數引用
higherOrderAdd(3,3,
fun (a:Int,b:Int):Float{ return (a+b).toFloat()}) // 匿名函數
higherOrderAdd(4,4,
{ a:Int,b:Int -> (a+b).toFloat()}) // Lambda表達式
println(
fun (a:Int,b:Int):Float{ return (a+b).toFloat()}(5,5) ) // 匿名函數直接調用
println(
{ a:Int,b:Int -> (a+b).toFloat()}(5,5)) // Lambda表達式調用
}
相比匿名函數，lambda 表達式定義與引用函數更 簡潔 。
函數式（SAM）接口
SAM 是 Single Abstract Method 的縮寫，只有一個抽象方法的接口稱為函數式接口或 SAM（單一抽象方法）接口。函數式接口可以有多個非抽象成員，但只能有一個抽象成員。
在Java 中可以用註解@FunctionalInterface 聲明一個函數式接口：
@FunctionalInterface
public interface Runnable {
void run();
}在 Kotlin 中可以用 fun 修飾符在 Kotlin 中聲明一個函數式接口：
// 注意 interface 前的 fun
fun interface KRunnable {
fun invoke()
}SAM 轉換
對於函數式接口，可以通過 lambda 表達式實現 SAM 轉換，從而使代碼更簡潔、更有可讀性。
使用 lambda 表達式可以替代手動創建 實現函數式接口的類。 通過 SAM 轉換， Kotlin 可以將 簽名與接口的單個抽象方法的簽名匹配的任何 lambda 表達式，轉換成實現該接口的類的實例。
// 注意需用fun 關鍵字聲明
fun interface Action{
fun run(str:String)
}
fun runAction(action: Action){
action.run("this run")
}fun main() {
// 創建一個 實現函數式接口 的類 的實例（匿名內部類）
val action = object :Action{
override fun run(str: String) {
println(str)
}
}
// 傳入實例，不使用 SAM 轉換
runAction(action)
// 利用 Kotlin 的 SAM 轉換，可以改為以下等效代碼：
// 使用 Lambda表達式替代手動創建 實現函數式接口的類
runAction({
str-> println(str)
})
}fun interface InterfaceApi{
fun run(str:String)
}
fun runInterface(interfaceApi: InterfaceApi){
interfaceApi.run("this run")
}
// 函數類型替代接口定義
fun factionTypeReplaceInterface(block:(String)->Unit){
block("this block run")
}
//=======Test====
// 普通函數，參數是函數式接口對象，傳 函數類型對象 也是可以的
fun testFactionTypeReplaceInterface(){
val function:(String)->Unit = { println(it) }
runInterface(function) //普通函數，參數是函數式接口對象，傳 函數類型對象 也是可以的
factionTypeReplaceInterface(function)
}
// 高階函數， 參數是函數類型對象，傳 是函數式接口對象 是不可以的。
fun testInterface(){
val interfaceApi:InterfaceApi = object :InterfaceApi{
override fun run(str: String) {
println(str)
}
}
runInterface(interfaceApi)
factionTypeReplaceInterface(interfaceApi)// 高階函數， 參數是函數類型對象，傳 是函數式接口對象 是不可以的。
}
普通函數，參數是函數式接口對象，傳 函數類型對象 也是可以的
反過來不可以：
高階函數， 參數是函數類型對象，傳 是函數式接口對象 是不可以的。
前面説的都是函數傳不同的參數類型。
<img src="http://seachal-blog-picture-host.oss-cn-beijing.aliyuncs.com/MWeb/2023/03/23/16795466653507.jpg"/>
這張圖中的三處報錯都是，類型不匹配。
説明：
作為函數實參時， 函數類型對象 單向代替 函數式接口對象。
但是在創建對象時， 函數類型、函數式接口兩種類型是涇渭分明的。
高階函數應用
在Android開發時，我們經常會遇到給自定義View綁定點擊事件的場景。以往通常的做法如下：
// CustomView.java
// 成員變量
private OnContextClickListener mOnContextClickListener;
// 監聽手指點擊內容事件
public void setOnContextClickListener(OnContextClickListener l) {
mOnContextClickListener = l;
}
// 為傳遞這個點擊事件，專門定義了一個接口
public interface OnContextClickListener {
void onContextClick(View v);
}
// 設置手指點擊事件
customView.setOnContextClickListener(new View.OnContextClickListener() {
@Override
public void onContextClick(View v) {
gotoPreview();
}
});看完了這兩段代碼之後，你有沒有覺得這樣的代碼會很囉嗦？因為，真正邏輯只有一行代碼：gotoPreview()，而實際上我們卻寫了 6 行代碼。
用 Kotlin 高階函數 改寫後
//View.kt
// (View) -> Unit 就是「函數類型 」
// ↑ ↑
var mOnContextClickListener: ((View) -> Unit)? = null
// 高階函數
fun setOnContextClickListener(l: (View) -> Unit) {
mOnClickListener = l;
}
如果我們將前面Java寫的例子的核心邏輯提取出來，會發現這樣才是最簡單明瞭的：
// { gotoPreview() } 就是 Lambda
// ↑
customView.setOnContextClickListener({ gotoPreview() })
Kotlin 語言的設計者是怎麼做的呢？實際上他們是分成了兩個部分：
- 用函數類型替代接口定義；
- 用 Lambda 表達式作為函數參數。
Kotlin 中引入高階函數會帶來幾個好處：一個是針對定義方，代碼中減少了接口類的定義；另一個是對於調用方來説，代碼也會更加簡潔。這樣一來，就大大減少了代碼量，提高了代碼可讀性，並通過減少類的數量，提高了代碼的性能。
| 不使用高階函數 | 使用高階函數 | |
|---|---|---|
| 定義方 | 需要額外定義接口 | 不需要額外定義接口 |
| 調用方 | 代碼繁瑣 | 代碼簡潔清晰 |
| 性能 | 差 | 藉助inline的情況，性能更高 |
最後總結
思考討論
本文主要分享了 空安全、擴展函數、高階函數、Lambda,
本文分享的Kotlin內容，您認為哪些特性是最有趣或最有用的？
參考文檔：
- Kotlin 語言中文站
- 《Kotlin實戰》
- 《Kotlin核心編程》
- 《Kotlin編程權威指南》
- 《Java 8實戰》
