Elkezdtem a Klotlin tanfolyamot
Itt érhető el:
Eddig ezeket 'szedtem' magamra :
--- Main metodus klotlin alatt
fun main(args :array<String>){
println("Hello, world!")
}
---
println() // egy sor kiírása /egy sorban kiírás
---
The data types are:
Int indicates an integer (whole number), such as 42.
Double and Float are used to store decimal numbers, such as 12.4.
Char represents a character, such as 'z'.
Boolean has two possible values, either true or false.
--- Remember that \n represents a new line.
fun main(args : Array<String>) {
println("Code is like humor. When you have to explain it, it’s bad.” – Cory House")
}
----
var num: Int = 42
val num: Int = 42 ----konstans
The difference with var is that variables declared using val cannot be changed.
----
val name = "Lajos"
var szam = 42
---- "Hey "+"there" results in "Hey there". This process is called concatenation.
Kotlin supports all common arithmetic operators:
+ for addition
- for subtraction
* for multiplication
/ for division
% for modulus
----
Kotlin also supports the increment ++ and decrement -- operators
a+=b is equivalent to a=a+b.
----
Here are the comparison operators:
> greater than
< less than
>= greater than or equals to
<= less than or equals to
== is equal to
!= is not equal
----
// comment
Everything between /* and */ is considered a comment.
----
You can take values as input from the user using the readLine() function. //string result
----
convert to Int we need to use toInt(),
You can use toDouble() to convert a string to Double.
----
Note the !! after readLine(): this is called the not-null assertion operator,
and it defines that the expression on its left is not-null,
which means that it has to have a valid value, which is not blank (or null).
----
if (condition) {
// some code to run
}
else if (condition2) {
// some code to run
}
else {
// other go
}
---- break / continue
Each branch in a when expression is represented by a condition, an arrow (->), and a result.
val num = -1
val result = when {
num > 0 -> "pozitiv"
num < 0 -> "negativ"
else -> "nulla"
}
println(num)
----
fun main(args: Array<String>) {
val Heartbeat= readLine()!!.toDouble()
val love = when {
Heartbeat > 110 && Heartbeat <= 200 -> "Positive💘"
Heartbeat > 75 && Heartbeat <=110 -> "Negative💔"
else -> "🤷🏻♀"
}
println(love)
}
-----
using the logical and && and or || operators.
----
fun main(args: Array<String>) {
var x = 4
while(x > 0) {
println(x)
x-=2
}
}
---
fun main(args: Array<String>) {
var i = 5
while (i > 0) {
if(i == 2) {
break
}
println(i)
i--
}
}
----
-- Hibás hurok : őrökös hurok
var i = 0
while (i < 10) {
if(i == 5) {
continue
}
i++
}
----
var contacts = arrayOf("John", "James", "Amy")
contacts[1] = "Dave" ---index
----
var x = arrayOf(4, 2, 6, 7, 1)
var sum = 0
for(num in x) {
sum += num
}
println(sum)
----
val s = "testing" --- string mint tömb
println(s[6])
----
for (x in 3..6) { --- 3..6 // range -> 3,4,5,6
To iterate a number range which does not include its end element,
use the until function:
for (i in 1 until 5). In this case 5 is excluded. // nem tartalmazza a végelemet tartományból
----
/*
A díjat a következő árstruktúra alapján számolják:
- az első 5 órát óránként 1 dollárért számolják fel.
- ezt követően minden óráért óránként 0,5 dollárt kell fizetni.
- 24 óránként 15 USD átalánydíjat számítanak fel.
Ez azt jelenti, hogy például, ha egy autó 26 órán keresztül parkol,
akkor a számlának 15+ (2 * 0,5) = 16,0 értékűnek kell lennie, mert 24 órán keresztül parkolt
plusz 2 további órával.
*/
fun main(args: Array<String>) {
var hours = readLine()!!.toInt()
var total: Double = 0.0
if (hours > 0) {
if (hours <= 5) {
total = ( 1.0 * hours )
hours = 0
} else if(hours > 5 && hours < 24) {
total = 5.0
hours -= 5
}
while (hours >= 24) {
total += 15.0
hours -= 24
}
while (hours >= 1) {
total += 0.5
--hours
}
}
println(total)
}
----
fun welcome() {
println("Hey there")
}
--
fun welcome(name: String) {
println("Hello, " + name)
}
----
fun calc(x:Int) {
var y = x*2
println(x+y)
}
fun main(args: Array<String>) {
calc(3)
}
---- return(42)
var result = sum(8, 42)
----
val f: (Int, Int) -> Int = { a, b -> a+b } // névtelen funkció/függvény
val f = { a:Int, b:Int -> a+b } // névtelen funkció/függvény rövidítve
---
fun main(args: Array<String>) {
val f = { a:Int, b:Int -> a+b } // névtelen funkció/függvény rövidítve
var ret = f(8,2)
println(ret)
}
----
var arr = arrayOf(4, 2, 6, 7, 1)
arr.forEach {
// item -> print(item * 4) // mindig item a bejárási objektum neve
println(it * 4) // mindig it a rövidített bejárási változó neve
}
----
/*Egy függvény argumentumként vehet fel egy másik függvényt is.
Ezeket a függvényeket magasabb rendű függvényeknek nevezzük.
Ez akkor hasznos, ha meg akarjuk változtatni a függvény viselkedését.*/
--
fun apply(x:Int, action: (Int) -> Int): Int {
return action(x)
}
//--
fun main(args: Array<String>) {
println(apply(4,{x -> x * x}))
}
----
fun f(x: String): Int {
var z = 0
for(a in x) {
z++
}
return z
}
fun main(args: Array<String>) {
println(f("hello"))
}
// = 5 // hány betűből áll
----
fun apply(x: Int): Int {
return x*x
}
fun main(args: Array<String>) {
val arr = arrayOf(2, 3, 4)
var res = 0
arr.forEach {
res += apply(it)
}
println(res)
}
//=29
----
class User {
var name = ""
var age = 0
}
--
var u1 = User()
u1.name = "lajos"
u1.age = 59
---- Our User class has two properties: name and age.
class User(val name:String, val age:Int) {
} --- konstruktor, létrehozáskori beállítása a properties-nek (inicializálás)
---- constructor
---- getter / setter
class User {
var name = ""
var age = 0
get() = field
set(value) {
field = value
}
}
----
class User(var name: String, var age: Int) {
fun login() {
println("Login from user " + name)
}
}
fun main(args: Array) {
var u = User("James", 42)
u.login()
println (u.age)
}
----
/*
Figyelje meg a open kulcsszót a Felhasználói osztály előtt is:
meg kell engednie az öröklést belőle, mivel alapértelmezés szerint az összes osztály végleges,
és nem engedélyezi tőlük az öröklést.
*/
open class User(var name: String, var age: Int) {
}
class Admin(name: String, age: Int): User(name, age) {
}
class Moderator(name: String, age: Int): User(name, age) {
}
----
/* the common modifiers:
public: visible everywhere
protected: visible to the subclasses only
private: not visible from the outside*/
----
/*
--Absztrakt osztályok
Bizonyos esetekben az alaposztályra csak a származtatott osztályokra van szükség,
és nem hoz létre egyetlen objektumot sem.
Tegyük fel például, hogy minden felhasználónk Moderátor vagy Rendszergazda.
Ebben az esetben soha nem lesz szükségünk User típusú objektum létrehozására.
Ezekben a helyzetekben definiálhatjuk az alaposztályt absztrakciónak
--
Abstract classes are always open, so you do not need to use the open keyword.
--
Az absztrakt osztályok tartalmazhatnak absztrakt függvényeket is - olyan funkciókat,
amelyek nem tartalmaznak olyan definíciót,
amelyet a levezetett osztályoknak végre kell hajtaniuk.
*/
abstract / override
----
class Num(value:Int) {
var v = value+2
set(value) {
field = value+v
}
}
fun main(args: Array<String>) {
val x = Num(3)
x.v = 7
println(x.v)
}
--=> 12
----
---------------------------------
You are building a Music Player app.
You need to implement the MusicPlayer class, which should hold the track names as Strings in an array. The array is already defined in the given code.
The player should support the following functions:
add: add the given argument track to the tracks array.
show: output all track names in the player on separate lines.
play: start playing the first track by outputting "Playing name" where name is the first track name.
You can add a new item to an array using +=, for example: tracks += track
The code in main takes track names from user input and calls the player functions. Do not modify the code in main.
----
Zenelejátszó alkalmazást épít.
Meg kell valósítania a MusicPlayer osztályt, amelynek a számok nevét Stringként kell tartalmaznia egy tömbben. A tömb már meg van határozva az adott kódban.
A játékosnak támogatnia kell a következő funkciókat:
add: adja hozzá az adott argumentum sávot a tracks tömbhöz.
show: a lejátszó összes műsorszámának kiadása külön sorokra.
lejátszás: kezdje el az első szám lejátszását a "Playing name" megadásával, ahol a név az első szám neve.
Új elemet hozzáadhat egy tömbhöz a + = gombbal, például: track + = track
A fő kód a sávok nevét veszi fel a felhasználói bevitelből, és meghívja a lejátszó funkcióit. Ne módosítsa a kódot.
----
Purple Haze
Under Pressure
Walk This Way
stop
==>
Purple Haze
Under Pressure
Walk This Way
Playing Purple Haze
----------------------------
class MusicPlayer {
private var songs: Array<String> = arrayOf()
fun add(song : String) {
songs += song
}
fun show() {
songs.forEach {
item -> println(item)
}
}
fun play() {
println("Playing "+songs[0] )
}
}
fun main(args: Array<String>) {
val m = MusicPlayer()
while(true) {
var input = readLine()!!
if(input == "stop") {
break
}
m.add(input)
}
m.show()
m.play()
}
Megjegyzések
Megjegyzés küldése