Kotlin-függvény (példával)

Tartalomjegyzék

Ebben a cikkben megismerheti a funkciókat; milyen funkciók, annak szintaxisa és hogyan lehet felhasználói funkciót létrehozni Kotlinban.

A programozásban a function a kapcsolódó utasítások csoportja, amelyek egy adott feladatot hajtanak végre.

A funkciókat egy nagy program kisebb és moduláris darabokra bontására használják. Például létre kell hoznia és színeznie kell egy kört a felhasználó bemenete alapján. Két funkciót hozhat létre a probléma megoldására:

  • createCircle() Funkció
  • colorCircle() Funkció

Az összetett program kisebb részekre bontása szervezettebbé és kezelhetőbbé teszi programunkat.

Ezenkívül elkerüli az ismétlést és újrafelhasználhatóvá teszi a kódot.

A funkciók típusai

Attól függően, hogy egy függvényt a felhasználó definiál, vagy elérhető a standard könyvtárban, kétféle funkció létezik:

  • Kotlin Standard Library funkció
  • Felhasználó által definiált függvények

Kotlin Standard Library funkció

A standard könyvtárfunkciók beépített funkciók Kotlinban, amelyek könnyen elérhetők. Például,

  • print() egy olyan könyvtárfunkció, amely üzenetet nyomtat a szokásos kimeneti adatfolyamba (monitor).
  • sqrt()szám ( Doubleérték) négyzetgyökét adja eredményül
 fun main(args: Array) ( var number = 5.5 print("Result = $(Math.sqrt(number))") )

A program futtatásakor a kimenet a következő lesz:

 Eredmény = 2.345207879911715

Itt található egy link a Kotlin Standard Library-hoz, amelyet felfedezhet.

Felhasználó által definiált funkciók

Mint említettük, maga hozhat létre függvényeket. Az ilyen függvényeket felhasználó által definiált függvényeknek nevezzük.

Hogyan hozzunk létre egy felhasználó által definiált függvényt Kotlinban?

A funkció (hívás) használata előtt meg kell határoznia.

Így határozhat meg egy függvényt Kotlinban:

 fun callMe () (// függvénytest)

A függvény meghatározása Kotlinban funkulcsszót használ. Ezután jön a függvény neve (azonosító). Itt a függvény neve callMe.

A fenti programban a zárójel ( )üres. Ez azt jelenti, hogy ez a függvény nem fogad el egyetlen argumentumot sem. Az érvekről a cikk későbbi részében tájékozódhat.

A göndör zárójelben ( )lévő kódok a függvénytestek.

Hogyan hívhatunk függvényt?

A függvény törzsében lévő kódok futtatásához meg kell hívnia a függvényt. Itt van, hogyan:

 hívj()

Ez az utasítás meghívja a callMe()korábban deklarált függvényt.

Példa: Egyszerű funkció program

 fun callMe() ( println("Printing from callMe() function.") println("This is cool (still printing from inside).") ) fun main(args: Array) ( callMe() println("Printing outside from callMe() function.") )

A program futtatásakor a kimenet a következő lesz:

Nyomtatás a callMe () funkcióból. Ez klassz (még mindig belülről nyomtat). Nyomtatás a callMe () függvényen kívül.

A callMe()fenti kódban található függvény egyetlen argumentumot sem fogad el.

Ezenkívül a függvény nem ad vissza értéket (a visszatérés típusa az Unit).

Vegyünk egy másik függvény példát. Ez a függvény elfogadja az argumentumokat, és értéket is ad vissza.

Példa: Két szám hozzáadása a Funkció használatával

 fun addNumbers(n1: Double, n2: Double): Int ( val sum = n1 + n2 val sumInteger = sum.toInt() return sumInteger ) fun main(args: Array) ( val number1 = 12.2 val number2 = 3.4 val result: Int result = addNumbers(number1, number2) println("result = $result") )

A program futtatásakor a kimenet a következő lesz:

 eredmény = 15

Hogyan működnek az argumentumokkal és a visszatérő értékkel rendelkező függvények?

Itt két, a number1 és number2 típusú argumentumot Doubletovábbítunk a addNumbers()függvénynek a függvényhívás során. Ezeket az érveket tényleges érveknek nevezzük.

 eredmény = addNumbers (szám1, szám2)

Az n1 és n2 paraméterek elfogadják az átadott argumentumokat (a függvény definíciójában). Ezeket az érveket formális argumentumoknak (vagy paramétereknek) nevezzük.

In Kotlin, arguments are separated using commas. Also, the type of the formal argument must be explicitly typed.

Note that, the data type of actual and formal arguments should match, i.e., the data type of first actual argument should match the type of first formal argument. Similarly, the type of second actual argument must match the type of second formal argument and so on.

Here,

 return sumInteger

is the return statement. This code terminates the addNumbers() function, and control of the program jumps to the main() function.

In the program, sumInteger is returned from addNumbers() function. This value is assigned to the variable result.

Notice,

  • both sumInteger and result are of type Int.
  • the return type of the function is specified in the function definition. 
     // return type is Int fun addNumbers(n1: Double, n2: Double): Int (… )

If the function doesn't return any value, its return type is Unit. It is optional to specify the return type in the function definition if the return type is Unit.

Example: Display Name by Using Function

 fun main(args: Array) ( println(getName("John", "Doe")) ) fun getName(firstName: String, lastName: String): String = "$firstName $lastName"

When you run the program, the output will be:

 John Doe

Here, the getName() function takes two String arguments, and returns a String.

You can omit the curly braces ( ) of the function body and specify the body after = symbol if the function returns a single expression (like above example).

It is optional to explicitly declare the return type in such case because the return type can be inferred by the compiler. In the above example, you can replace

 fun getName (keresztnév: karakterlánc, vezetéknév: karakterlánc): karakterlánc = "$ firstName $ vezetékNév"

val vel

 fun getName (keresztnév: karakterlánc, vezetéknév: karakterlánc) = "$ firstName $ vezetékNév"

Ez csak a Kotlin-i funkciók rövid bemutatása. A funkciókkal kapcsolatos ajánlott cikkek:

  • Kotlin inline funkciók
  • Kotlin infix funkciók
  • Kotlin függvény hatóköre
  • Kotlin alapértelmezett és elnevezett érvek
  • Kotlin rekurzió
  • Kotlin farok rekurzív funkció
  • Kotlin kiterjesztés funkció
  • Kotlin magas rendű funkciók és lambdák

érdekes cikkek...