Die Funktion ist wie folgt definiert.
//Eine Funktion, die Argumente vom Typ Int erhöht und zurückgibt
fun increment(i: Int): Int {
return i + 1
}
Spaß Funktionsname ( Argumentliste): Rückgabetyp
Dies ist die Grundform.
Welcher Wert entspricht welchem Argument in einem Funktionsaufruf mit vielen Argumenten Es kann schwer zu verstehen sein.
Kotlin hat die Fähigkeit, dieses Problem zu lösen.
/*
*Ich werde Takoyaki bestellen
*
* @param isKarashiMayo Gibt an, ob Karashi Mayonnaise ausgewählt werden soll
* @param isPutAonori Gibt an, ob blauer Kleber aufgetragen werden soll oder nicht
*
* @return Eine Instanz von Takoyaki wird zurückgegeben
*/
fun oderTakoyaki(isKarashiMayo: Boolean, isPutAonori: Boolean): Takoyaki {
// ...
}
val takoyaki = oderTakoyaki(true, false)
//Welche Flagge ist blauer Kleber?
val takoyaki = oderTakoyaki(isKarashiMayo = true, isPutAonori = false)
//Sie können dem Anrufer einen formalen Argumentnamen geben
//Einfach zu lesende Code-Absicht
val takoyaki = oderTakoyaki(isPutAonori = false, isKarashiMayo = true)
//Wenn Sie ihm einen Namen geben, muss er nicht in der in der Funktion definierten Reihenfolge sein.
Ich denke, es gibt viele Klassen, die viele Überladungen mit unterschiedlicher Anzahl von Argumenten haben. Zum Beispiel ...
Durch die Verwendung von Standardargumenten in Kotlin können Sie diese Situation zunehmender Variationen vermeiden.
/*
*Ich werde Takoyaki bestellen
*
* @param isKarashiMayo Gibt an, ob Karashi Mayonnaise ausgewählt werden soll
* @param isPutAonori Gibt an, ob blauer Kleber aufgetragen werden soll oder nicht
*
* @return Eine Instanz von Takoyaki wird zurückgegeben
*/
fun oderTakoyaki(isKarashiMayo: Boolean = false, isPutAonori: Boolean = true): Takoyaki {
// ...
}
//Argumente können zum Zeitpunkt des Aufrufs weggelassen werden. Wenn nicht angegeben, wird der Standardwert verwendet.
val takoyaki = oderTakoyaki()
Sie können später vorhandenen Klassen Funktionen hinzufügen. Fügen wir dem String-Typ eine Funktion hinzu, die in unserem eigenen Datumsformat analysiert wird.
fun String.toDate(): Date {
val format = SimpleDateFormat("JJJJ Jahr MM Monat TT Tag")
return format.parse(this)
}
val str = "09. März 2019"
val date = str.toDate()
fun Erweiterter Typ . Funktionsname ( Argumentliste): Rückgabewert
Definieren Sie als ↑.
Die übliche Funktion ist übrigens ...
Spaß Funktionsname ( Argumentliste): Rückgabetyp
↑ Es war so.
Wenn Sie vor dem Funktionsnamen einen Typ des Erweiterungsziels hinzufügen, wird dies zu einer Erweiterungsfunktion.
Übrigens heißt dieses Erweiterungszielobjekt in Kotlin ** Empfängerobjekt **.
Wenn die Funktion aus einem Ausdruck besteht, kann das {} weggelassen werden.
Funktionen für einzelne Ausdrücke können den Rückgabetyp auch weglassen, wenn der Rückgabetyp abgeleitet werden kann.
//Normale Funktion
fun double(x: Int): Int {
return x * 2
}
//Beschrieben als einzelne Ausdrucksfunktion
fun double(x: Int): Int = x * 2
//Leiten Sie den Rückgabetyp mit einer einzelnen Ausdrucksfunktion ab
fun double(x: Int) = x * 2
Der Lambda-Ausdruck wird als ↓ geschrieben.
val sum = { x: Int, y: Int ->
x + y
}
{Argument list-> Body}
Oder wenn es kein Argument gibt
{Hauptkörper}
Es wird sein.
Die implizite Variable it kann verwendet werden, wenn der Lambda-Ausdruck einen Parameter hat.
val double: (Int)->Int = {
it * 2
}
Der Funktionstyp wird wie folgt beschrieben.
(Argument type) -> Return type
Der Lambda-Ausdruck ist ein Mechanismus mit hohen Ausführungskosten. Kotlins Lambda-Ausdruck ist als anonyme Klasse implementiert. Jedes Mal, wenn ein Lambda-Ausdruck ausgeführt wird, der eine Variable erfasst, wird eine Instanz der anonymen Klasse erstellt.
Daher ist es eine Inline-Funktion. Die Inline-Funktion wird kompiliert, indem der Funktionskörper ersetzt wird, in dem sie aufgerufen wird.
inline fun edit(context: DataBaseContext, block: (DataBaseContext.Transaction)->Unit) {
val transaction = context.beginTransaction() // 1.Transaktionsstart
block(transaction) // 2.Argument Lambda-Ausführung
transaction.commit() // 3.Ende der Transaktion
}
Die Inline-Funktion ist wirksam Eine Funktion, die einen Lambda-Ausdruck als Argument verwendet und intern ausführt. Die Inline-Funktion erweitert auch den Argument-Lambda-Ausdruck auf den Aufrufer.
Dies ist ein Beispiel, das die Ueno-Inline-Funktion "edit" aufruft.
val dataBaseContext = DataBaseContext()
edit(dataBaseContext) { transaction ->
val newObject = Any()
transaction.add(newObject)
}
Die Funktion "Bearbeiten" wird zur Kompilierungszeit erweitert und sieht wie folgt aus: Bild (Bild)
val dataBaseContext = DataBaseContext()
//Die Bearbeitungsfunktion wird von hier aus erweitert
val transaction = dataBaseContext.beginTransaction() // 1.Transaktionsstart
val newObject = Any() // 2.Argument Lambda-Erweiterung
transaction.add(newObject) // 2.Argument Lambda-Erweiterung
transaction.commit() // 3.Ende der Transaktion
//Die Bearbeitungsfunktion wird bisher erweitert
Kotlin-Generika verlieren zur Laufzeit Typinformationen.
Die folgende Funktion führt beispielsweise zu einem Kompilierungsfehler.
fun <T> mapFilter(list: List<Any>): List<T> {
return list.filter { it is T }
.map { it as T }
}
Dies liegt daran, dass der Typparameter T der Funktion mapFilter zur Laufzeit verloren geht.
Fügen Sie daher der Inline-Funktion den Modifikator "reified" hinzu.
//↓ Hier!
inline fun <reified T> mapFilter(list: List<Any>): List<T> {
return list.filter { it is T }
.map { it as T }
}
Auf diese Weise wird es erweitert, während die Typinformationen zur Laufzeit beibehalten werden.
Die Funktion mapFilter kann jetzt kompiliert werden.