Kotlin ist eine neue JVM-basierte Programmiersprache, die von JetBrains entwickelt wurde. Im Vergleich zu Java ist die Syntax von Kotlin einfacher, ausdrucksvoller und bietet mehr Funktionen.
Kotlin wurde speziell für Java-Entwickler entwickelt, mit Intellij als primärer Entwicklungs-IDE. Für Android-Entwickler gibt es zwei interessante Funktionen:
- Für Java-Entwickler ist Kotlin sehr intuitiv und leicht zu erlernen. Der Großteil der Sprache ist dem, was wir kennen, sehr ähnlich, sodass wir sie schnell beherrschen können.
- Als derzeit beliebtestes Android-Entwicklungstool kann Android Studio Kotlin-Code perfekt verstehen, kompilieren und ausführen.
Warum Kotlin wählen?
- Einfachheit: Reduziert die Menge an Boilerplate-Code erheblich.
- Sicherheit: Vermeiden Sie klassenweite Fehler wie NullPointerExceptions.
- Interoperabilität: Nutzen Sie vorhandene Bibliotheken von JVM, Android und Browsern.
- Toolfreundlich: kann mit jeder Java-IDE oder über die Befehlszeile erstellt werden.
Grundlegende Kotlin-Syntax
Kotlin-Dateien haben das Suffix .kt.
Paketdeklaration
Der Anfang der Codedatei ist normalerweise die Paketdeklaration:
package com.runoob.main
import java.util.*
fun test() {}
class Runoob {}
Für Kotlin-Quelldateien sind keine passenden Verzeichnisse und Pakete erforderlich, und Quelldateien können in jedem Dateiverzeichnis abgelegt werden.
Im obigen Beispiel lautet der vollständige Name von test() com.runoob.main.test und der vollständige Name von Runoob lautet com.runoob.main.Runoob.
Wenn kein Paket angegeben ist, wird das Standardpaket verwendet.
Standardimport
Es gibt mehrere Pakete, die standardmäßig in jede Kotlin-Datei importiert werden:
- kotlin.*
- kotlin.annotation.*
- kotlin.collections.*
- kotlin.comparisons.*
- kotlin.io.*
- kotlin.ranges.*
- kotlin.sequences.*
- kotlin.text.*
Funktionsdefinition
Die Funktionsdefinition verwendet das Schlüsselwort fun und das Parameterformat ist: Parameter: Typ
fun sum(a: Int, b: Int): Int { // Int 参数，返回值 Int
return a + b
}
Der Ausdruck dient als Funktionskörper und der Rückgabetyp wird automatisch abgeleitet:
fun sum(a: Int, b: Int) = a + b
public fun sum(a: Int, b: Int): Int = a + b // public 方法则必须明确写出返回类型
Funktionen ohne Rückgabewerte (ähnlich wie void in Java):
fun printSum(a: Int, b: Int): Unit {
print(a + b)
}
// 如果是返回 Unit类型，则可以省略(对于public方法也是这样)：
public fun printSum(a: Int, b: Int) {
print(a + b)
}
Parameterfunktion mit variabler Länge
Parameter variabler Länge einer Funktion können mit dem Schlüsselwort vararg identifiziert werden:
fun vars(vararg v:Int){
for(vt in v){
print(vt)
}
}
// 测试
fun main(args: Array<String>) {
vars(1,2,3,4,5) // 输出12345
}
Lambda (anonyme Funktion)
Beispiele für die Verwendung von Lambda-Ausdrücken:
// 测试
fun main(args: Array<String>) {
val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
println(sumLambda(1,2)) // 输出 3
}
Definieren Sie Konstanten und Variablen
Variablendefinition: Schlüsselwort var
var <标识符> : <类型> = <初始化值>
Definition unveränderlicher Variablen: Schlüsselwort val, eine Variable, die nur einmal zugewiesen werden kann (ähnlich den endgültig geänderten Variablen in Java).
val <标识符> : <类型> = <初始化值>
Konstanten und Variablen können keinen Initialisierungswert haben, müssen jedoch vor der Referenzierung initialisiert werden.
Der Compiler unterstützt die automatische Typbeurteilung. Das heißt, der Typ muss bei der Deklaration nicht angegeben werden, und der Compiler beurteilt ihn.
val a: Int = 1
val b = 1 // 系统自动推断变量类型为Int
val c: Int // 如果不在声明时初始化则必须提供变量类型
c = 1 // 明确赋值
var x = 5 // 系统自动推断变量类型为Int
x += 1 // 变量可修改
Kommentar
Kotlin unterstützt einzeilige und mehrzeilige Kommentare, Beispiele sind wie folgt:
// 这是一个单行注释
/* 这是一个多行的
块注释。 */
Im Gegensatz zu Java ermöglichen Blockkommentare in Kotlin eine Verschachtelung.
String-Vorlage
$ steht für einen Variablennamen oder Variablenwert
$varName stellt den Variablenwert dar
${varName.fun()} stellt den Rückgabewert der Variablenmethode dar:
var a = 1
// 模板中的简单名称：
val s1 = "a is $a"
a = 2
// 模板中的任意表达式：
val s2 = "${s1.replace("is", "was")}, but now is $a"
NULL-Prüfmechanismus
Das Nullsicherheitsdesign von Kotlin erfordert eine Nullbeurteilungsverarbeitung, wenn Parameter verwendet werden, die als null deklariert sind. Es gibt zwei Verarbeitungsmethoden. Fügen Sie !! nach dem Feld hinzu, um eine Nullausnahme wie Java auszulösen. Eine andere Möglichkeit, ? nach dem Feld hinzuzufügen, ist nicht erforderlich. Der Rückgabewert der Verarbeitung ist null oder stimmt überein?: Kurze Beurteilung der Verarbeitung
//类型后面加?表示可为空
var age: String? = "23"
//抛出空指针异常
val ages = age!!.toInt()
//不做处理返回 null
val ages1 = age?.toInt()
//age为空返回-1
val ages2 = age?.toInt() ?: -1
Wenn eine Referenz möglicherweise NULL-Werte zulässt, muss die entsprechende Typdeklaration explizit als NULL-Werte zulässig markiert werden.
Wenn der String-Inhalt in str keine Ganzzahl ist, wird null zurückgegeben:
fun parseInt(str: String): Int? {
// ...
}
Das folgende Beispiel zeigt, wie eine Funktion verwendet wird, die einen Nullwert zurückgibt:
fun parseInt(str: String): Int? {
return str.toIntOrNull()
}
fun printProduct(arg1: String, arg2: String) {
val x = parseInt(arg1)
val y = parseInt(arg2)
// 直接使用 `x * y` 会导致错误, 因为它们可能为 null
if (x != null && y != null) {
// 在进行过 null 值检查之后, x 和 y 的类型会被自动转换为非 null 变量
println(x * y)
}
else {
println("'$arg1' or '$arg2' is not a number")
}
}
fun main() {
printProduct("6", "7")
printProduct("a", "7")
printProduct("a", "b")
}
oder:
fun parseInt(str: String): Int? {
return str.toIntOrNull()
}
fun printProduct(arg1: String, arg2: String) {
val x = parseInt(arg1)
val y = parseInt(arg2)
// ...
if (x == null) {
println("Wrong number format in arg1: '$arg1'")
return
}
if (y == null) {
println("Wrong number format in arg2: '$arg2'")
return
}
// 在进行过 null 值检查之后, x 和 y 的类型会被自动转换为非 null 变量
println(x * y)
}
fun main() {
printProduct("6", "7")
printProduct("a", "7")
printProduct("99", "b")
}
Typerkennung und automatische Typkonvertierung
Mit dem is-Operator können wir testen, ob ein Ausdruck eine Instanz eines Typs ist (ähnlich dem Schlüsselwort „instanceof“ in Java).
fun getStringLength(obj: Any): Int? {
if (obj is String) {
// 做过类型判断以后，obj会被系统自动转换为String类型
return obj.length
}
//在这里还有一种方法，与Java中instanceof不同，使用!is
// if (obj !is String){
// // XXX
// }
// 这里的obj仍然是Any类型的引用
return null
}
oder
fun getStringLength(obj: Any): Int? {
if (obj !is String)
return null
// 在这个分支中, `obj` 的类型会被自动转换为 `String`
return obj.length
}
Es ist sogar okay
fun getStringLength(obj: Any): Int? {
// 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
if (obj is String && obj.length > 0)
return obj.length
return null
}
Intervall
Bereichsausdrücke werden durch die Funktion rangeTo mit dem Operator form … gebildet, ergänzt durch in und !in.
Der Bereich ist für jeden vergleichbaren Typ definiert, verfügt jedoch für ganzzahlige primitive Typen über eine optimierte Implementierung. Hier sind einige Beispiele für die Verwendung von Intervallen:
for (i in 1..4) print(i) // 输出“1234”
for (i in 4..1) print(i) // 什么都不输出
if (i in 1..10) { // 等同于 1 <= i && i <= 10
println(i)
}
// 使用 step 指定步长
for (i in 1..4 step 2) print(i) // 输出“13”
for (i in 4 downTo 1 step 2) print(i) // 输出“42”
// 使用 until 函数排除结束元素
for (i in 1 until 10) { // i in [1, 10) 排除了 10
println(i)
}
Beispieltest
fun main(args: Array<String>) {
print("循环输出：")
for (i in 1..4) print(i) // 输出“1234”
println("\n----------------")
print("设置步长：")
for (i in 1..4 step 2) print(i) // 输出“13”
println("\n----------------")
print("使用 downTo：")
for (i in 4 downTo 1 step 2) print(i) // 输出“42”
println("\n----------------")
print("使用 until：")
// 使用 until 函数排除结束元素
for (i in 1 until 4) { // i in [1, 4) 排除了 4
print(i)
}
println("\n----------------")
}
Ausgabeergebnis:
循环输出：1234
----------------
设置步长：13
----------------
使用 downTo：42
----------------
使用 until：123
----------------
Natürlich lernen Sie Kotlin, mit Ausnahme der Grundlagen der Grammatik. Empfohlene Referenzen„Kotlin-Handbuch“Es gibt auch Kotlin IntelliJ IDEA-Umgebungssetup, Kotlin Eclipse-Umgebungssetup, Kotlin-Befehlszeilenkompilierung, Kotlin Android-Umgebungssetup und Kotlin Grundlagen Syntax, grundlegende Kotlin-Datentypen, bedingte Kotlin-Steuerung, Kotlin-Schleifensteuerung, Kotlin-Klassen und -Objekte, Kotlin-Vererbung, Kotlin-Schnittstellen, Kotlin-Erweiterungen, Kotlin-Datenklassen und versiegelte Klassen, generische Kotlin-Aufzählungsklassen, Kotlin-Objektausdrücke/-deklarationen, Kotlin Delegation usw. Mehr könnt ihr auf meiner Homepage sehen oder mir direkt eine private Nachricht schicken.