Wie wir alle wissen, hat Google Kotlin als first class Programmiersprache für Android erklärt. Das bedeutet vollen Support für die Programmiersprache und absolut keine Nachteile für die Entwicklung damit. - Im Gegenteil!
Wie es die offizielle Seite zusammenfasst:
var hello: String = "Hello" // mutable, also veränderbar
val hi: String = "hi" // immutable, also final und nicht veränderbar
private val world: String = "World" // privater Zugriff nur innerhalb der Klasse
private val aNumber: Int = 2
private val aBoolean: Boolean = true
private val aFloat: Float = 2.1f
private val aDouble: Double = 2.1
...
?
val user: User? = null // optional: named parameters! Wegfall "new"
user = User(name = "Alice")
user?.name = "Bob" // User hat jetzt einen neuen Namen
user = null
user.name = "Charlie" // Compiler-Error
user!!.name = "Charlie" // "force Unwrap", wenn möglich vermeiden; wäre hier eine Nullpointer Exception!
user?.let {
// guard, hier drinnen ist "it" der user (ähnlich this in java) und "it" ist nicht mehr nullable!
it.name = "Alice"
}
var hello = "Hello" // String, sonst: var hello: String = "Hello"
val one = 1 // Int, sonst: val one: Int = 1
val lon = 34.6 // Double, sonst: val lon: Double = 34.6
val isIt = true // Boolean, sonst: val isIt: Boolean = true
val woho = ["1", "2". "3"] // [String], sonst: val woho: List<String> = ["1","2","3"]
class
. Vererbung und Implementierung von Interfaces durch :
class User(val name: String, val age: Int) { ...} // Finale Klasse mit Konstruktor Variablen
class User: Human, InteractionListener { ...} // erbt von Human, implementiert InteractionListener
open class Human { ...} // vererbbare Klasse
data classes
mit equals(), toString()
und hashCode()
- Funktionendata class User(val name: String, val age: Int)
fun
und dem Typen Unit
als Ersatz für void
in Java. Somit die Standard return Value einer Funktion, die keinen Rückgabewert hat.Es gilt daher gleichbedeutend
private fun doSomething(): Unit {
print("Hello World")
return Unit
}
und
// prägnantere, gewöhnlichere Schreibweise:
private fun doSomething() {
print("Hello World")
}
object Utils {
fun doSomething(){}
}
fun String.isHelloWorld(): Boolean { // erweitert die String Klasse
return if (this == "Hello World") true // this bezieht sich auf die String Klasse
else false
}
oder kürzer
fun String.isHelloWorld(): Boolean {
return (this == "Hello World")
}
oder noch kürzer
fun String.isHelloWorld() = this == "Hello World"
Ein gutes Beispiel ist auch .apply
auf ein beliebiges Objekt, das Funktionen innerhalb des Objekts in einem Block aufrufen kann:
val user = User().apply {
name = Bob
age = 24
doSomething()
doEvenMore()
}
Filter
listOf(1,2,3,4,5,6).filter{ it < 4 } // liefert [1,2,3]
Map
listOf(1,2,3).map { it + 1 } // liefert [2,3,4]
Reduce
listOf(1,2,3).reduce{ total, item -> total + item} // liefert 6
ForEach
listOf(1,2,3).forEach{ print(it) } // liefert 123
// das gleiche mit function reference
listOf(1,2,3).forEach(::print) // liefert 123
// Eine Funktion die einen String-Input entgegennimmt
// und prüft ob "hello" enthalten ist und die Anzahl an gefundenen "l"s ausgibt.
fun evaluatateLs(input: String, evaluation: (hasHello: Boolean, lCount: Int) -> Unit) {
val lowerCasedInput = input.toLowerCase().trim()
evaluation(lowerCasedInput.contains("hello"), lowerCasedInput.count { it == 'l' })
}
// it = Parameter-Value innerhalb des Lambdas, ähnlich aber nicht gleich `this` in java
// Aufruf
fun testIt(){
evaluatateLs("heLlo WorLd") { hasHello, lCount ->
assertTrue(hasHello)
assertEquals(3, lCount)
}
}
Auto Convert
Gerade für Einsteiger sehr praktisch: Android Studio bietet die Möglichkeit, ganze Java-Files in Kotlin-Files zu konvertierten. Dabei geht der Konverter nach bestimmten Regeln vor.
Außerdem können Codeabschnitte aus einem Java File on the fly konvertiert werden, wenn der Code nach dem Ausschneiden in ein Kotlin File eingefügt wird.
⚠️ Bitte beachte aber unbedingt, dass dieser Code daher eher eine Ahnung davon gibt, wie er in Kotlin geschrieben sein könnte.
Warum man mit Kotlin gerade in der Android Entwicklung besonders profitiert:
Java:
button.setOnClickListener(new OnClickListener(){ // java ist in diesem Fall sehr "verbose"
@Override
public void onClick(View view){
// do something
}
});
Kotlin:
button.onClick {
// do something
}
for
-SchleifenIn unserer ersten Coding-Übung legen wir innerhalb unserem erstellten Utils-File eine Klasse User
an.
print()
Methode (fun print(){})
hinzuLog.e("PRINT", loginName)
enthalten, um aus dem Namen des Users auf der Konsole eine Ausgabe zu erzeugen. Importiere dazu mit import android.util.Log
die Funktion Log
.In dem File MainActivity
unter setContentView(..)
erstellen wir jetzt codeseitig einen neuen User mit beliebigem Namen.
Sorge dafür, dass dort die print()-Methode des Users aufgerufen wird.
Über den "Run" Button von Android Studio kannst du dann testen, ob alles funktioniert.
Schaue in der Logcat nach "PRINT". Falls die Logcat viel zu voll ist, suche explizit nach Print und stelle die Ausgabe auf Error.
Wie du siehst, ist die Logcat praktisch für das sehr einfache Debugging auf dem Gerät.
Das war's erstmal.
Jetzt bist du bereit um mit der UI-Entwicklung weiter zu machen.
Mache nun weiter mit den UI Essentials.