Kotlin - 快速指南

---

---

Kotlin - 概述

Kotlin 是一種新的開源程式語言，類似於 Java、JavaScript 等。它是一種高階強型別靜態語言，將函式式和技術部分結合在一個地方。目前，Kotlin 針對 Java 和 JavaScript。它在 JVM 上執行。

Kotlin 受其他程式語言的影響，例如 Java、Scala、Groovy、Gosu 等。Kotlin 的語法可能與 JAVA 不完全相同，但是，在內部，Kotlin 依賴於現有的 Java 類庫為程式設計師提供出色的結果。Kotlin 為全球的開發者提供了互操作性、程式碼安全性和清晰度。

優點和缺點

以下是使用 Kotlin 進行應用程式開發的一些優點。

簡單的語言 - Kotlin 是一種函式式語言，非常易於學習。語法與 Java 非常相似，因此很容易記住。Kotlin 更具表達性，這使得您的程式碼更易於閱讀和理解。

簡潔 - Kotlin 基於 JVM，並且是一種函式式語言。因此，它減少了其他程式語言中使用的許多樣板程式碼。

執行時和效能 - 更好的效能和更小的執行時。

互操作性 - Kotlin 已經足夠成熟，可以以不太複雜的方式構建互操作應用程式。

全新的 - Kotlin 是一種全新的語言，為開發人員提供了一個新的起點。它不是 Java 的替代品，儘管它是在 JVM 上開發的。它被接受為 Android 開發的第一種官方語言。Kotlin 可以定義為 - Kotlin = JAVA + 附加更新的新功能。

以下是 Kotlin 的一些缺點。

名稱空間宣告 - Kotlin 允許開發人員在頂層宣告函式。但是，當在應用程式的許多地方宣告相同的函式時，很難理解正在呼叫哪個函式。

沒有靜態宣告 - Kotlin 沒有像 Java 那樣的常用靜態處理修飾符，這可能會給傳統的 Java 開發人員帶來一些問題。

Kotlin - 環境設定

但是，如果您仍然希望在本地系統中離線使用 Kotlin，則需要執行以下步驟來配置您的本地工作區。

步驟 1 - 安裝 Java 8。

Kotlin 在 JVM 上執行，因此，對於本地 Kotlin 開發來說，使用 JDK 8 非常必要。請參閱 oracle 的官方網站下載並安裝 JDK 8 或更高版本。您可能需要設定 JAVA 的環境變數，以便它能夠正常工作。為了驗證您在 Windows 作業系統中的安裝，請在命令提示符中鍵入“java –version”，作為輸出，它將顯示您系統中安裝的 java 版本。

步驟 2 - 安裝 IDE。

網際網路上有許多 IDE 可供使用。您可以使用任何您選擇的 IDE。您可以在下表中找到不同 IDE 的下載連結。

始終建議使用最新的軟體版本以充分利用其功能。

步驟 3 - 配置 Eclipse。

開啟 Eclipse 並轉到“Eclipse Market Place”。您將看到以下螢幕。

在搜尋框中搜索 Kotlin，並在您的本地系統中安裝它。這可能需要一些時間，具體取決於網路速度。安裝成功後，您可能需要重新啟動 Eclipse。

步驟 4 - Kotlin 專案。

Eclipse 重新啟動並安裝 Kotlin 後，您將能夠即時建立 Kotlin 專案。轉到檔案 → 新建 → 其他，然後從列表中選擇“Kotlin 專案”。

專案設定完成後，您可以在“SRC”資料夾下建立一個 Kotlin 檔案。左鍵單擊“Src”資料夾並點選“新建”。您將獲得 Kotlin 檔案的選項，否則您可能需要從“其他”中搜索。建立新檔案後，您的專案目錄將如下所示。

您的開發環境已準備就緒。繼續並在“Hello.kt”檔案中新增以下程式碼段。

即時演示

fun main(args: Array<String>) {
   println("Hello, World!")
}

將其作為 Kotlin 應用程式執行，並在控制檯中檢視輸出，如下面的螢幕截圖所示。為了更好地理解和可用性，我們將使用我們的編碼場地工具。

Hello, World!

Kotlin - 架構

Kotlin 是一種程式語言，它擁有自己的架構來分配記憶體併為終端使用者生成高質量的輸出。以下是 Kotlin 編譯器在針對不同型別的語言（例如 Java 和 JavaScript）時將以不同方式工作的情況。

Kotlin 編譯器建立位元組碼，該位元組碼可以在 JVM 上執行，這與 Java .class 檔案生成的位元組碼完全相同。當兩個位元組碼檔案在 JVM 上執行時，它們可以相互通訊，這就是 Kotlin 為 Java 建立互操作功能的方式。

當 Kotlin 針對 JavaScript 時，Kotlin 編譯器會將.kt檔案轉換為 ES5.1 併為 JavaScript 生成相容的程式碼。Kotlin 編譯器能夠透過 LLVM 建立平臺基礎相容的程式碼。

Kotlin - 基本型別

在本章中，我們將學習 Kotlin 程式語言中可用的基本資料型別。

數字

Kotlin 中數字的表示與 Java 非常相似，但是，Kotlin 不允許不同資料型別的內部轉換。下表列出了不同數字的不同變數長度。

在下面的示例中，我們將看到 Kotlin 如何處理不同的資料型別。請在我們的編碼場地中輸入以下程式碼集。

即時演示

fun main(args: Array<String>) {
   val a: Int = 10000
   val d: Double = 100.00
   val f: Float = 100.00f
   val l: Long = 1000000004
   val s: Short = 10
   val b: Byte = 1
   
   println("Your Int Value is "+a);
   println("Your Double  Value is "+d);
   println("Your Float Value is "+f);
   println("Your Long Value is "+l);
   println("Your Short Value is "+s);
   println("Your Byte Value is "+b);
}

當您在編碼場地中執行上述程式碼段時，它將在 Web 控制檯中生成以下輸出。

Your Int Value is 10000
Your Double  Value is 100.0
Your Float Value is 100.0
Your Long Value is 1000000004
Your Short Value is 10
Your Byte Value is 1

字元

Kotlin 使用char表示字元。字元應在單引號中宣告，例如‘c’。請在我們的編碼場地中輸入以下程式碼，並檢視 Kotlin 如何解釋字元變數。字元變數不能像數字變數那樣宣告。Kotlin 變數可以透過兩種方式宣告 - 一種使用“var”，另一種使用“val”。

即時演示

fun main(args: Array<String>) {
   val letter: Char    // defining a variable 
   letter = 'A'        // Assigning a value to it 
   println("$letter")
}

上述程式碼段將在瀏覽器輸出視窗中產生以下輸出。

A

布林值

布林值與其他程式語言一樣簡單。布林值只有兩個值 - 真或假。在下面的示例中，我們將看到 Kotlin 如何解釋布林值。

即時演示

fun main(args: Array<String>) {
   val letter: Boolean   // defining a variable 
   letter = true         // Assinging a value to it 
   println("Your character value is "+"$letter")
}

上述程式碼段將在瀏覽器中產生以下輸出。

Your character value is true

字串

字串是字元陣列。與 Java 一樣，它們本質上是不可變的。Kotlin 中有兩種字串 - 一種稱為原始字串，另一種稱為跳脫字元串。在下面的示例中，我們將使用這些字串。

即時演示

fun main(args: Array<String>) {
   var rawString :String  = "I am Raw String!"
   val escapedString : String  = "I am escaped String!\n"
   
   println("Hello!"+escapedString)
   println("Hey!!"+rawString)   
}

跳脫字元串的上述示例允許在第一個 print 語句後提供額外的行間距。以下是瀏覽器中的輸出。

Hello!I am escaped String!

Hey!!I am Raw String!

陣列

陣列是同類資料的集合。與 Java 一樣，Kotlin 支援不同資料型別的陣列。在下面的示例中，我們將使用不同的陣列。

即時演示

fun main(args: Array<String>) {
   val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)
   println("Hey!! I am array Example"+numbers[2])
}

上述程式碼段產生以下輸出。陣列的索引與其他程式語言類似。在這裡，我們正在搜尋第二個索引，其值為“3”。

Hey!! I am array Example3

集合

集合是資料結構中非常重要的一部分，它使軟體開發對工程師來說變得容易。Kotlin 有兩種型別的集合 - 一種是不可變集合（這意味著無法編輯的列表、對映和集合），另一種是可變集合（這種型別的集合是可編輯的）。務必牢記應用程式中使用的集合型別，因為 Kotlin 系統不會在其中表示任何特定差異。

即時演示

fun main(args: Array<String>) { 
   val numbers: MutableList<Int> = mutableListOf(1, 2, 3) //mutable List 
   val readOnlyView: List<Int> = numbers                  // immutable list 
   println("my mutable list--"+numbers)        // prints "[1, 2, 3]" 
   numbers.add(4) 
   println("my mutable list after addition --"+numbers)        // prints "[1, 2, 3, 4]" 
   println(readOnlyView)     
   readOnlyView.clear()    // ⇒ does not compile  
// gives error  
}

上述程式碼段將在瀏覽器中產生以下輸出。當我們嘗試清除集合的可變列表時，它會報錯。

main.kt:9:18: error: unresolved reference: clear
   readOnlyView.clear()    // -> does not compile  
                 ^

在集合中，Kotlin 提供了一些有用的方法，例如first()、last()、filter()等。所有這些方法都是自描述的並且易於實現。此外，Kotlin 在實現集合時遵循與 Java 相同的結構。您可以自由實現任何您選擇的集合，例如 Map 和 Set。

在下面的示例中，我們使用不同的內建方法實現了 Map 和 Set。

即時演示

fun main(args: Array<String>) {
   val items = listOf(1, 2, 3, 4)
   println("First Element of our list----"+items.first())
   println("Last Element of our list----"+items.last())
   println("Even Numbers of our List----"+items.
      filter { it % 2 = = 0 })   // returns [2, 4]
   
   val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
   println(readWriteMap["foo"])  // prints "1"
   
   val strings = hashSetOf("a", "b", "c", "c")
   println("My Set Values are"+strings)
}

上述程式碼段將在瀏覽器中產生以下輸出。

First Element of our list----1
Last Element of our list----4
Even Numbers of our List----[2, 4]
1
My Set Values are[a, b, c]

範圍

範圍是 Kotlin 的另一個獨特特徵。與 Haskell 一樣，它提供了一個運算子，可幫助您遍歷一個範圍。在內部，它是使用rangeTo()實現的，其運算子形式為(..)。

在下面的示例中，我們將看到 Kotlin 如何解釋此範圍運算子。

即時演示

fun main(args: Array<String>) {
   val i:Int  = 2
   for (j in 1..4) 
   print(j) // prints "1234"
   
   if (i in 1..10) { // equivalent of 1 < = i && i < = 10
      println("we found your number --"+i)
   }
}

上述程式碼段將在瀏覽器中產生以下輸出。

1234we found your number --2

Kotlin - 控制流

在上一章中，我們學習了 Kotlin 系統中可用的不同型別的資料型別。在本章中，我們將討論 Kotlin 中可用的不同型別的控制流機制。

If - Else

Kotlin 是一種函式式語言，因此與每種函式式語言一樣，Kotlin 中的“if”是一個表示式，而不是關鍵字。表示式“if”會在需要時返回一個值。與其他程式語言一樣，“if-else”塊用作初始條件檢查運算子。在下面的示例中，我們將比較兩個變數並相應地提供所需的輸出。

即時演示

fun main(args: Array<String>) {
   val a:Int = 5
   val b:Int = 2
   var max: Int
   
   if (a > b) {
      max = a
   } else {
      max = b
   }
   print("Maximum of a or b is " +max)
 
   // As expression 
   // val max = if (a > b) a else b
}

上面這段程式碼在瀏覽器中產生以下輸出作為結果。我們的示例還包含另一行程式碼，它描述瞭如何將“If”語句用作表示式。

Maximum of a or b is 5

When 的使用

如果您熟悉其他程式語言，那麼您可能聽說過 switch 語句，它基本上是一個條件運算子，當多個條件可以應用於特定變數時。“when”運算子將變數值與分支條件進行匹配。如果滿足分支條件，則它將執行該範圍內的語句。在下面的示例中，我們將詳細瞭解 Kotlin 中的“when”。

即時演示

fun main(args: Array<String>) {
   val x:Int = 5
   when (x) {
      1 -> print("x = = 1")
      2 -> print("x = = 2")
      
      else -> { // Note the block
         print("x is neither 1 nor 2")
      }
   }
}

上述程式碼段將在瀏覽器中產生以下輸出。

x is neither 1 nor 2

在上面的示例中，Kotlin 編譯器將x的值與給定的分支進行匹配。如果它與任何分支都不匹配，則它將執行 else 部分。實際上，when 等效於多個 if 塊。Kotlin 為開發人員提供了另一種靈活性，開發人員可以透過在檢查中提供“，”在同一行中提供多個檢查。讓我們修改上面的示例如下。

即時演示

fun main(args: Array<String>) {
   val x:Int = 5
   when (x) {
      1,2 -> print(" Value of X either 1,2")
      
      else -> { // Note the block
         print("x is neither 1 nor 2")
      }
   }
}

在瀏覽器中執行相同的程式碼，它將在瀏覽器中產生以下輸出。

x is neither 1 nor 2

For 迴圈

迴圈是一種如此的發明，它提供了遍歷任何型別的資料結構的靈活性。與其他程式語言一樣，Kotlin 也提供了多種迴圈方法，但是，其中“For”是最成功的一種。For 迴圈的實現和使用在概念上類似於 Java for 迴圈。以下示例顯示瞭如何在現實生活示例中使用它。

即時演示

fun main(args: Array<String>) {
   val items = listOf(1, 2, 3, 4)
   for (i in items) println("values of the array"+i)
}

在上面的程式碼片段中，我們聲明瞭一個名為“items”的列表，並使用 for 迴圈遍歷該定義的列表並在瀏覽器中列印其值。以下是輸出。

values of the array1
values of the array2
values of the array3
values of the array4

以下是另一個程式碼示例，我們使用一些庫函式使我們的開發工作比以往任何時候都更容易。

即時演示

fun main(args: Array<String>) {
   val items = listOf(1, 22, 83, 4)
   
   for ((index, value) in items.withIndex()) {
      println("the element at $index is $value")
   }
}

一旦我們在我們的編碼環境中編譯並執行上面的程式碼片段，它將在瀏覽器中產生以下輸出。

the element at 0 is 1
the element at 1 is 22
the element at 2 is 83
the element at 3 is 4

While 迴圈和 Do-While 迴圈

While 和 Do-While 的工作方式與其他程式語言中的工作方式完全相同。這兩個迴圈之間的唯一區別是，在 Do-while 迴圈的情況下，條件將在迴圈結束時進行測試。以下示例顯示了While 迴圈的使用。

即時演示

fun main(args: Array<String>) {
   var x:Int = 0
   println("Example of While Loop--")
   
   while(x< = 10) {
      println(x)
      x++
   } 
}

上述程式碼段將在瀏覽器中產生以下輸出。

Example of While Loop--
0
1
2
3
4
5
6
7
8
9
10

Kotlin 還具有另一個稱為 Do-While 迴圈的迴圈，其中迴圈體將執行一次，然後才會檢查條件。以下示例顯示了Do-while 迴圈的使用。

即時演示

fun main(args: Array<String>) {
   var x:Int = 0
   do {
      x = x + 10
      println("I am inside Do block---"+x)
   } while(x <= 50)
}

上面的程式碼片段在瀏覽器中產生以下輸出。在上面的程式碼中，Kotlin 編譯器將執行 DO 塊，然後它將轉到 while 塊中的條件檢查。

I am inside Do block---10
I am inside Do block---20
I am inside Do block---30
I am inside Do block---40
I am inside Do block---50
I am inside Do block---60

Return、Break、Continue 的使用

如果您熟悉任何程式語言，那麼您一定對幫助我們在應用程式中實現良好控制流的不同關鍵字有所瞭解。以下是可用於控制迴圈或任何其他型別控制流的不同關鍵字。

Return - Return 是一個關鍵字，它從被呼叫函式返回一些值到呼叫函式。在下面的示例中，我們將使用我們的 Kotlin 編碼環境來實現這種情況。

即時演示

fun main(args: Array<String>) {
   var x:Int = 10
   println("The value of X is--"+doubleMe(x))
}
fun doubleMe(x:Int):Int {
   return 2*x;
}

在上面的程式碼片段中，我們正在呼叫另一個函式並將輸入乘以 2，並將結果值返回到呼叫函式，即我們的主函式。Kotlin 以不同的方式定義函式，我們將在後續章節中介紹。目前，瞭解上面程式碼將在瀏覽器中生成以下輸出就足夠了。

The value of X is--20

Continue & Break - Continue 和 break 是邏輯問題中最重要的一部分。“break”關鍵字在某些條件失敗時終止控制器流，而“continue”則執行相反的操作。所有這些操作都立即可見。Kotlin 比其他程式語言更智慧，在其中開發人員可以應用多個標籤作為可見性。以下程式碼片段顯示了我們如何在 Kotlin 中實現此標籤。

即時演示

fun main(args: Array<String>) {
   println("Example of Break and Continue")
   myLabel@ for(x in 1..10) { // appling the custom label
      if(x = = 5) {
         println("I am inside if block with value"+x+"\n-- hence it will close the operation")
         break@myLabel //specifing the label
      } else {
         println("I am inside else block with value"+x)
         continue@myLabel
      }
   }
}

上述程式碼段將在瀏覽器中產生以下輸出。

Example of Break and Continue
I am inside else block with value1
I am inside else block with value2
I am inside else block with value3
I am inside else block with value4
I am inside if block with value5
-- hence it will close the operation

如您所見，控制器繼續迴圈，直到且僅當x的值為 5 為止。一旦x的值達到 5，它就開始執行 if 塊，並且一旦到達 break 語句，整個控制流就會終止程式執行。

Kotlin - 類和物件

在本章中，我們將學習使用 Kotlin 進行面向物件程式設計 (OOP) 的基礎知識。我們將學習類及其物件以及如何操作該物件。根據 OOP 的定義，類是執行時實體的藍圖，而物件是其狀態，包括其行為和狀態。在 Kotlin 中，類宣告包含類頭和用花括號括起來的類體，類似於 Java。

Class myClass { // class Header 

   // class Body
}

與 Java 一樣，Kotlin 也允許建立類的多個物件，您可以自由地包含其類成員和函式。我們可以使用不同的關鍵字來控制類成員變數的可見性，我們將在第 10 章“可見性控制”中學習這些關鍵字。在下面的示例中，我們將建立一個類及其物件，透過該物件我們將訪問該類的不同資料成員。

即時演示

class myClass {
   // property (data member)
   private var name: String = "Tutorials.point"
   
   // member function
   fun printMe() {
      print("You are at the best Learning website Named-"+name)
   }
}
fun main(args: Array<String>) {
   val obj = myClass() // create obj object of myClass class
   obj.printMe()
}

上面的程式碼片段將在瀏覽器中產生以下輸出，我們使用自己的物件呼叫 myClass 的 printMe()。

You are at the best Learning website Named- Tutorials.point

巢狀類

根據定義，當一個類在另一個類內部建立時，它被稱為巢狀類。在 Kotlin 中，巢狀類預設是靜態的，因此，無需建立該類的任何物件即可訪問它。在下面的示例中，我們將看到 Kotlin 如何解釋我們的巢狀類。

即時演示

fun main(args: Array<String>) {
   val demo = Outer.Nested().foo() // calling nested class method
   print(demo)
}
class Outer {
   class Nested {
      fun foo() = "Welcome to The TutorialsPoint.com"
   }
}

上述程式碼段將在瀏覽器中產生以下輸出。

Welcome to The TutorialsPoint.com

內部類

當巢狀類被標記為“inner”時，它將被稱為內部類。內部類可以透過外部類的資料成員進行訪問。在下面的示例中，我們將訪問外部類的資料成員。

即時演示

fun main(args: Array<String>) {
   val demo = Outer().Nested().foo() // calling nested class method
   print(demo)
}
class Outer {
   private val welcomeMessage: String = "Welcome to the TutorialsPoint.com"
   inner class Nested {
      fun foo() = welcomeMessage
   }
}

上面的程式碼片段將在瀏覽器中產生以下輸出，我們使用 Kotlin 編譯器在編譯時提供的預設建構函式呼叫巢狀類。

Welcome to the TutorialsPoint.com

匿名內部類

匿名內部類是一個非常好的概念，它使程式設計師的生活變得非常輕鬆。每當我們實現一個介面時，匿名內部塊的概念就會出現。使用執行時物件引用建立介面物件的概念稱為匿名類。在下面的示例中，我們將建立一個介面，並使用匿名內部類機制建立該介面的物件。

即時演示

fun main(args: Array<String>) {
   var programmer :Human = object:Human // creating an instance of the interface {
      override fun think() { // overriding the think method
         print("I am an example of Anonymous Inner Class ")
      }
   }
   programmer.think()
}
interface Human {
   fun think()
}

上述程式碼段將在瀏覽器中產生以下輸出。

I am an example of Anonymous Inner Class 

類型別名

類型別名是 Kotlin 編譯器的一個特性。它提供了建立現有型別新名稱的靈活性，它不會建立新型別。如果型別名稱太長，您可以輕鬆地引入一個較短的名稱並在以後使用中使用它。類型別名對於複雜型別非常有用。在最新版本中，Kotlin 取消了對類型別名的支援，但是，如果您使用的是舊版本的 Kotlin，您可以像下面這樣使用它 -

typealias NodeSet = Set<Network.Node>
typealias FileTable<K> = MutableMap<K, MutableList<File>>

Kotlin - 建構函式

在本章中，我們將學習 Kotlin 中的建構函式。Kotlin 有兩種型別的建構函式 - 一種是主建構函式，另一種是次建構函式。一個 Kotlin 類可以有一個主建構函式，一個或多個次建構函式。Java 建構函式初始化成員變數，但在 Kotlin 中，主建構函式初始化類，而次建構函式有助於在初始化類時包含一些額外的邏輯。主建構函式可以在類頭級別宣告，如以下示例所示。

class Person(val firstName: String, var age: Int) {
   // class body
}

在上面的示例中，我們在括號內聲明瞭主建構函式。在這兩個欄位中，firstName 是隻讀的，因為它被宣告為“val”，而欄位 age 可以編輯。在下面的示例中，我們將使用主建構函式。

即時演示

fun main(args: Array<String>) {
   val person1 = Person("TutorialsPoint.com", 15)
   println("First Name = ${person1.firstName}")
   println("Age = ${person1.age}")
}
class Person(val firstName: String, var age: Int) {
}

上面的程式碼片段將自動初始化這兩個變數並在瀏覽器中提供以下輸出。

First Name = TutorialsPoint.com
Age = 15

如前所述，Kotlin 允許為您的類建立一個或多個次建構函式。此次建構函式是使用“constructor”關鍵字建立的。當您想在 Kotlin 中建立多個建構函式時，或者當您想在主建構函式中包含更多邏輯並且您無法這樣做時，這是必需的，因為主建構函式可能會被其他類呼叫。檢視下面的示例，我們在這裡建立了一個次建構函式，並使用上面的示例來實現它。

即時演示

fun main(args: Array<String>) {
   val HUman = HUman("TutorialsPoint.com", 25)
   print("${HUman.message}"+"${HUman.firstName}"+
      "Welcome to the example of Secondary  constructor, Your Age is-${HUman.age}")
}
class HUman(val firstName: String, var age: Int) {
   val message:String  = "Hey!!!"
	constructor(name : String , age :Int ,message :String):this(name,age) {
   }
}

注意 - 可以建立任意數量的次建構函式，但是所有這些建構函式都應該直接或間接地呼叫主建構函式。

上述程式碼段將在瀏覽器中產生以下輸出。

Hey!!! TutorialsPoint.comWelcome to the example of Secondary  constructor, Your Age is- 25

Kotlin - 繼承

在本章中，我們將學習繼承。根據定義，我們都知道繼承意味著將母類的某些屬性累積到子類中。在 Kotlin 中，基類名為“Any”，它是 Kotlin 中宣告的“any”預設類的超類。與所有其他 OOPS 一樣，Kotlin 也使用一個名為“:”的關鍵字提供此功能。

Kotlin 中的所有內容預設都是最終的，因此，我們需要在類宣告前面使用關鍵字“open”才能使其允許繼承。檢視以下繼承示例。

即時演示

import java.util.Arrays

open class ABC {
   fun think () {
      print("Hey!! i am thiking ")
   }
}
class BCD: ABC(){ // inheritence happend using default constructor 
}

fun main(args: Array<String>) {
   var  a = BCD()
   a.think()
}

上述程式碼段將在瀏覽器中產生以下輸出。

Hey!! i am thiking 

現在，如果我們想在子類中覆蓋 think() 方法怎麼辦。然後，我們需要考慮以下示例，我們在這裡建立了兩個類並在子類中覆蓋了其中一個函式。

即時演示

import java.util.Arrays

open class ABC {
   open fun think () {
      print("Hey!! i am thinking ")
   }
}
class BCD: ABC() { // inheritance happens using default constructor 
   override fun think() {
      print("I Am from Child")
   }
}
fun main(args: Array<String>) {
   var  a = BCD()
   a.think()
}

上面的程式碼片段將呼叫子類繼承的方法，它將在瀏覽器中產生以下輸出。與 Java 一樣，Kotlin 也不允許多重繼承。

I Am from Child 

Kotlin - 介面

在本章中，我們將學習 Kotlin 中的介面。在 Kotlin 中，介面的工作方式與 Java 8 完全相同，這意味著它們可以包含方法實現以及抽象方法宣告。類可以實現介面以使用其定義的功能。我們已經在第 6 章 - “匿名內部類”部分介紹了一個介面示例。在本章中，我們將進一步瞭解它。“interface”關鍵字用於在 Kotlin 中定義介面，如以下程式碼片段所示。

interface ExampleInterface {
   var myVar: String     // abstract property
   fun absMethod()       // abstract method
   fun sayHello() = "Hello there" // method with default implementation
}

在上面的示例中，我們建立了一個名為“ExampleInterface”的介面，並在其中我們總共有幾個抽象屬性和方法。檢視名為“sayHello()”的函式，它是一個已實現的方法。

在下面的示例中，我們將實現上面的介面在一個類中。

即時演示

interface ExampleInterface  {
   var myVar: Int            // abstract property
   fun absMethod():String    // abstract method
   
   fun hello() {
      println("Hello there, Welcome to TutorialsPoint.Com!")
   }
}
class InterfaceImp : ExampleInterface {
   override var myVar: Int = 25
   override fun absMethod() = "Happy Learning "
}
fun main(args: Array<String>) {
   val obj = InterfaceImp()
   println("My Variable Value is = ${obj.myVar}")
   print("Calling hello(): ")
   obj.hello()
   
   print("Message from the Website-- ")
   println(obj.absMethod())
}

上述程式碼段將在瀏覽器中產生以下輸出。

My Variable Value is = 25
Calling hello(): Hello there, Welcome to TutorialsPoint.Com!
Message from the Website-- Happy Learning 

如前所述，Kotlin 不支援多重繼承，但是可以透過一次實現多個介面來實現相同的功能。

在下面的示例中，我們將建立兩個介面，然後我們將這兩個介面實現到一個類中。

即時演示

interface A {
   fun printMe() {
      println(" method of interface A")
   }
}
interface B  {
   fun printMeToo() {
      println("I am another Method from interface B")
   }
}

// implements two interfaces A and B
class multipleInterfaceExample: A, B

fun main(args: Array<String>) {
   val obj = multipleInterfaceExample()
   obj.printMe()
   obj.printMeToo()
}

在上面的示例中，我們建立了兩個示例介面 A、B，並在名為“multipleInterfaceExample”的類中，我們實現了前面宣告的兩個介面。上面的程式碼片段將在瀏覽器中產生以下輸出。

method of interface A
I am another Method from interface B

Kotlin - 可見性控制

在本章中，我們將學習 Kotlin 語言中可用的不同修飾符。訪問修飾符用於限制應用程式中使用的變數、方法和類的使用。與其他 OOP 程式語言一樣，此修飾符適用於多個位置，例如類頭或方法宣告。Kotlin 中有四種訪問修飾符可用。

私有

類、方法和包可以使用 private 修飾符宣告。一旦任何內容被宣告為 private，那麼它只能在其直接作用域內訪問。例如，私有包可以在該特定檔案中訪問。私有類或介面只能被其資料成員訪問，等等。

private class privateExample {
   private val i = 1
   private val doSomething() {
   }
}

在上面的示例中，類“privateExample”和變數 i 都只能在同一個 Kotlin 檔案中訪問，因為它們都在宣告塊中宣告為 private。

Protected

Protected 是 Kotlin 的另一個訪問修飾符，目前它不適用於頂級宣告，例如任何包都不能是 protected。受保護的類或介面僅對其子類可見。

class A() {
   protected val i = 1
}
class B : A() {
   fun getValue() : Int {
      return i
   }
}

在上面的示例中，變數“i”宣告為 protected，因此，它僅對其子類可見。

Internal

Internal 是 Kotlin 中引入的一個新的修飾符。如果任何內容被標記為 internal，那麼該特定欄位將位於內部欄位中。內部包僅在其實現的模組內部可見。內部類介面僅對存在於同一包或模組中的其他類可見。在以下示例中，我們將看到如何實現內部方法。

class internalExample {
   internal val i = 1
   internal fun doSomething() {
   }
}

在上面的示例中，名為“doSomething”的方法和變數被標記為 internal，因此，這兩個欄位只能在宣告它們的包內部訪問。

Public

Public 修飾符可以在專案工作區的任何地方訪問。如果未指定訪問修飾符，則預設情況下它將處於 public 作用域。在我們之前的所有示例中，我們都沒有提到任何修飾符，因此，它們都處於 public 作用域。以下是一個示例，以瞭解有關如何宣告公共變數或方法的更多資訊。

class publicExample {
   val i = 1
   fun doSomething() {
   }
}

在上面的示例中，我們沒有提到任何修飾符，因此所有這些方法和變數預設都是 public 的。

Kotlin - 擴充套件

在本章中，我們將學習 Kotlin 的另一個新特性“擴充套件”。使用擴充套件，我們將能夠新增或刪除某些方法功能，即使不繼承或修改它們。擴充套件是靜態解析的。它實際上並沒有修改現有的類，而是建立一個可呼叫的函式，可以透過點運算子呼叫。

函式擴充套件

在函式擴充套件中，Kotlin 允許在主類之外定義方法。在以下示例中，我們將看到如何在函式級別實現擴充套件。

即時演示

class Alien {
   var skills : String = "null"
	
   fun printMySkills() {
      print(skills)
   }		
}
fun main(args: Array<String>) {
   var  a1 = Alien()
   a1.skills = "JAVA"
   //a1.printMySkills()
	
   var  a2 = Alien()
   a2.skills = "SQL"
   //a2.printMySkills()
	
   var  a3 = Alien()
   a3.skills = a1.addMySkills(a2)
   a3.printMySkills()
}
fun Alien.addMySkills(a:Alien):String{
   var a4 = Alien()
   a4.skills = this.skills + " " +a.skills
   return a4.skills
}

在上面的示例中，“Alien”類中沒有任何名為“addMySkills()”的方法，但是，我們仍然在類外部的其他地方實現了相同的方法，這就是擴充套件的魔力。

上面的程式碼將在瀏覽器中生成以下輸出。

JAVA SQL

物件擴充套件

Kotlin 提供了另一種實現 Java 靜態功能的機制。這可以透過使用關鍵字“companion object”來實現。使用這種機制，我們可以在工廠方法內部建立類的物件，然後我們可以使用類名的引用來呼叫該方法。在以下示例中，我們將建立一個“companion object”。

即時演示

fun main(args: Array<String>) {
   println("Heyyy!!!"+A.show())
}
class A {
   companion object {
      fun show():String {
         return("You are learning Kotlin from TutorialsPoint.com")
      }
   }
}

上述程式碼段將在瀏覽器中產生以下輸出。

Heyyy!!! You are learning Kotlin from TutorialsPoint.com

上面的示例看起來像 Java 中的靜態方法，但是，在實際執行時，我們正在建立作為同一類成員變數的物件。這就是為什麼它也包含在擴充套件屬性下，並且可以替代地稱為物件擴充套件。您基本上是在擴充套件同一類的物件以使用某些成員函式。

Kotlin - 資料類

在本章中，我們將進一步瞭解 Kotlin 程式語言的資料類。當類被標記為“data”時，它可以被標記為資料類。這種型別的類可以用來儲存基本資料。除此之外，它不提供任何其他功能。

所有資料類都需要有一個主建構函式，並且所有主建構函式都必須至少有一個引數。每當一個類被標記為資料類時，我們可以使用該資料類的一些內建函式，例如“toString()”、“hashCode()”等。任何資料類都不能有像 abstract 和 open 或 internal 這樣的修飾符。資料類也可以擴充套件到其他類。在以下示例中，我們將建立一個數據類。

即時演示

fun main(args: Array<String>) {
   val book: Book = Book("Kotlin", "TutorialPoint.com", 5)
   println("Name of the Book is--"+book.name) // "Kotlin"
   println("Puclisher Name--"+book.publisher) // "TutorialPoint.com"
   println("Review of the book is--"+book.reviewScore) // 5
   book.reviewScore = 7
   println("Printing all the info all together--"+book.toString()) 
   //using inbuilt function of the data class 
   
   println("Example of the hashCode function--"+book.hashCode())
}

data class Book(val name: String, val publisher: String, var reviewScore: Int)

上面的程式碼將在瀏覽器中產生以下輸出，其中我們建立了一個數據類來儲存一些資料，並且從主函式中我們訪問了其所有資料成員。

Name of the Book is--"Kotlin"
Puclisher Name--"TutorialPoint.com"
Review of the book is--5
Printing all the info all together--(name-Kotlin, publisher-TutorialPoint.com, reviewScore-7)
Example of the hashCode function---1753517245

Kotlin - 密封類

在本章中，我們將學習另一種稱為“Sealed”類的類型別。這種型別的類用於表示受限的類層次結構。Sealed 允許開發人員維護預定義型別的資料型別。要建立一個密封類，我們需要使用關鍵字“sealed”作為該類的修飾符。密封類可以有自己的子類，但所有這些子類都需要與密封類一起在同一個 Kotlin 檔案中宣告。在以下示例中，我們將看到如何使用密封類。

即時演示

sealed class MyExample {
   class OP1 : MyExample() // MyExmaple class can be of two types only
   class OP2 : MyExample()
}
fun main(args: Array<String>) {
   val obj: MyExample = MyExample.OP2() 
   
   val output = when (obj) { // defining the object of the class depending on the inuputs 
      is MyExample.OP1 -> "Option One has been chosen"
      is MyExample.OP2 -> "option Two has been chosen"
   }
   
   println(output)
}

在上面的示例中，我們有一個名為“MyExample”的密封類，它只有兩種型別 - 一種是“OP1”，另一種是“OP2”。在主類中，我們在類中建立一個物件並在執行時分配其型別。現在，由於此“MyExample”類是密封的，因此我們可以在執行時應用“when”子句來實現最終輸出。

在密封類中，我們不需要使用任何不必要的“else”語句來使程式碼複雜化。上面的程式碼將在瀏覽器中產生以下輸出。

option Two has been chosen

Kotlin - 泛型

與 Java 一樣，Kotlin 提供了更高階的變數型別，稱為泛型。在本章中，我們將學習 Kotlin 如何實現泛型以及作為開發人員我們如何使用泛型庫中提供的那些功能。在實現方面，泛型與 Java 非常相似，但 Kotlin 開發人員引入了兩個新關鍵字“out”和“in”，使 Kotlin 程式碼更具可讀性，並方便開發人員使用。

在 Kotlin 中，類和型別是完全不同的概念。根據示例，List 是 Kotlin 中的一個類，而 List<String> 是 Kotlin 中的一個型別。以下示例描述了 Kotlin 中泛型的實現方式。

fun main(args: Array<String>) {
   val integer: Int = 1
   val number: Number = integer
   print(number)
}

在上面的程式碼中，我們聲明瞭一個“integer”，然後我們將該變數分配給一個數字變數。這是可能的，因為“Int”是 Number 類的子類，因此型別轉換在執行時自動發生併產生輸出“1”。

讓我們進一步瞭解 Kotlin 中的泛型。當我們不確定將在應用程式中使用的資料型別時，最好使用泛型資料型別。通常，在 Kotlin 中，泛型由<T>定義，其中“T”代表模板，它可以由 Kotlin 編譯器動態確定。在以下示例中，我們將看到如何在 Kotlin 程式語言中使用泛型資料型別。

即時演示

fun main(args: Array<String>) {
   var objet = genericsExample<String>("JAVA")
   var objet1 = genericsExample<Int>(10)
}
class genericsExample<T>(input:T) {
   init {
      println("I am getting called with the value "+input)
   }
}

在上面的程式碼片段中，我們正在建立一個具有泛型返回型別的類，它表示為<T>。看看 main 方法，我們在執行時動態定義了它的值，在建立該類的物件時提供了值型別。這就是 Kotlin 編譯器如何解釋泛型的。當我們在程式碼環境中執行此程式碼時，將在瀏覽器中獲得以下輸出。

I am getting called with the value JAVA
I am getting called with the value 10

當我們想要將泛型型別分配給其任何超型別時，我們需要使用“out”關鍵字，當我們想要將泛型型別分配給其任何子型別時，我們需要使用“in”關鍵字。在以下示例中，我們將使用“out”關鍵字。同樣，您可以嘗試使用“in”關鍵字。

即時演示

fun main(args: Array<String>) {
   var objet1 = genericsExample<Int>(10)
   var object2 = genericsExample<Double>(10.00)
   println(objet1)
   println(object2)
}
class genericsExample<out T>(input:T) {
   init {
      println("I am getting called with the value "+input)
   }
}

上面的程式碼將在瀏覽器中產生以下輸出。

I am getting called with the value 10
I am getting called with the value 10.0
genericsExample@28d93b30
genericsExample@1b6d3586

Kotlin - 委託

Kotlin 透過引入一個新的關鍵字“by”來支援“委託”設計模式。使用此關鍵字或委託方法，Kotlin 允許派生類透過特定物件訪問介面的所有已實現的公共方法。以下示例演示了 Kotlin 中是如何發生的。

即時演示

interface Base {
   fun printMe() //abstract method
}
class BaseImpl(val x: Int) : Base {
   override fun printMe() { println(x) }   //implementation of the method
}
class Derived(b: Base) : Base by b  // delegating the public method on the object b

fun main(args: Array<String>) {
   val b = BaseImpl(10)
   Derived(b).printMe() // prints 10 :: accessing the printMe() method 
}

在示例中，我們有一個介面“Base”，其抽象方法名為“printme()”。在 BaseImpl 類中，我們實現了這個“printme()”，然後從另一個類中使用“by”關鍵字使用此實現。

上述程式碼段將在瀏覽器中產生以下輸出。

10

屬性委託

在上一節中，我們學習了使用“by”關鍵字的委託設計模式。在本節中，我們將學習如何使用 Kotlin 庫中提到的某些標準方法來委託屬性。

委託意味著將責任傳遞給另一個類或方法。當屬性已在某些地方宣告時，我們應該重用相同的程式碼來初始化它們。在以下示例中，我們將使用 Kotlin 提供的一些標準委託方法和一些標準庫函式在我們的示例中實現委託。

使用 Lazy()

Lazy 是一個 lambda 函式，它將屬性作為輸入，並返回Lazy<T>的例項，其中<T>基本上是它正在使用的屬性的型別。讓我們看看以下內容以瞭解其工作原理。

即時演示

val myVar: String by lazy {
   "Hello"
}
fun main(args: Array<String>) {
   println(myVar +" My dear friend")
}

在上面的程式碼片段中，我們將變數“myVar”傳遞給 Lazy 函式，該函式依次將值分配給其物件並將相同的值返回給主函式。以下是瀏覽器中的輸出。

Hello My dear friend

Delegetion.Observable()

Observable() 接受兩個引數來初始化物件，並將相同的值返回給被呼叫函式。在以下示例中，我們將看到如何使用 Observable() 方法來實現委託。

即時演示

import kotlin.properties.Delegates
class User {
   var name: String by Delegates.observable("Welcome to Tutorialspoint.com") {
      prop, old, new ->
      println("$old -> $new")
   }
}
fun main(args: Array<String>) {
   val user = User()
   user.name = "first"
   user.name = "second"
}

上述程式碼段將在瀏覽器中產生以下輸出。

first -> second

一般來說，“by”關鍵字後的表示式是委託的。變數p的get()和set()方法將被委託給在 Delegate 類中定義的getValue()和setValue()方法。

class Example {
   var p: String by Delegate()
}

對於上面的程式碼片段，以下是我們需要生成的委託類，以便在變數p中分配值。

class Delegate {
   operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
      return "$thisRef, thank you for delegating '${property.name}' to me!"
   }
   operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
      println("$value has been assigned to '${property.name} in $thisRef.'")
   }
}

在讀取時，將呼叫 getValue() 方法，而在設定變數時，將呼叫 setValue() 方法。

Kotlin - 函式

Kotlin 是一種靜態型別語言，因此函式在其中發揮著重要作用。我們非常熟悉函式，因為我們在整個示例中都在使用函式。函式用關鍵字“fun”宣告。像任何其他 OOP 一樣，它也需要一個返回型別和一個可選的引數列表。

在以下示例中，我們定義了一個名為 MyFunction 的函式，並在主函式中呼叫此函式並傳遞一些引數。

即時演示

fun main(args: Array<String>) {
   println(MyFunction("tutorialsPoint.com"))
}
fun MyFunction(x: String): String {
   var c:String  = "Hey!! Welcome To ---"
   return (c+x)
}

上述程式碼段將在瀏覽器中產生以下輸出。

Hey!! Welcome To ---tutorialsPoint.com

函式應按如下方式宣告：

fun <nameOfFunction>(<argument>:<argumentType>):<ReturnType>

以下是 Kotlin 中一些不同型別的函式。

Lambda 函式

Lambda 是一種高階函式，在宣告函式和定義函式時可以大幅減少樣板程式碼。Kotlin 允許你定義自己的 Lambda。在 Kotlin 中，你可以宣告你的 Lambda 並將其傳遞給一個函式。

請看下面的例子。

即時演示

fun main(args: Array<String>) {
   val mylambda :(String)->Unit  = {s:String->print(s)}
   val v:String = "TutorialsPoint.com"
   mylambda(v)
}

在上面的程式碼中，我們建立了自己的 Lambda，名為“mylambda”，並將一個變數傳遞給了這個 Lambda，該變數的型別為 String，值是“TutorialsPoint.com”。

上述程式碼段將在瀏覽器中產生以下輸出。

TutorialsPoint.com

行內函數

上面的例子展示了我們可以在 Kotlin 應用程式中使用的 Lambda 表示式的基本用法。現在，我們可以將 Lambda 傳遞給另一個函式以獲取輸出，這使得呼叫函式成為行內函數。

請看下面的例子。

即時演示

fun main(args: Array<String>) {
   val mylambda:(String)->Unit  = {s:String->print(s)}
   val v:String = "TutorialsPoint.com"
   myFun(v,mylambda) //passing lambda as a parameter of another function 
}
fun myFun(a :String, action: (String)->Unit) { //passing lambda 
   print("Heyyy!!!")
   action(a)// call to lambda function
}

上面的程式碼將在瀏覽器中產生以下輸出。使用行內函數，我們傳遞了一個 Lambda 作為引數。任何其他函式都可以使用“inline”關鍵字將其設定為行內函數。

Heyyy!!!TutorialsPoint.com

Kotlin - 解構宣告

Kotlin 包含其他程式語言的許多特性。它允許你同時宣告多個變數。這種技術稱為解構宣告。

以下是解構宣告的基本語法。

val (name, age) = person

在上面的語法中，我們建立了一個物件並在單個語句中一起定義了它們。稍後，我們可以按如下方式使用它們。

println(name)
println(age)

現在，讓我們看看如何在實際應用中使用它。考慮以下示例，我們建立了一個包含一些屬性的 Student 類，稍後我們將使用它們來列印物件的值。

即時演示

fun main(args: Array<String>) {
   val s = Student("TutorialsPoint.com","Kotlin")
   val (name,subject) = s
   println("You are learning "+subject+" from "+name)
}
data class Student( val a :String,val b: String ){
   var name:String = a
   var subject:String = b
}

上述程式碼段將在瀏覽器中產生以下輸出。

You are learning Kotlin from TutorialsPoint.com

Kotlin - 異常處理

異常處理是程式語言中非常重要的一部分。此技術可以防止應用程式在執行時生成錯誤的輸出。在本章中，我們將學習如何在 Kotlin 中處理執行時異常。Kotlin 中的異常與 Java 中的異常非常相似。所有異常都是“Throwable”類的子類。以下示例展示瞭如何在 Kotlin 中使用異常處理技術。

fun main(args: Array<String>) {
   try {
      val myVar:Int = 12;
      val v:String = "Tutorialspoint.com";
      v.toInt();
   } catch(e:Exception) {
      e.printStackTrace();
   } finally {
      println("Exception Handeling in Kotlin");
   }
}

在上面的程式碼片段中，我們聲明瞭一個字串，然後將其轉換為整數，這實際上是一個執行時異常。因此，我們將在瀏覽器中得到以下輸出。

val myVar:Int = 12;
Exception Handeling in Kotlin

注意 - 與 Java 一樣，Kotlin 也會在執行 catch 塊後執行 finally 塊。