[[oktatas:programozás:kotlin|< Kotlin]]

====== Kotlin nyelv ======

  * **Szerző:** Sallai András
  * Copyright (c) 2020, Sallai András
  * Szerkesztve: 2020, 2023
  * Licenc: [[https://creativecommons.org/licenses/by-sa/4.0/|CC BY-SA 4.0]]
  * Web: https://szit.hu


===== Helló világ =====

<code kotlin prog.kt>
fun main() {
    println("Helló Világ!")
}

</code>

Fordítás:
  kotlinc src/prog.kt -d bin

Futtatás:
  java -cp bin ProgKt


JVM fordítás:
<code>
kotlinc prog.kt -include-runtime -d prog.jar
</code>

Kapunk egy prog.jar fájlt. 

Futtatás: 
<code>
java -jar prog.jar
</code>


A kotlin forráskódok kiterjesztése a következők egyike lehet:

  * .kt
  * .kts
  * .ktm



===== Megjegyzés =====

Egysoros megjegyzés:
<code kotlin>
// egysoros megjegyzés
</code>

Többsoros megjegyzés:
<code kotlin>
/*
több
soros
megjegyzés
*/
</code>

===== Kivitel =====

<code kotlin>
fun main() {
    print("Szám: ")
}
</code>


<code kotlin>
fun main() {
    println("Eredmény: ")
}
</code>


Ha a println() számára megadok egy kifejezést, az kiértékelésre kerül. 
<code kotlin kiir.kt>
fun main() {
    println(5/2)    // 2
    println(5/2.0)  // 2.5
}
</code>
Osztás esetén egész osztás történik, ha csak egész számok esetén.
Ha szeretnénk a példában található 2, valós számként értelmeztetni,
egyszerűen írjuk utána .0 meghatározást. 


<code kotlin kiir.kt>
fun main() {
    val a = 2;
    println(5 / a)             // 2
    println(5 / a.toDouble())  //2.5
}
</code>

==== Hibakimenet ====

A kotlin nem tartalmaz kiírató utasítást, amely az alapértelmezett
kimenetre ír. De használhatjuk a Java szabványos utasítását:
<code kotlin>
System.err.println("Hiba")
</code>

===== Típusok =====

^  Egész típusok  ^^^^
^  Típus  ^  Bitek  ^  Min érték  ^  Max érték  ^
| Long   | 64 |	-9223372036854775808  | 9223372036854775807  |
| Int    | 32 | -2147483648 | 2147483647 |
| Short	 | 16 | -32768 | 32767 |
| Byte   | 8  | -128 | 127 |


^  Valós típusok  ^^^
^  Típus  ^  Bitek  ^  Leírás  ^
|  Double  |  64  |  16-17 értékes szám (mint a float a Python nyelven) |
|  Float   |  32  |  6-7 értékes szám  |


^   Egyéb   ^^^
^  Típus  ^  Bitek  ^  Leírás  ^
|  Char  | 16 | UTF-16 kód |
|  Boolean  | 8 | true vagy false  |


===== Változók =====

A változókat használat előtt deklarálni kell, vagyis be kell jelenteni.
Ezt a var kulcsszóval tehetjük meg.

<code kotlin>
var szam = 30
var uzenet = "helló"
</code>


Csak olvasható változó:
<code kotlin>
val number = 30
val uzenet = "helló"
</code>

A helyes terminológia szerint, ez csak változó, csak olvasható változó.
A val kulcsszóval nem deklarálunk állandót, mivel annak értékét nem
kell definiálni fordításkor. 


Állandó:
<code kotlin>
const val szam = 2
</code>

Típus megahatározása:

<code kotlin>
var a = 35
var b: Byte = 35;
var c: Int = 45;
var d: Short = 55;
</code>

Ha nem adjuk meg a változó típusát, és belefér az Int típusba, akkor
Int lesz.

De beállíthatjuk egy szám típusát:
<code kotlin>
var e = 65.toShort()
var f = 75.toByte()
</code>

===== Formázott kimenet =====

Használható formátumkarakterek:

^  Néhány konverziós karakter  ^^
|  %d  | egész kiíratása  |
|  %f  | valós kiíratása  |
|  %c  | karakter kiíratása  |
|  %s  | karaktersorozat kiíratása  |



<code kotlin forma.kt>
fun main() {
    val szam = 34.12345
    println("Eredmény: %.2f".format(szam))
}
</code>


===== Matematikai függvények =====

Hatványozás:
<code kotlin>
println(Math.pow(2.0,3.0))
</code>


Pi értéke:
<code kotlin>
println(Math.PI)
</code>

Szinusz:
<code kotlin>
fun main() {
    var szog = 1.0
    var rad = szog * Math.PI / 180
    println(Math.sin(rad))
}
</code>

===== Bevitel =====

<code kotlin>
fun main() {
    print("Szám: ")
    val szam = readLine()!!.toInt()
    println("Szám: "+ szam * 2)
}
</code>


Beolvasás másként:
<code kotlin>
import java.util.Scanner

fun main() {
    print("Szám: ")
    val input = Scanner(System.`in`)
    val szam = input.nextInt()
    println("Eredmény: " + szam)
}

</code>


Újra:
<code kotlin>
fun main() {
    print("Szám: ")
    val szam:Int = readLine()!!.toInt()
    println("Dupla: " + szam * 2)
}

</code>

===== Szelekció =====
==== if ====

<code kotlin>
fun main() {
    val szam = 30
    if(szam > 0) {
        println("A szám pozitív")
    }
}
</code>


Ellenben:

<code kotlin>
fun main() {
    val szam = -30
    if(szam > 0) {
        println("A szám pozitív")
    }else {
        println("A szám nulla vagy negatív")
    }
}

</code>


Több ágú szelekció:

<code kotlin>
fun main() {
    val szam = -30
    if(szam > 0) {
        println("A szám pozitív")
    }else if(szam < 0) {
        println("A szám negatív")
    }else {
        println("A szám nulla")
    }
}

</code>

==== when ====

<code kotlin szelekcio.kt>
fun main() {
    print("Szám: ")
    var szam = readLine()!!.toInt()
    when(szam) {
        1 -> println("egy")
        2 -> println("kettő")
        3 -> println("három")
        4 -> println("négy")
        else -> {
            println("Nem 1..4 közötti szám")
        }
    }
}
</code>


<code kotlin szelekcio.kt>
fun main() {
    print("Szám: ")
    var szam = readLine()!!.toInt()
    when(szam) {
        1, 2 -> println("egy vagy kettő")
        else -> {
            println("Valami más")
        }
    }
}
</code>


<code kotlin szelekcio.kt>
fun main() {
    print("Szám: ")
    var szam = readLine()!!.toInt()

    var szamok = (10..20).toList()
    when(szam) {
        in 1..10 -> println("1 és 10 között")
        in szamok -> println("10 és 20 között")
        else -> {
            println("Valami más")
        }
    }
}
</code>


<code kotlin szelekcio.kt>
fun main() {
    print("Szám: ")
    var szam = readLine()!!.toInt()

    var szamok = (10..20).toList()
    when(szam) {
        in 1..10 -> println("1 és 10 között")
        in szamok -> println("10 és 20 között")
        !in 20..30 -> println("nem 20 és 30 közötti szám")
        else -> {
            println("Valami más")
        }
    }
}

</code>

===== Ciklus =====

==== for ====

<code kotlin>
fun main() {
    for(i in 0..9) {
        println("Helló Világ!")
    }
}

</code>

A 10 kizárása:
<code kotlin>
fun main() {
    for(i in 0 until 10) {
        println(i)
    }
}

</code>


Léptetés 2-vel:
<code kotlin>
fun main() {
    for(i in 0 until 10 step 2) {
        println(i)
    }
}
</code>

Csökkentés:
<code kotlin>
fun main() {
    for(i in 10 downTo 0 step 2) {
        println(i)
    }
}

</code>
==== while ====


<code kotlin ciklus.kt>
fun main() {
    var szam = 0
    while(szam<10) {
        println("Valami")
        szam++
    }
}
</code>

==== do..while ====

<code kotlin ciklus.kt>
fun main() {
    var szam = 0
    do {
        println("Valami")
        szam++
    }while(szam<10);
}

</code>

===== Lista =====

<code kotlin>

fun main() {
    var szamok = (0..9).toList()
    println(szamok[2])
}

</code>


<code kotlin>
val nevek = listOf("Kati", "Mari", "Dani")
for (nev in nevek) {
    println(nev)
}
</code>

===== Karakterek =====

<code kotlin>
val ch = 'a' // karakter
val uzenet = "alma" // karaktersorozat
val elso = uzenet[0] // karakter
</code>

==== Konkatenálás ====

<code kotlin>
fun main() {
    val vnev = "Nagy"
    val knev = "János"
    val nev = "$vnev $knev"
    println(nev)
}
</code>

==== Kifejezés kiértékelése ====

<code kotlin>
fun main() {
    val szuletesEv = 1985
    val jelenEv = 2020    
    println("Életkor: ${jelenEv - szuletesEv}")
}
</code>


===== Fájlkezelés =====

<code>
File("adat.txt").writeText("alma")
</code>


<code kotlin>
import java.io.File

fun main() {
    File("adat.txt").writeText("alma\nkörte\nbarack")
    File("adat.txt").forEachLine { println(it) }
}

</code>

===== Függvények =====

<code kotlin eljaras.kt>
fun main() {
    nevjegy()
}

fun nevjegy() {
    println("Nagy János")
    println("Szolnok")
    println("Kék utca 32.")
}
</code>


<code kotlin fuggveny.kt>
fun dupla(szam: Int): Int {
    return szam * 2
}
</code>