Bearbeiten von „Kotlin“

Zur Navigation springen Zur Suche springen

Warnung: Du bist nicht angemeldet. Deine IP-Adresse wird bei Bearbeitungen öffentlich sichtbar. Melde dich an oder erstelle ein Benutzerkonto, damit Bearbeitungen deinem Benutzernamen zugeordnet werden.

Die Bearbeitung kann rückgängig gemacht werden. Bitte prüfe den Vergleich unten, um sicherzustellen, dass du dies tun möchtest, und veröffentliche dann unten deine Änderungen, um die Bearbeitung rückgängig zu machen.

Aktuelle Version Dein Text
Zeile 1: Zeile 1:
Kategorie:Sprache
Kategorie:Sprache
= Links =
* [[Kotlin-GUI]]


= Funktionen =
= Funktionen =
Zeile 22: Zeile 19:
fun showNamesParams() {
fun showNamesParams() {
   log(prefix:"!", message:"Hi")
   log(prefix:"!", message:"Hi")
  log(message="Hi", prefix="")
</pre>
== Varargs ==
fun join(prefix: String, vararg items:String) {
  var rc = prefix
  items.foreach(items) {
    rc += it
  }
  return rc
}
== High order functions ==
<pre>fun printFilteredStrings(list: List<String>, predicate: (String) -> Boolean) {
  list.forEach {
    if predicate(it) {
      println(it)
    }
  }
}
fun main() {
  val list = listOf("a", "b");
  printFilterStrings(list, { it.startswith(prefix:"J")})
}
fun printFilteredStrings2(list: List<String>, (predicate: (String)?) -> Boolean) {
  list.forEach {
    if predicate?.invoke(it) == true {
      println(it)
    }
  }
}
val predicate: (String) -> Boolean = {
  it.startsWith(prefix:"J")
}
fun getPrintPredicate(): (String) -> Boolean {
  return { it.startsWith("J") }
}
</pre>
</pre>


Zeile 90: Zeile 52:
   println(thing)
   println(thing)
}
}
things.forEachIndexed { no, thing ->
things.forIndexedEach { no, thing ->
   println(no, thing)
   println(no, thing)
}
}
</pre>
</pre>
= Expressions =
= Expressions =
<pre>name = lastName if (firstName == null) else "$firstName $lastName"
<pre>name = lastName if (firstName == null) else "$firstName $lastName"
Zeile 101: Zeile 62:
   else -> "$firstName $lastName"
   else -> "$firstName $lastName"
}
}
// Ersatz, wenn null
name += lastName :? ""
</pre>
</pre>


= Typen =
= Typen =
* if item is Person { ... }
* if item !is Person { ... }
* Cast: (infoProvider as SessionInfoProvider).getSessionId()
== String ==
== String ==
* Konkatenation: firstName + ! " + lastName
* Konkatenation: firstName + ! " + lastName
* Templates: "$firstName $lastName"
* Templates: "$firstName $lastName"
== Enums ==
<pre>enum class EntityType {
  EASY, MEDIUM, HARD:
  fun formated() = name.toLowerCase()
}
when type {
  EntityType.EASY -> type.name // Metainfo
  else -> "not easy"
}
</pre>


== Container ==
== Container ==
Zeile 134: Zeile 79:
val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c")
val map = mutableMapOf(1 to "a", 2 to "b", 3 to "c")
map.
map.
</pre>
= Klassen =
* Klassen: private / internal
* Members: private / protected
* Klassen + vals: open: kann abgeleitet werden
** in abgeleiteter Klasse: override
<pre>class Person constructor()
class Person(_firstName: String, lastName: String){
  val age: Int? = null
  val firstName: String
  val lastName: String
  init {
    firstName = _firstName
    lastName = _lastName
  }
}
// Kürzer:
class Person(val firstName: String, val lastName: String){
  // 2.ter Konstruktor:
  constructor(): this("Peter", "Parker")
  var nickName: String? = null
    // expliziter Setter:
    set(value){
      println("nickname is set")
      field = value
    }
    get() {
      println("access to nickname")
      return field
    }
}
open class BasicInfoProvider {
}
class FancyInfoProvider : BasicInfoProvider {
}
</pre>
== sealed class ==
<pre>sealed class Entity {
  data class Easy(val id: String, val name: String): Entity
  data class Hard(val id: String, val name: String, multiplyer:Float): Entity
}
entity = Entity.Easy("x", "Jones")
</pre>
== extended functions ==
* Beliebige Klasse (ohne Sourcecode) erweitern:
<pre>fun String.printInfo() {
  ..
}
val Entity.Medium.info: String
  get() = "some info"
</pre>
== Companion object ==
<pre> class Entity private constructor(val id: String) {
  compianion Factory {
    const val id = "id"
    fun create() = Entitiy(id)
  }
}
fun main() {
  val entity = Entity.Factory.create()
}
</pre>
= Interfaces =
<pre>interface personInfoProvider {
  fun printInfo(person: Person)
  fun debug(person: Person) {
    person.debug()
  }
  val providerInfo: String
}
class BasicInfoProvider: PersonInfoProvider {
  override val providerInfo = "!"
  override fun printInfo(person: Person) {
    super.printInfo(person)
  }
}
</pre>
= Funktionale Programmierung =
<pre>fun main(){
  val list = listOf("Kotlin", "Java", "JS", "C++")
  list
    .filterNotNull()
    .take(n:3)
    .takeLast(n:1)
    .find { it.startsWith("J") }
    .findLast { it.startsWith("X") }.orEmpty()
    .associate { it to it.length() }
    .filter {
      it.startsWith("J")
    }
    .forEach {
      println(it)
    }
  list
    .associate { it to it.length() }
    .forEach {
      println("${it.value}, ${it.key}")
    }
  val map = list
    .filterNotNull()
    .associate { it to it.length() }
  // Letztes Element einer Liste ist null:
  val last = list.filterNotNull().last()
}
</pre>
</pre>

Bitte kopiere keine Webseiten, die nicht deine eigenen sind, benutze keine urheberrechtlich geschützten Werke ohne Erlaubnis des Urhebers!
Du gibst uns hiermit deine Zusage, dass du den Text selbst verfasst hast, dass der Text Allgemeingut (public domain) ist, oder dass der Urheber seine Zustimmung gegeben hat. Falls dieser Text bereits woanders veröffentlicht wurde, weise bitte auf der Diskussionsseite darauf hin. Bitte beachte, dass alle Info-Theke-Beiträge automatisch unter der „Gemeinfreiheit“ stehen (siehe Info-Theke:Urheberrechte für Einzelheiten). Falls du nicht möchtest, dass deine Arbeit hier von anderen verändert und verbreitet wird, dann klicke nicht auf „Seite speichern“.

Abbrechen Bearbeitungshilfe (wird in einem neuen Fenster geöffnet)
Abgerufen von „https://wiki.hamatoma.de/index.php?title=Kotlin“