Kotlin Grundlegende Syntax
Kotlin-Dateien enden mit.ktals Suffix.
Paketdeklaration
Der Anfang einer Codedatei ist in der Regel eine Paketdeklaration:
package com.example.main
import java.util.*
fun test() {}
class Example {}
Kotlin-Quelldateien erfordern kein übereinstimmendes Verzeichnis und Paket; Quelldateien können in einem beliebigen Dateiverzeichnis abgelegt werden.
Im obigen Beispiel ist der vollständige Name von test() com.example.main.test und der vollständige Name von Example com.example.main.Example.
Wenn kein Paket angegeben ist, wird standardmäßig dasdefaultPaket verwendet.
Standardpakete
Mehrere Pakete werden standardmäßig in jede Kotlin-Datei importiert:
- kotlin.*
- kotlin.annotation.*
- kotlin.collections.*
- kotlin.comparisons.*
- kotlin.io.*
- kotlin.ranges.*
- kotlin.sequences.*
- kotlin.text.*
Funktionsdefinition
Funktionsdefinitionen verwenden das Schlüsselwort fun, und das Parameterformat ist: parameter : type
fun sum(a: Int, b: Int): Int { // Int 参数,返回值 Int
return a + b
}
Ein Ausdruck als Funktionskörper, wobei der Rückgabetyp automatisch abgeleitet wird:
fun sum(a: Int, b: Int) = a + b public fun sum(a: Int, b: Int): Int = a + b // public 方法则必须明确写出返回类型
Eine Funktion ohne Rückgabewert (ä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)
}
Funktion mit variabler Parameterlänge
Parameter variabler Länge einer Funktion können mit demvararg-Schlüsselwort markiert 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)
Beispiel für die Verwendung eines Lambda-Ausdrucks:
// 测试
fun main(args: Array<String>) {
val sumLambda: (Int, Int) -> Int = {x,y -> x+y}
println(sumLambda(1,2)) // 输出 3
}
Definieren von Konstanten und Variablen
Definition einer veränderlichen Variablen: var-Schlüsselwort
var <标识符> : <类型> = <初始化值>
Definition einer unveränderlichen Variablen: val-Schlüsselwort, eine Variable, die nur einmal zugewiesen werden kann (ähnlich einer Variable, die in Java mit final modifiziert wird)
val <标识符> : <类型> = <初始化值>
Sowohl Konstanten als auch Variablen können ohne Initialwerte sein, müssen aber vor der Referenzierung initialisiert werden.
Der Compiler unterstützt automatische Typinferenz, das heißt, beim Deklarieren kann man den Typ weglassen und den Compiler ihn ableiten lassen.
val a: Int = 1 val b = 1 // 系统自动推断变量类型为Int val c: Int // 如果不在声明时初始化则必须提供变量类型 c = 1 // 明确赋值 var x = 5 // 系统自动推断变量类型为Int x += 1 // 变量可修改
Kommentare
Kotlin unterstützt einzeilige und mehrzeilige Kommentare, wie im folgenden Beispiel gezeigt:
// This is a single-line comment /* This is a multi-line block comment. */
Im Gegensatz zu Java erlauben Blockkommentare in Kotlin Verschachtelung.
String-Vorlagen
$ steht für einen Variablennamen oder Variablenwert
$varName repräsentiert den Variablenwert
${varName.fun()} repräsentiert den Rückgabewert der Methode der Variablen:
var a = 1
// 模板中的简单名称:
val s1 = "a is $a"
a = 2
// 模板中的任意表达式:
val s2 = "${s1.replace("is", "was")}, but now is $a"
NULL-Prüfmechanismus
Kotlins null-sicheres Design erfordert eine Null-Prüfbehandlung, wenn als nullable deklarierte Parameter verwendet werden. Es gibt zwei Behandlungsmethoden: Das Anhängen von !! nach dem Feld löst wie in Java eine Null-Ausnahme aus; die andere Möglichkeit ist, ? nach dem Feld anzuhängen, was unbehandelt bleiben kann und der Rückgabewert istnulloder mit?:für die Null-Prüfbehandlung.
//类型后面加?表示可为空 var age: String? = "23" //抛出空指针异常 val ages = age!!.toInt() //不做处理返回 null val ages1 = age?.toInt() //age为空返回-1 val ages2 = age?.toInt() ?: -1
Wenn eine Referenz null sein kann, muss die entsprechende Typdeklaration explizit als nullable markiert werden.
Wenn die Zeichenkette in str keine Ganzzahl ist, gibt sie null zurück:
fun parseInt(str: String): Int? {
// ...
}
Das folgende Beispiel zeigt, wie man eine Funktion verwendet, deren Rückgabewert null sein kann:
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")
}
Typprüfung und automatische Typkonvertierung
Wir können denisOperator verwenden, um zu prüfen, ob ein Objekt eine Instanz eines angegebenen Typs ist (ähnlich wie das Schlüsselwort instanceof in Java).
if (obj is Type) {
// 如果 obj 是 Type 类型,则可以直接使用 Type 类型的属性和方法
} else {
// 处理其他类型情况
}
WannisWenn die Prüfung erfolgreich ist, behandelt Kotlin automatischobjbehandelt es als den angegebenen Typ, also inifim Zweig der Anweisung muss keine explizite Typumwandlung durchgeführt werden. Dies wird alsintelligente Typumwandlung bezeichnet.。
Beispiel
val obj: Any = "Hello, Kotlin"
if (obj is String) {
println("string length: ${obj.length}") // Hier wurde `obj` intelligent in `String` umgewandelt
} else {
println("Not a string type")
}
}
In diesem Beispiel, wennobjJaStringTyp,isOperator gibt zurücktrue, Kotlin wirdobjes als erkennenString, damit es zugreifen kannStringdie Eigenschaften und Methoden des Typs.
Weitere Anwendungen:
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
}
Sie können sogar
fun getStringLength(obj: Any): Int? {
// 在 `&&` 运算符的右侧, `obj` 的类型会被自动转换为 `String`
if (obj is String && obj.length > 0)
return obj.length
return null
}
Bereiche
Bereichsausdrücke werden durch die Operatorform..der rangeTo-Funktion gebildet, ergänzt durch in und !in.
Bereiche sind für jeden vergleichbaren Typ definiert, aber für integrale primitive Typen haben sie eine optimierte Implementierung. Im Folgenden finden Sie einige Beispiele für die Verwendung von Bereichen:
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 ----------------Weitere Erweiterungen