Kotlin programozási oktatóanyag

Kotlin története

Íme, fontos tereptárgyak Kotlin történetéből:

Év	esemény
2016	Elindult a Kotlin v1.0
2017	A Google bejelentése a kotlin első osztályú támogatásáról androidon
2018	A Kotlin v1.2 kiegészítéssel érkezik a kódok elosztására a JVM és a között JavaForgatókönyv
2019	A Google bejelentette, hogy a Kotlin a preferált programozási nyelve Android Alkalmazásfejlesztők
2021	20. szeptember 2021-án megjelent a Kotlin v1.5.31.

A Kotlin használatának okai

Íme néhány fontos ok, amiért a Kotlint széles körben használják:

• A Kotlin egy statikusan tipizált nyelv, amely nagyon könnyen olvasható és írható.
• A Kotlin programok nem igényelnek pontosvesszőt a programjukban. Ez megkönnyíti és olvashatóbbá teszi a kódot.
• Ez a nyelv lehetővé teszi az információk cseréjét és felhasználását Java különféle módokon. Ráadásul, Java és a Kotlin kód együtt létezhet ugyanabban a projektben.
• A Kotlin-féle típusú rendszer célja a NullPointerException kivétele a kódból.
• Kevesebb időt vesz igénybe, hogy új kódot írjon a Kotlinban. Még egyszerűbb a kotlin kód üzembe helyezése és nagyarányú karbantartása.

Kotlin jellemzői

Íme a Kotlin néhány olyan funkciója, amelyek megbizonyosodnak arról, hogy a programozási nyelv halad előre.

Vágott kódolás:

A Kotlin egy OOP-alapú programozási nyelv, ahol a kódsor 40%-ig levágható, ami ideális választássá teszi a Kotlint szoftver- vagy webfejlesztéshez.

Nyílt forráskód:

Kotlin azért Android JVM-et használ, és egyesíti az OOP-ok és a funkcionális orientált programozás jellemzőit.

Gyors összeállítás:

A Kotlinnal való munka során könnyen lefordítható a kód, ami jobb teljesítményt eredményez az androidos fejlesztések számára, és azt is elmagyarázza, hogy milyen típusú adatfüggvény használható a teljes kódban.

Kiterjesztési funkciók:

A Kotlin számos kiterjesztési funkciót tud támogatni anélkül, hogy bármiféle változtatást végezne a kódon. segít a meglévő kód vonzóbbá és nagyszerűbbé tételében a fejlesztők számára.

Például:

Fun String.removeFirstLastChar():
String = this.substring(1, this.length -1)

Ez a kód segít a karakterlánc első és utolsó karakterének levágásában, így alkalmazhatjuk:

Val string1 = "Today is cloudy."
Val string2 = string1.removeFirstLastChar()

Null biztonság:

Kotlinban a rendszer különbséget tesz a nulla hivatkozások és nem a nulla hivatkozások között, ahogy az alábbi Kotlin-példában látható.

Például egy String változóban nem szerepelhet null:

Var string1: String = "Today is Sunday"
String1 = null  // compilation error
To permit null, we can adjoin the nullable variable :
Var string2: String? = "Today is Sunday"
String2 = null
print(string2)

Átjárható:

A Kotlin kódot használhatja Javaés Java kódok használhatók Kotlinnal. Tehát, ha van ismereted arról OOP-k programozás, könnyen át lehet váltani a Kotlin fejlesztésére. Akkor is, ha be van írva néhány alkalmazás Java, akkor használhatók Kotlin környezetével.

Robusztus szerszámok:

Mint Java, A Kotlin kód IDE használatával vagy a parancssori felület használatával is írható. Az IDE-vel könnyű dolgozni, és a szintaktikai hibák is drámaian csökkennek. Ugyanakkor, amikor parancssori felülettel dolgozik, először le kell fordítani a kódot.

Smart Cast:

Az intelligens öntés alapvetően segít csökkenteni az alkalmazás költségeit, és javítja annak sebességét vagy teljesítményét. A kód hatékonyságának kezelésén dolgozik típusöntéssel vagy megváltoztathatatlan értékekkel.

Például, ha a karakterlánc azonosítva van, akkor annak hossza és száma, és megtalálható a Smart Cast funkció segítségével:

Val string1: Any = "Today is Monday"
when(string1)
{
is String  -> string1.length
Is Int -> string1.inc()
}

Alacsony átvételi költség:

A vállalkozások a Kotlin-t részesítik előnyben az örökbefogadás költségeinek elvesztése miatt. A legfontosabb, hogy a fejlesztők könnyen megtanulják, különösen, ha programozói háttérrel rendelkeznek.

Kotlin környezet beállítása

A következő lépések segítenek a munkakörnyezet beállításában a Kotlin telepítésével.

1. lépés) Telepítés Java

Amint azt korábban megbeszéltük, a Kotlin azon alapul Java, tehát telepítenie kell Java először, amikor Kotlin örökbefogadását tervezi. Lásd a mi Java Telepítési útmutató.

2. lépés) Telepítés Java Idus

Szerencsére több is van Java Idus választani. Itt letöltési linkeket adtunk, hogy kicsit könnyebbé tegyük a dolgokat.

• A letöltéshez Eclipse, kattints ide.
• A letöltéshez NetBeans, kattints ide.
• Az IntelliJ letöltéséhez kattints ide.

Ebben a Kotlin-oktatóanyagban azt fogjuk használni Eclipse.

3. lépés) Telepítse a Kotlint

A Kotlin telepítéséhez Eclipse, lépjen a Súgó részbe Eclipse és kattintson a Eclipse Marketplace opció.

Most írja be a Kotlin kulcsszót a keresőmezőbe. Kattintson a Go opcióra a bővítmény listázásához. Megadja a Kotlin beépülő modul hivatkozását, a megadott linkről telepítenie kell a plugint.

Kérjük, indítsa újra a Eclipse IDE, ha a telepítés befejeződött. A jobb felső sarokban található egy parancsikon Eclipse IDE. Ez egy gyors hozzáférési módszer.

Egy másik módja annak, hogy hozzáférjen Kotlinhoz Eclipse Az IDE, menj a Windows, Perspectives, Open Perspectives, majd válassza az Egyebek lehetőséget. Itt ellenőrizheti a később telepített bővítmények listáját, az alábbiak szerint.

Miután ellenőrizte a Kotlin telepítését, a következő lépésben hozzuk létre az első Kotlin programot.

4. lépés) Első Kotlin program

Kezdje az első Kotlin projekttel. A Fájl menüből válassza az Új lehetőséget, majd válasszon másokat, és kezdjen egy új Kotlin-projekttel a listából.

Most meg kell határoznia a projekt nevét, és készen áll a Kotlinnal való együttműködésre.

Ezekkel az egyszerű lépésekkel könnyen letölthető Eclipse és Kotlint a rendszerén, és azonnal megírja az első Kotlin-programot.

ArchiKotlin tectúrája

A jól felépített architektúra fontos ahhoz, hogy egy alkalmazás bővítse szolgáltatásait, és megfeleljen a végfelhasználói bázis elvárásainak. A Kotlin sajátos és jellegzetes architektúrával rendelkezik a memória lefoglalására és minőségi eredmények elérésére a fejlesztők és a végfelhasználók számára.

Kotlin korutinjai és osztályai úgy építik fel a magot, hogy kevesebb mintakódot állítsanak elő, erősítsék a teljesítményt és erősítsék a hatékonyságot. Számos olyan forgatókönyv létezik, amikor a kotlin fordító eltérően reagálhat, különösen akkor, ha különféle nyelveket jelöl ki.

Az architektúra diagramon jól látható, hogy a kód végrehajtása három egyszerű lépésben történik.

1. Az első lépésben egy „.kt” vagy kotlin fájl kerül hozzáadásra a fordítóhoz.
2. A második lépésben a Kotlin fordító a kódot bájtkóddá alakítja.
3. A harmadik lépésben a bájtkód kerül be Java Virtuális gép és a JVM végrehajtotta.

Amikor néhány bájtos kódolású fájl működik a JVM-en, fellángolják a kölcsönös kommunikációt egymás között, ezért a Kotlin által a java interoperabilitásának nevezett szolgáltatása megszületik.

Kotlin áttörése JavaA forgatókönyv akkor történik, amikor Kotlin célba vesz JavaForgatókönyv.

Amikor a JavaA forgatókönyv célpontja ki van választva, a Kotlin bármely kódja, amely a könyvtár része, amely Kotlinnal jár, kiszóródik JavaForgatókönyv. Azonban a Java A Development Kit (JDK) vagy bármely használt Java könyvtár kizárt.

A nem Kotlin fájlokat a rendszer nem veszi figyelembe az ilyen művelet során. Célzás közben JavaA Script .kt fájlt a Kotlin fordító ES5.1-be konvertálja, hogy konzisztens kódot hozzon létre JavaForgatókönyv. A Kotlin fordító optimális méretű kimenetre, a meglévő modullal való együttműködésre, a szabványos könyvtárral azonos funkcionalitásra és a JavaSzkript olvasható.

A megbeszélésből egyértelműen kiderül, hogy a Kotlin fordítók hatékonyabb, kompetensebb és függetlenebb kódot tudnak létrehozni, amely további nagy teljesítményű szoftverterméket eredményez.

Kotlin változó

A változók a programban manipulálandó és hivatkozandó adatok tárolására szolgálnak. Alapvetően az adatok tárolásának és címkézésének egysége, amely egy expozíciós álnévre vár, hogy a program könnyen olvasható és könnyen érthető legyen. Más szóval azt mondhatjuk, hogy a változók az információgyűjtés tárolói.

Kotlinban minden változót deklarálni kell. Ha azonban valamelyik változó nincs deklarálva, akkor az szintaktikai hibaként jelenik meg. Ezenkívül a változó deklarációja határozza meg, hogy milyen típusú adatokat engedünk a változóban tárolni. A Kotlinban a változók a val és var kulcsszavakkal definiálhatók. Íme a Kotlin változók deklarálásának szintaxisa:

Var day = "Monday"
Var number = 3

Itt deklaráltuk a helyi változó napot, amelynek értéke "Monday' és amelynek típusa String és egy másik helyi változószám, amelynek értéke 3, típusa pedig Int, mert itt a literál a 3 típusú egész szám.

A helyi változókat szokás szerint egyszerre deklarálják és inicializálják. A Kotlin változó inicializálása közben is végrehajthatunk bizonyos műveleteket.

Azonos adattípusú változón hajthatunk végre műveletet, mivel itt a num1 és a num2 ugyanabból az adattípusból áll, mint az Int, míg a day a string adattípusú. Ergo hibát fog jelezni. Itt van egy másik technika, hogyan definiálhat változókat a Kotlinban.

var day : String = "GURU99"
var num : Int = 100

Nézzük meg, miben különböznek egymástól a var és a val kulcsszavak.

Var :

A Var olyan, mint egy általános változó, amelyet bármilyen programozási nyelvben használnak, és amely többször is felhasználható egyetlen programban. Sőt, a programban bármikor megváltoztathatja az értékét. Ezért ez a változó változó.

Íme egy példa a Kotlin változó változójára:

var num1 = 10
Var num2 = 20
Num1 = 20
print(num1 + num2) // output : 40

Itt a num1 20-as értékét felülírja a szám1 előző értéke, ami 10. Ezért a num1 + num2 kimenete 40 helyett 30.

Érték:

A Val olyan, mint egy konstans változó, és a programban később nem változtathatja meg az értékét, amelyet nem lehet többször hozzárendelni egy programhoz, és csak egyszer használható egy adott programban. Ergo megváltoztathatatlan változóként ismert.

Itt van egy Kotlin program példa a Kotlin megváltoztathatatlan változóira:

Val num1 = 10
Var num2 = 20

Itt a num1 10-es értéke nem írható felül a 1-as szám20 új értékével, mivel az állandó val típusú. Ezért a kimenet 30 helyett 40.

Megjegyzések: A Kotlinban a megváltoztathatatlan változókat részesítik előnyben a változtatható változókkal szemben.

Adattípusok Kotlinban

Az adattípusok egymáshoz viszonyítható értékek halmazai, amelyek leírják a rajtuk végrehajtható műveleteket. Más programozási nyelvekhez hasonlóan a Kotlin is rendelkezik előre meghatározott adattípusokkal, például Int, Boolean, Char, DoubleStb

A Kotlinban minden adattípus objektumnak számít.

Most ebben a Kotlin alapoktatóanyagban merüljünk el mélyebben a Kotlinban használt előre meghatározott adattípusokba.

Numbers :

A Kotlin számokként ismert beépített adattípusokat szolgál ki, amelyek egész számok és lebegőpontosak alkategóriákba sorolhatók. Numbers.

Egész számok:

Az egész számok a számok kategóriája, amelynek négy típusa van:

típus	Méret (bit)	Min érték	Maximális érték
Byte	8	-128	127
rövid	16	-32768	32767
Int	32	-2,147,483,648 (-231)	2,147,483,647 (231-1)
Hosszú	64	-9,223,372,036,854,775,808 (-263)	9,223,372,036,854,775,807 (263-1)

Lebegőpont Numbers :

Lebegőpont Numbers azok a nem egész számok, amelyek néhány decimális értéket hordoznak.

Float: A lebegés egy 32 bites, egyszeres pontosságú lebegőpontos érték.

Példa: var: Float x = 3.25600

Double: Double egy 64 bites dupla pontosságú lebegőpontos érték.

Példa: var: Double y = 2456.345587

Booleans:

A Kotlin-beli Booleans adattípus jelentős a logikai értékek megjelenítéséhez. Csak két lehetséges érték van a Boole-ban, amelyek igazak vagy hamisak.

Például: val nap = igaz

Val day2 = hamis

Karakter :

A karakterek Kotlinban a char nevű kulcsszó segítségével jelennek meg. A Kotlinban az idézőjelek a char deklarációját jelentik. Java-ban a char néha számként használatos, ami a kotlinban nem lehetséges.

Például:

val onechar = 'x'
print(onechar) //  output : x
Val onedigit = '7'
print(onedigit) // output : 7

Kotlin Type Conversion vagy Kotlin Type Casting

A típuskonverzió egy olyan eljárás, amely egy adattípust egy másik adattípus-változóvá konvertál. Ez óriási, más néven Type Casting.

Nyilvánvalóan be Java, támogatott az implicit típusú típuskonverzió vagy egy kisebb adattípus nagyobb adattípusba való implicit típusú typecastingja.

For Example : int abc = 15;
Long bcd = abc; // compiles successfully

A kotlinban azonban egy kisebb adattípus implicit átalakítása nagyobb adattípussá egyáltalán nem támogatott, mivel az int adattípus nem konvertálható implicit módon hosszú adattípussá.

For Example : var abc = 15
Val bcd : Long = abc // error

A Kotlinban azonban a típuskonverzió kifejezetten megtörténik. Itt jön a segédfüggvények útmutatása, amely az egyik adattípus-változó másikra konvertálását irányítja.

Vannak bizonyos segédfunkciók, amelyek az egyik adattípus másikra való konvertálására szolgálnak:

toInt()

toByte()

toShort()

toChar()

hosszú ()

lebegni()

nak nekDouble()

For Example : var abc = 15
Val bcd : Long = abc.toLong() // compiles successfully

Kotlin Operatorzok

OperaA torok jelentős és különleges karakterek vagy szimbólumok, amelyek biztosítják a műveleteket változókkal és értékekkel rendelkező operandusokban. A Kotlinban van egy sor operátor, amelyet különböző műveletekhez használnak, például aritmetikai műveletekhez, hozzárendelési műveletekhez, összehasonlító műveletekhez stb.

Számtan Operators:

Az aritmetikai operátorok összeadásra, kivonásra, szorzásra, osztásra és modulusra használhatók.

Operator	Jelentés
+	Összeadás (karakterlánc összefűzésére is használatos)
-	Kivonás Operator
*	Szorzás Operator
/	osztály Operator
%	Modulus Operator

Például:

var x = 10
var y = 20
var z = ( ( x + y ) * ( x + y ) ) / 2     

Itt a következő kód kimenete 45.

Compare Operators:

Az összehasonlító operátor két érték, két változó vagy két szám összehasonlítására szolgál. A nagyobb mint szimbólummal ( > ), kisebb mint szimbólummal ( < ) és egyenlő a szimbólummal ( ==), nem egyenlő a szimbólummal ( != ), nagyobb, mint egyenlő a szimbólummal ( >= ), kisebb, mint egyenlő szimbólum(<= ). Ez mindig igazat vagy hamisat eredményez.

Például:

var x = 10
Var y =20
Var z = x < y // Output : true
Var w = x > y // Output : false
Var m = x == y // Output : false

Átruházás Operators:

Átruházás Operatorokat használnak az aritmetikai operált értékek hozzárendelésére. Olyan szimbólumokkal használatos, mint a +=, -=, *=, /=, %=.

Például:

var x = 10
var y = 20
var x + = y // Output : 30
Var y - = x // Output : 10
Var x * = y // Output : 200

Növekedés és csökkentés Operators:

Növekedés és csökkentés operátorok a változó vagy szám értékének növelésére és csökkentésére szolgálnak. Olyan szimbólumok segítségével használják, mint a ++ és a —.

A növelésnek és a csökkentésnek két típusa van, ezek a ++a növekedés előtti, a növekedés utáni a++, a –b csökkentés előtti, a b– utólagos csökkentési műveletek.

Például:

var a = 10
var b = 20
var c = a++ // Output: 11
var d = b— //Output : 19     

Kotlin tömbök

A tömb az adattípusok homogén halmaza, és az egyik legalapvetőbb adattípus, amelyet ugyanazon típusú adatok tárolására használnak a szomszédos memóriahelyen. A tömb minden programozási nyelven fontos az adatok rendszerezéséhez, így több, egyetlen helyen tárolt adat könnyen kereshető vagy rendezhető.

A Kotlinban a tömbök ugyanazon adattípusok változtatható együttműködései, nem pedig natív adattípusok.

Íme egy Kotlin tömb bizonyos tulajdonságai

• A tömb mérete deklarálás után nem módosítható.
• A Kotlin tömbjei változtathatók.
• A tömböket összefüggő memóriahelyeken tárolják.
• Egy tömb olyan indexek segítségével érhető el, mint a[1], a[2] stb.
• Egy tömb indexe nullával kezdődik, ami a[0].

A Kotlinban egy tömb két különböző módszerrel definiálható

Az arrayOf() függvény használatával:

Kotlinban jelentős mértékben használják a könyvtári funkciókat. Az egyik ilyen könyvtári függvény az arrayOf() függvény, amely egy tömb definiálására szolgál úgy, hogy a változók értékét átadja a függvénynek.

Például: A tömb implicit típusdeklarációja arrayOf() függvény használatával

val x = arrayOf(1,2,3,4,5,6,7,8,9)

Például: A tömb kifejezetten típusdeklarációja az arrayOf() függvény használatával.

Val y = arrayOf<Int>(1,2,3,4,5,6,7,8,9)

A Array Constructor használatával:

Kotlinban van egy osztály, melynek neve Array. Ezért lehetséges a konstruktor tömbjének használata egy tömb létrehozásához. A konstruktor tömbje két fő paramétert tartalmaz.

Mi a tömb indexe Kotlinban?

Az a függvény, ahol egy tömbindex elfogadható, hogy visszaadja az index kezdeti értékét.

Például:

val abc = Array(7 , { i -> i*1})

Itt a tömb értéke 7, és a lambda kifejezést használjuk az elem értékeinek inicializálására.

Különféle módszerek is léteznek a tömbök elérésére és módosítására bizonyos funkciók használatával. Ezért van két tagfüggvény, a get() és a set(), amelyek az osztálytömb objektumaihoz való hozzáférésre szolgálnak.

Például:

val x = arrayOf(10,20,30,40,50,60,70,80,90)
val y = x.get(0) // Output 10

Itt a kimenet 10, mivel a tömb 0 indexének értéke 10

Megjegyzés: A get() csak egyetlen értéket vesz fel

Például:

val x = arrayOf(10,20,30,40,50,60,70.80.90)
val y = x.set(2, 3) //

Kimenet: 30 40

Itt a kimenet 30 és 40, mivel a tömb 2. indexénél az érték 30, a 3. indexnél pedig 40.

Megjegyzés: a set() egy tömb több értékét veszi fel.

Kotlin Strings

A karakterlánc egy alapvető adattípus bármely programozási nyelvben. A karakterlánc nem más, mint karakterek sorozata. A String osztály karakterláncokat képvisel. A Kotlinban minden karakterlánc a String osztály objektuma, ami azt jelenti, hogy a karakterlánc-literálok az osztály példányaiként valósulnak meg.

Syntax:

 Val myString = "Hey there!"

Kotlin gyűjtemény

Egy gyűjtemény több hasonló típusú objektumot tartalmaz, és ezeket az objektumokat a gyűjteményben elemeknek vagy tételeknek nevezzük. A gyűjtés segíthet az adatok tárolásában, lekérésében, kezelésében és összesítésében.

Gyűjtemények típusai:

Változatlan gyűjtemény

Az ilyen típusú gyűjtemények csak olvasható funkciókat támogatnak. Az elemeit nem lehet módosítani.

A módszerek a következők:

• Lista – listOf() és listOf ()
• Set – setOf()
• Térkép – mapOf()

Változó gyűjtemény

Támogatja az olvasási és írási funkciókat is.

A módszerek közé tartozik

• Lista – mutableListOf(),arrayListOf() és ArrayList
• Set – mutableSetOf(), hashSetOf()
• Térkép – mutableMapOf(), hashMapOf() és HashMap

Kotlin függvények

A függvények bármely programozási nyelvben hasonló utasítások csoportja, amelyek egy adott feladat végrehajtására szolgálnak. A funkciók lehetővé teszik a program számára, hogy különböző kis kódblokkokra bontsa. Ez a kódfelosztás növeli a kód olvashatóságát, a kód újrafelhasználhatóságát, és könnyen kezelhetővé teszi a programot.

Kotlin néven statikusan tipizált nyelvként ismert. Itt a „fun” kulcsszó egy függvény deklarálására szolgál. A Kotlinban kétféle függvény létezik, amelyek kizárólag attól függnek, hogy elérhető-e a szabványos könyvtárban vagy a felhasználói definícióban. Ők:

• Szabványos könyvtári funkció
• Felhasználó által definiált funkció

Most beszéljük meg őket részletesen Kotlin-kód példákkal.

Szabványos könyvtári funkció

Ezek beépített könyvtári függvények, amelyek implicit módon definiálhatók és használhatók.

2. példa:

fun main(args: Array<String>){  
var number = 9  
var result = Math.sqrt(number.toDouble())  
print("$result")  
}  

output:

3.0

Az sqrt() a könyvtárban definiált függvény, amely egy szám négyzetgyökét adja vissza.

print() függvény üzenetet nyomtat egy szabványos kimeneti adatfolyamba.

Felhasználó által definiált funkció

Ahogy a neve is sugallja, ezeket a funkciókat általában a felhasználók hozzák létre, és speciális programozáshoz is használhatók.

Itt a függvények a "fun" kulcsszóval vannak deklarálva.

3. példa:

fun functionName(){
//body of the code
}

Itt meghívjuk a függvényt, hogy kódokat futtasson a függvénynév() törzsben

Példák a Kotlin függvényre:

fun main(args: Array<String>){  
    sum()  
    print("code after sum")  
}  
fun sum(){  
    var num1 =8  
    var num2 = 9  
    println("sum = "+(num1+num2))  
}  

output:

összeg = 17

kód összeg után

Kivételkezelés Kotlinban

A programozásban a kivételt a programban fellépő futásidejű problémaként határozzuk meg, ami a program leállásához vezet. Ezt a problémát a kevesebb memória, a tömb nem köti össze, vagy olyan körülmények okozhatják, mint a nullával való osztás. Az ilyen típusú kódvégrehajtási problémák megfékezésére kivételkezelést alkalmaznak.

A kivételkezelés az a technika, amely kezeli a futásidejű problémákat, és fenntartja a programfolyamatot a végrehajtás során.

Kotlin a 'dobás' kifejezést használja egy kivételobjektum eldobására. Itt minden kivételosztály a Throwable osztály leszármazottja.

Throw MyException ("dobja a kivételt")

A kivételkezelésben négyféle kivétel létezik. Ők:

• try – Ez a blokk olyan utasításokat tartalmaz, amelyek kivételt hozhatnak létre. Utána mindig vagy a fogás vagy végül vagy mindkettő követi.
• catch – a try blokkból kidobott kivételt elkapja.
• végül – Mindig ellenőrzi, hogy a kivételt kezelték-e vagy sem.
• dobás – kifejezetten kivételek dobására szolgál.

Próbáld elkapni:

A try-catch blokkban a kivételkezelésben a try block bezárja a kódot, amely kivételt dobhat, a catch blokk pedig elkapja a kifejezést és kezeli azt.

A try catch blokk szintaxisa:

try{    
//code with exception    
}catch(e: SomeException){  
//code handling exception  
}    

A try szintaxisa a Végül blokkolással

try{    
//code with exception    
}finally{  
// code finally block  
}   

Végül:

A Kolinban a Végül blokk mindig ellenőrzi, hogy a kivételt kezelték-e vagy sem, így ez a kivételkezelés nagyon fontos utasítása.

4. példa:

Ebben a kódrészletben előfordul a kivétel, és azt kezeljük.

fun main (args: Array<String>){  
    try {  	
        val data =  9/ 0  
        println(data)  
    } catch (e: ArithmeticException) {  
        println(e)  
    } finally {  
        println("finally block executes")  
    }  
    println("write next code")  
}  

output:

java.lang.ArithmeticException: / by zero
finally block executes
write next code

Dobás:

A dobásblokk kifejezett kivételt dob. Ezenkívül egyéni kivételek dobására használják.

Syntax:

Throw SomeException()

Throw SomeException()

Példa:

fun main(args: Array<String>) {
    try{
        println("Exception is not thrown yet")
        throw Exception("Everything is not well")
        println("Exception is thrown")
    }
    catch(e: Exception){
        println(e)

    }
    finally{
        println("You can't ignore me")
    }
}

output:

Kotlin Null Biztonság

A Kotlint támogató rendszerek típusai nagyban megkülönböztetik azokat a hivatkozásokat, amelyek nullálható hivatkozásokat hordozhatnak, és azok, amelyek nem hordozhatnak nullálható hivatkozásokat. A Kotlin egy null biztonsági nyelv, amelynek célja, hogy kiküszöbölje a nullmutató kivételt vagy nulla hivatkozást a kódból, amelyet szándékosan A néven ismernek. Billion dollár hiba.

A legszokványosabb buktató a sok közül programozási nyelvek az, hogy a null hivatkozás tagjának elérése során ez NullPointerException-t eredményez, ami a !! operátort vagy ezt a konstruktort használta valahol máshol, és egy másik kódponton adta át. A nullálható tulajdonság minden használat előtt megerősítést igényel a null ellenőrzéshez.

A Kotlinban a rendszer különbséget tesz nulla hivatkozások és nem nulla hivatkozások között.

Például egy String változóban nem szerepelhet null:

5. példa:

fun main(args: Array<String>){
    var x: String = "GURU99 is the only place where you will get maximum technical content!" // Not Null by default
    println("x is : $x")
    // You cannot assign null variable to not-nullable variables 
    // a=null // it will give compilation error
    var y: String? = "Thanks for visiting GURU99" 
// Nullable Variable
    println("y is : $y")
    y = null
    println("y is : $y")
}

output:

Kotlin OOPs

Az objektum-orientált programozási megközelítés lehetővé teszi, hogy egy összetett kódrészletet objektumok létrehozásával kisebb kódblokkokra osszanak fel. Ezeknek az objektumoknak kölcsönösen két jellemzőjük van: állapot és viselkedés.

Íme néhány OOP elem, amelyeket Kotlin kódpéldákkal fogunk megvitatni:

• Osztály és objektumok
• Kivitelezők
• Öröklés
• Absztrakt osztály

Osztály Kotlinban

Az objektum létrehozása előtt először meg kell határoznunk egy osztályt, amelyet az objektum tervrajzának is neveznek.

Syntax:

class ClassName {
    // property
    // member function
    ... .. ...
}

Tárgyak Kotlinban

Az osztály meghatározása során csak az objektum specifikációit adjuk meg, más paraméter, például memória vagy tárhely nincs lefoglalva.

Syntax:

var obj1 = ClassName()

Konstruktorok Kotlinban

A konstruktor az osztálytulajdonságok inicializálásának egyik módja. Ez egy tagfüggvény, amelyet akkor hívnak meg, amikor egy objektumot példányosítanak. De Kotlinban ez másképp működik.

A Kotlinban kétféle konstruktor létezik:

Elsődleges konstruktor: Az osztály inicializálásának optimalizált módja

Syntax:

class myClass(valname: String,varid: Int) {  
    // class body  
}  

Másodlagos konstruktor: Segít inicializálási logika hozzáadásához

Kotlin-öröklés

Az öröklődés akkor következik be, amikor a szülőosztály egyes tulajdonságait az utódosztály szerzi meg. Az öröklődés akkor megengedett, ha két vagy több osztály ugyanazokkal a tulajdonságokkal rendelkezik.

Syntax:

open class ParentClass(primary_construct){
    // common code
  }class ChildClass(primary_construct): ParentClass(primary_construct_initializ){
    // ChildClass specific behaviours
  }

Absztrakt osztály Kotlinban

Az absztrakt osztály olyan osztály, amely nem példányosítható, de örökölhetünk belőlük alosztályokat. Az 'abstract' kulcsszó egy absztrakt osztály deklarálására szolgál.

6. példa:

  open class humanbeings { 
    open fun Eat() { 
        println("All Human being Eat") 
    } 
} 
abstract class Animal : humanbeings() { 
    override abstract fun Eat() 
} 
class Cat: Animal(){ 
    override fun Eat() { 
        println("Cats also loves eating") 
    } 
} 
fun main(args: Array<String>){ 
    val lt = humanbeings() 
    lt.Eat() 
    val d = Cat() 
    d.Eat() 
} 

output:

Kotlin jelene és jövője

Jelen:

• Sok cég szereti Netflix, Pinterest és Corda a Kotlin segítségével hoz létre erőteljes Android apps.
• Rövid, egy év alatt, 2016 és 2017 között, a Kotlin rendkívül népszerűvé vált csodálatos programozási funkcióival.
• 2017-ben a Google bejelentette, hogy a Kotlin az Android-fejlesztés hivatalos programozási nyelve.
• Gyorsan cserélheti Java kódot a Kotlinnal, mivel az 100%-ban együttműködik vele Java és a Android.

A jövő:

• Többplatformos játékfejlesztés
• Platformos mobilalkalmazások fejlesztése
• Szolgáltatásoldali szkriptelés és mikroszolgáltatások
• Gépi tanulás & adatelemzés

Összegzésként

• A Kotlin egy programozási nyelv, amelyet a JetBrains javasolt 2010-ben többplatformos alkalmazásokhoz, az Apache 2.0 licenc alatt.
• A Kotlin név a Kotlin-sziget nevéből származik, hasonló levelezésben Java a java nevű sziget neve után.
• 2016-ban megjelent a Kotlin első verziója, a v1.0
• A Kotlin programok nem igényelnek pontosvesszőt a programjukban. Ez megkönnyíti és olvashatóbbá teszi a kódot.
• Kotlin azért Android A developers egy OOP-alapú programozási nyelv, ahol a kódsor 40%-ig levágható, ami miatt a Kotlin ideális választás szoftver- vagy webfejlesztéshez.
• A Kotlinban az összes változót a var és a val kulcsszavakkal kell deklarálni.
• Más programozási nyelvekhez hasonlóan a Kotlin is rendelkezik előre meghatározott adattípusokkal, például Int, Boolean, Char, DoubleStb
• A Kotlinban van egy sor operátor, amelyet különböző műveletekhez használnak, például aritmetikai műveletekhez, hozzárendelési műveletekhez, összehasonlító műveletekhez stb.
• A Kotlinban a tömbök ugyanazon adattípusok változtatható együttműködései, nem pedig natív adattípusok.
• A Kotlinban a tömbök két módszerrel vannak meghatározva – ArrayOF () és konstruktorok.
• A Kotlin egy null biztonsági nyelv, amely segít eltávolítani a null pointer kivételt vagy null hivatkozást a kódból, amelyet szándékosan A-nak hívnak. Billion dollár hiba.