Kotlin - Hızlı Kılavuz
Kotlin, Java, JavaScript, vb. Gibi yeni bir açık kaynak programlama dilidir. İşlevsel ve teknik bölümü aynı yerde birleştiren yüksek düzeyde güçlü statik olarak yazılmış bir dildir. Şu anda Kotlin, Java ve JavaScript'i hedefliyor. JVM üzerinde çalışır.
Kotlin, Java, Scala, Groovy, Gosu, vb. Gibi diğer programlama dillerinden etkilenir. Kotlin'in sözdizimi JAVA'ya tam olarak benzemeyebilir, ancak dahili olarak Kotlin, programcılar için harika sonuçlar üretmek için mevcut Java Sınıfı kitaplığına güvenir. . Kotlin, dünya çapındaki geliştiricilere birlikte çalışabilirlik, kod güvenliği ve netlik sağlar.
Avantajlar ve dezavantajlar
Aşağıda, uygulama geliştirmeniz için Kotlin kullanmanın avantajlarından bazıları verilmiştir.
Easy Language- Kotlin işlevsel bir dildir ve öğrenmesi çok kolaydır. Sözdizimi Java'ya oldukça benzer, dolayısıyla hatırlaması çok kolaydır. Kotlin daha etkileyici, bu da kodunuzu daha okunaklı ve anlaşılır kılıyor.
Concise- Kotlin, JVM tabanlıdır ve işlevsel bir dildir. Böylece, diğer programlama dillerinde kullanılan çok sayıda kazan plakası kodunu azaltır.
Runtime and Performance - Daha iyi performans ve küçük çalışma süresi.
Interoperability - Kotlin, daha az karmaşık bir şekilde birlikte çalışabilir bir uygulama oluşturacak kadar olgunlaşmıştır.
Brand New- Kotlin, geliştiricilere yeni bir başlangıç sağlayan yepyeni bir dildir. JVM üzerinden geliştirilmiş olsa da Java'nın yerini almaz. Android geliştirmenin ilk resmi dili olarak kabul edilmektedir. Kotlin, - Kotlin = JAVA + ekstra güncellenmiş yeni özellikler olarak tanımlanabilir.
Aşağıda Kotlin'in bazı dezavantajları bulunmaktadır.
Namespace declaration- Kotlin, geliştiricilerin işlevleri en üst düzeyde beyan etmelerine olanak tanır. Bununla birlikte, uygulamanızın birçok yerinde aynı işlev bildirildiğinde, hangi işlevin çağrıldığını anlamak zordur.
No Static Declaration - Kotlin, Java gibi olağan statik işleme değiştiricisine sahip değildir, bu da geleneksel Java geliştiricisi için bazı sorunlara neden olabilir.
Ancak, yerel sisteminizde Kotlin'i çevrimdışı kullanmak istiyorsanız, yerel çalışma alanınızı yapılandırmak için aşağıdaki adımları uygulamanız gerekir.
Step 1 - Java 8 kurulumu.
Dolayısıyla Kotlin JVM üzerinde çalışıyor. Yerel Kotlin geliştirmeniz için JDK 8 kullanmanız gerçekten gerekli. Resmi web sitesine bakınız kahin JDK 8 veya üstü bir sürümünü indirip yüklemek için. JAVA için ortam değişkenini düzgün çalışacak şekilde ayarlamanız gerekebilir. Windows işletim sisteminde kurulumunuzu doğrulamak için, komut isteminde “java –version” a basın ve çıktı olarak sisteminizde kurulu olan java sürümünü gösterecektir.
Step 2 - IDE kurulumu.
İnternet üzerinden kullanılabilen birkaç IDE vardır. İstediğinizi kullanabilirsiniz. Farklı IDE'lerin indirme bağlantısını aşağıdaki tabloda bulabilirsiniz.
| IDE Adı | Kurulum Bağlantısı |
|---|---|
| NetBeans | https://netbeans.org/downloads/ |
| Tutulma | https://www.eclipse.org/downloads/ |
| Intellij | https://www.jetbrains.com/idea/download/#section = windows |
Her zaman maksimum kolaylığı çıkarmak için en son yazılım sürümünü kullanmanız önerilir.
Step 3 - Eclipse yapılandırılıyor.
Eclipse'i açın ve "Eclipse Market Place" e gidin. Aşağıdaki ekranı bulacaksınız.
Arama kutusunda Kotlin'i arayın ve aynısını yerel sisteminize kurun. İnternet hızına bağlı olarak biraz zaman alabilir. Eclipse'inizi başarıyla yükledikten sonra yeniden başlatmanız gerekebilir.
Step 4 - Kotlin Projesi.
Eclipse başarıyla yeniden başlatıldıktan ve Kotlin kurulduktan sonra, anında bir Kotlin projesi oluşturabileceksiniz. GitFile → New → Others listeden “Kotlin projesi” ni seçin.
Proje kurulumu tamamlandığında, “SRC” klasörü altında bir Kotlin dosyası oluşturabilirsiniz. "Src" klasörüne sol tıklayın ve "yeni" ye basın. Kotlin dosyası için bir seçenek alacaksınız, aksi takdirde "diğerlerinden" arama yapmanız gerekebilir. Yeni dosya oluşturulduktan sonra proje dizininiz aşağıdaki gibi görünecektir.
Geliştirme ortamınız artık hazır. Devam edin ve aşağıdaki kod parçasını "Hello.kt" dosyasına ekleyin.
fun main(args: Array<String>) {
println("Hello, World!")
}Bir Kotlin uygulaması olarak çalıştırın ve aşağıdaki ekran görüntüsünde gösterildiği gibi konsolda çıktıyı görün. Daha iyi anlamak ve kullanılabilirlik için kodlama zemini aracımızı kullanacağız.
Hello, World!Kotlin bir programlama dilidir ve bellek ayırmak ve son kullanıcıya kaliteli bir çıktı üretmek için kendi mimarisine sahiptir. Aşağıda, Kotlin derleyicisinin Java ve JavaScript gibi farklı diğer dil türlerini hedeflediği durumlarda farklı çalışacağı farklı senaryolar verilmiştir.
Kotlin derleyicisi bir bayt kodu oluşturur ve bu bayt kodu, Java tarafından üretilen bayt koduna tam olarak eşit olan JVM üzerinde çalışabilir. .classdosya. JVM'de iki bayt kodlu dosya çalıştığında, birbirleriyle iletişim kurabilirler ve bu, Java için Kotlin'de birlikte çalışabilir bir özellik nasıl kurulur.
Kotlin JavaScript'i her hedeflediğinde, Kotlin derleyicisi .ktdosyasını ES5.1'e aktarır ve JavaScript için uyumlu bir kod oluşturur. Kotlin derleyicisi, LLVM aracılığıyla platform tabanlı uyumlu kodlar oluşturabilir.
Bu bölümde, Kotlin programlama dilinde mevcut olan temel veri türleri hakkında bilgi edineceğiz.
Sayılar
Kotlin'de sayıların temsili Java'ya oldukça benzer, ancak Kotlin farklı veri türlerinin dahili dönüşümüne izin vermez. Aşağıdaki tablo, farklı numaralar için farklı değişken uzunlukları listelemektedir.
| Tür | Boyut |
|---|---|
| Çift | 64 |
| Yüzer | 32 |
| Uzun | 64 |
| Int | 32 |
| Kısa | 16 |
| Bayt | 8 |
Aşağıdaki örnekte Kotlin'in farklı veri türleri ile nasıl çalıştığını göreceğiz. Lütfen kodlama alanımıza aşağıdaki kod setini girin.
fun main(args: Array<String>) {
val a: Int = 10000
val d: Double = 100.00
val f: Float = 100.00f
val l: Long = 1000000004
val s: Short = 10
val b: Byte = 1
println("Your Int Value is "+a);
println("Your Double Value is "+d);
println("Your Float Value is "+f);
println("Your Long Value is "+l);
println("Your Short Value is "+s);
println("Your Byte Value is "+b);
}Yukarıdaki kod parçasını kodlama alanında çalıştırdığınızda, web konsolunda aşağıdaki çıktıyı üretecektir.
Your Int Value is 10000
Your Double Value is 100.0
Your Float Value is 100.0
Your Long Value is 1000000004
Your Short Value is 10
Your Byte Value is 1Karakterler
Kotlin, karakter kullanarak char. Karakter gibi tek bir alıntıyla beyan edilmelidir:‘c’. Lütfen kodlama alanımıza aşağıdaki kodu girin ve Kotlin'in karakter değişkenini nasıl yorumladığını görün. Karakter değişkeni, sayı değişkenleri gibi bildirilemez. Kotlin değişkeni iki şekilde beyan edilebilir - biri kullanılarak“var” ve bir başkası kullanıyor “val”.
fun main(args: Array<String>) {
val letter: Char // defining a variable
letter = 'A' // Assigning a value to it
println("$letter")
}Yukarıdaki kod parçası, tarayıcının çıktı penceresinde aşağıdaki çıktıyı verecektir.
ABoole
Boolean, diğer programlama dilleri gibi çok basittir. Boolean için yalnızca iki değerimiz var - doğru veya yanlış. Aşağıdaki örnekte Kotlin'in Boolean'ı nasıl yorumladığını göreceğiz.
fun main(args: Array<String>) {
val letter: Boolean // defining a variable
letter = true // Assinging a value to it
println("Your character value is "+"$letter")
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
Your character value is trueTeller
Dizeler, karakter dizileridir. Java gibi, doğası gereği değişmezler. Kotlin'de iki tür dizgimiz var - biriraw String ve diğeri denir escaped String. Aşağıdaki örnekte, bu dizeleri kullanacağız.
fun main(args: Array<String>) {
var rawString :String = "I am Raw String!"
val escapedString : String = "I am escaped String!\n"
println("Hello!"+escapedString)
println("Hey!!"+rawString)
}Yukarıdaki escaped String örneği, ilk print ifadesinden sonra fazladan satır alanı sağlamaya izin verir. Aşağıdaki tarayıcıda çıktı olacaktır.
Hello!I am escaped String!
Hey!!I am Raw String!Diziler
Diziler homojen verilerin bir koleksiyonudur. Java gibi, Kotlin de farklı veri türlerinin dizilerini destekler. Aşağıdaki örnekte farklı diziler kullanacağız.
fun main(args: Array<String>) {
val numbers: IntArray = intArrayOf(1, 2, 3, 4, 5)
println("Hey!! I am array Example"+numbers[2])
}Yukarıdaki kod parçası aşağıdaki çıktıyı verir. Dizinin indekslenmesi diğer programlama dillerine benzer. Burada değeri "3" olan ikinci bir indeks arıyoruz.
Hey!! I am array Example3Koleksiyonlar
Koleksiyon, veri yapısının çok önemli bir parçasıdır ve yazılım geliştirmeyi mühendisler için kolaylaştırır. Kotlin'in iki tür koleksiyonu vardır - biriimmutable collection (bu, düzenlenemeyen listeler, haritalar ve kümeler anlamına gelir) ve diğeri mutable collection(bu tür koleksiyon düzenlenebilir). Kotlin sistemi bunlarda belirli bir farkı temsil etmediğinden, uygulamanızda kullanılan koleksiyon türünü akılda tutmanız çok önemlidir.
fun main(args: Array<String>) {
val numbers: MutableList<Int> = mutableListOf(1, 2, 3) //mutable List
val readOnlyView: List<Int> = numbers // immutable list
println("my mutable list--"+numbers) // prints "[1, 2, 3]"
numbers.add(4)
println("my mutable list after addition --"+numbers) // prints "[1, 2, 3, 4]"
println(readOnlyView)
readOnlyView.clear() // ⇒ does not compile
// gives error
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir. Değişken koleksiyon listesini temizlemeye çalıştığımızda hata veriyor.
main.kt:9:18: error: unresolved reference: clear
readOnlyView.clear() // -> does not compile
^Koleksiyonda Kotlin, aşağıdaki gibi bazı yararlı yöntemler sağlar: first(), last(), filter(), vb. Tüm bu yöntemler kendi kendini tanımlayıcıdır ve uygulaması kolaydır. Üstelik Kotlin, koleksiyonu gerçekleştirirken Java gibi aynı yapıyı takip ediyor. Harita ve Set gibi seçtiğiniz herhangi bir koleksiyonu uygulamakta özgürsünüz.
Aşağıdaki örnekte, farklı yerleşik yöntemler kullanarak Map ve Set uyguladık.
fun main(args: Array<String>) {
val items = listOf(1, 2, 3, 4)
println("First Element of our list----"+items.first())
println("Last Element of our list----"+items.last())
println("Even Numbers of our List----"+items.
filter { it % 2 = = 0 }) // returns [2, 4]
val readWriteMap = hashMapOf("foo" to 1, "bar" to 2)
println(readWriteMap["foo"]) // prints "1"
val strings = hashSetOf("a", "b", "c", "c")
println("My Set Values are"+strings)
}Yukarıdaki kod parçası, tarayıcıda aşağıdaki çıktıyı verir.
First Element of our list----1
Last Element of our list----4
Even Numbers of our List----[2, 4]
1
My Set Values are[a, b, c]Aralıklar
Aralıklar, Kotlin'in bir başka benzersiz özelliğidir. Haskell gibi, bir aralıkta yineleme yapmanıza yardımcı olan bir operatör sağlar. Dahili olarak, kullanılarak uygulanırrangeTo() ve operatör formu (..).
Aşağıdaki örnekte, Kotlin'in bu aralık operatörünü nasıl yorumladığını göreceğiz.
fun main(args: Array<String>) {
val i:Int = 2
for (j in 1..4)
print(j) // prints "1234"
if (i in 1..10) { // equivalent of 1 < = i && i < = 10
println("we found your number --"+i)
}
}Yukarıdaki kod parçası, tarayıcıda aşağıdaki çıktıyı verir.
1234we found your number --2Önceki bölümde, Kotlin sisteminde bulunan farklı veri türleri hakkında bilgi sahibi olduk. Bu bölümde, Kotlin'de bulunan farklı kontrol akış mekanizması türlerini tartışacağız.
If - Else
Kotlin işlevsel bir dildir, dolayısıyla Kotlin'deki her işlevsel dil gibi “if”bir ifadedir, bir anahtar kelime değildir. İfade“if”gerektiğinde bir değer döndürür. Diğer programlama dili gibi,“if-else”blok, ilk koşullu kontrol operatörü olarak kullanılır. Aşağıdaki örnekte, iki değişkeni karşılaştıracağız ve buna göre gerekli çıktıyı sağlayacağız.
fun main(args: Array<String>) {
val a:Int = 5
val b:Int = 2
var max: Int
if (a > b) {
max = a
} else {
max = b
}
print("Maximum of a or b is " +max)
// As expression
// val max = if (a > b) a else b
}Yukarıdaki kod parçası, tarayıcıda sonuç olarak aşağıdaki çıktıyı verir. Örneğimiz ayrıca nasıl kullanılacağını gösteren başka bir kod satırı içerir“If” ifade olarak ifade.
Maximum of a or b is 5Ne Zaman Kullanımı
Diğer programlama dillerine aşina iseniz, belirli bir değişkene birden çok koşul uygulanabildiğinde temelde koşullu bir işleç olan switch deyimini duymuş olabilirsiniz. “when”işleci, değişken değerini şube koşullarına göre eşleştirir. Dallanma koşulunu yerine getiriyorsa, o kapsam içindeki ifadeyi çalıştıracaktır. Aşağıdaki örnekte, Kotlin'de "ne zaman" hakkında daha fazla bilgi edineceğiz.
fun main(args: Array<String>) {
val x:Int = 5
when (x) {
1 -> print("x = = 1")
2 -> print("x = = 2")
else -> { // Note the block
print("x is neither 1 nor 2")
}
}
}Yukarıdaki kod parçası, tarayıcıda aşağıdaki çıktıyı verir.
x is neither 1 nor 2Yukarıdaki örnekte, Kotlin derleyicisi şu değerle eşleşir: xverilen şubeler ile. Dalların hiçbiriyle eşleşmiyorsa, o zaman else bölümünü çalıştıracaktır. Pratik olarak, ne zaman birden fazla if bloğuna eşdeğerdir. Kotlin, geliştiriciye, kontrollerin içinde "" sağlayarak aynı satırda birden çok kontrol sağlayabileceği başka bir esneklik sağlar. Yukarıdaki örneği aşağıdaki gibi değiştirelim.
fun main(args: Array<String>) {
val x:Int = 5
when (x) {
1,2 -> print(" Value of X either 1,2")
else -> { // Note the block
print("x is neither 1 nor 2")
}
}
}Aynısını tarayıcıda da çalıştırın, bu tarayıcıda aşağıdaki çıktıyı verecektir.
x is neither 1 nor 2Döngü için
Döngü, her tür veri yapısında yineleme esnekliği sağlayan böyle bir buluştur. Diğer programlama dilleri gibi, Kotlin de birçok çeşit Döngü yöntemi sağlar, ancak bunlar arasında“For”en başarılı olanıdır. For döngüsünün uygulanması ve kullanımı kavramsal olarak Java for döngüsüne benzer. Aşağıdaki örnek, aynısını gerçek hayat örneklerinde nasıl kullanabileceğimizi göstermektedir.
fun main(args: Array<String>) {
val items = listOf(1, 2, 3, 4)
for (i in items) println("values of the array"+i)
}Yukarıdaki kod parçasında, "öğeler" adında bir liste tanımladık ve for döngüsünü kullanarak bu tanımlı listeyi yineliyor ve değerini tarayıcıda yazdırıyoruz. Aşağıdaki çıktıdır.
values of the array1
values of the array2
values of the array3
values of the array4Aşağıda, geliştirme çalışmalarımızı her zamankinden daha kolay hale getirmek için bazı kütüphane işlevlerini kullandığımız başka bir kod örneği var.
fun main(args: Array<String>) {
val items = listOf(1, 22, 83, 4)
for ((index, value) in items.withIndex()) {
println("the element at $index is $value")
}
}Yukarıdaki kod parçasını kodlama alanımızda derleyip yürüttüğümüzde, tarayıcıda aşağıdaki çıktıyı verecektir.
the element at 0 is 1
the element at 1 is 22
the element at 2 is 83
the element at 3 is 4Döngü Halindeyken ve Yaparken Döngü
While ve Do-While, diğer programlama dillerinde olduğu gibi tam olarak benzer şekilde çalışır. Bu iki döngü arasındaki tek fark, Do-while döngüsü durumunda koşul, döngünün sonunda test edilecektir. Aşağıdaki örnek,While loop.
fun main(args: Array<String>) {
var x:Int = 0
println("Example of While Loop--")
while(x< = 10) {
println(x)
x++
}
}Yukarıdaki kod parçası, tarayıcıda aşağıdaki çıktıyı verir.
Example of While Loop--
0
1
2
3
4
5
6
7
8
9
10Kotlin ayrıca, döngü gövdesinin bir kez yürütüleceği, ancak o zaman koşulun kontrol edileceği Do-While döngüsü adı verilen başka bir döngüye de sahiptir. Aşağıdaki örnek,Do-while loop.
fun main(args: Array<String>) {
var x:Int = 0
do {
x = x + 10
println("I am inside Do block---"+x)
} while(x <= 50)
}Yukarıdaki kod parçası, tarayıcıda aşağıdaki çıktıyı verir. Yukarıdaki kodda, Kotlin derleyicisi DO bloğunu çalıştıracak, ardından blok sırasında koşul kontrolüne gidecektir.
I am inside Do block---10
I am inside Do block---20
I am inside Do block---30
I am inside Do block---40
I am inside Do block---50
I am inside Do block---60İade, Ara, Devam Kullanımı
Herhangi bir programlama diline aşinaysanız, uygulamada iyi bir kontrol akışı sağlamamıza yardımcı olan farklı anahtar kelimeler hakkında bir fikriniz olmalıdır. Aşağıdakiler, döngüleri veya diğer kontrol akışı türlerini kontrol etmek için kullanılabilecek farklı anahtar sözcüklerdir.
Return- Dönüş, çağrılan işlevden çağıran işleve bir değer döndüren bir anahtar sözcüktür. Aşağıdaki örnekte, bu senaryoyu Kotlin kodlama zeminimizi kullanarak uygulayacağız.
fun main(args: Array<String>) {
var x:Int = 10
println("The value of X is--"+doubleMe(x))
}
fun doubleMe(x:Int):Int {
return 2*x;
}Yukarıdaki kod parçasında, başka bir işlevi çağırıp girdiyi 2 ile çarpıyoruz ve ortaya çıkan değeri ana işlevimiz olan çağrılan işleve döndürüyoruz. Kotlin, işlevi sonraki bölümde inceleyeceğimiz farklı bir şekilde tanımlar. Şimdilik, yukarıdaki kodun tarayıcıda aşağıdaki çıktıyı üreteceğini anlamak yeterlidir.
The value of X is--20Continue & Break- Devam etmek ve ara vermek, mantıksal bir sorunun en hayati parçasıdır. "Break" anahtar sözcüğü, bazı koşullar başarısız olursa denetleyici akışını sonlandırır ve "devam et" tam tersini yapar. Tüm bu operasyon anında görünürlükle gerçekleşir. Kotlin, geliştiricinin görünürlük olarak birden fazla etiketi uygulayabileceği diğer programlama dillerinden daha akıllıdır. Aşağıdaki kod parçası, bu etiketi Kotlin'de nasıl uyguladığımızı göstermektedir.
fun main(args: Array<String>) {
println("Example of Break and Continue")
myLabel@ for(x in 1..10) { // appling the custom label
if(x = = 5) {
println("I am inside if block with value"+x+"\n-- hence it will close the operation")
break@myLabel //specifing the label
} else {
println("I am inside else block with value"+x)
continue@myLabel
}
}
}Yukarıdaki kod parçası, tarayıcıda aşağıdaki çıktıyı verir.
Example of Break and Continue
I am inside else block with value1
I am inside else block with value2
I am inside else block with value3
I am inside else block with value4
I am inside if block with value5
-- hence it will close the operationGördüğünüz gibi, denetleyici, değeri kadar ve olmadıkça döngüye devam eder. x 5'tir. değeri x 5'e ulaştığında, if bloğunu yürütmeye başlar ve break ifadesine ulaşıldığında, tüm kontrol akışı program yürütmesini sonlandırır.
Bu bölümde, Kotlin kullanarak Nesneye Yönelik Programlamanın (OOP) temellerini öğreneceğiz. Sınıfı ve nesnesini ve bu nesneyle nasıl oynanacağını öğreneceğiz. OOP'nin tanımına göre, bir sınıf, bir çalışma zamanı varlığının bir planıdır ve nesne, hem davranışını hem de durumunu içeren durumudur. Kotlin'de sınıf bildirimi, Java'ya benzer şekilde kaşlı ayraçlarla çevrili bir sınıf başlığı ve bir sınıf gövdesinden oluşur.
Class myClass { // class Header
// class Body
}Java gibi, Kotlin de bir sınıfın birkaç nesnesini oluşturmanıza izin verir ve sınıf üyelerini ve işlevlerini dahil etmekte özgürsünüz. Sınıf üyeleri değişkenlerinin görünürlüğünü, Bölüm 10 - Görünürlük Kontrolü'nde öğreneceğimiz farklı anahtar kelimeleri kullanarak kontrol edebiliriz. Aşağıdaki örnekte, o sınıfın farklı veri üyelerine erişeceğimiz bir sınıf ve nesnesini oluşturacağız.
class myClass {
// property (data member)
private var name: String = "Tutorials.point"
// member function
fun printMe() {
print("You are at the best Learning website Named-"+name)
}
}
fun main(args: Array<String>) {
val obj = myClass() // create obj object of myClass class
obj.printMe()
}Yukarıdaki kod parçası, kendi nesnesini kullanarak myClass'ın printMe () işlevini çağırdığımız tarayıcıda aşağıdaki çıktıyı verecektir.
You are at the best Learning website Named- Tutorials.pointYuvalanmış Sınıf
Tanım gereği, bir sınıf başka bir sınıf içinde oluşturulduğunda, bu sınıf iç içe bir sınıf olarak adlandırılır. Kotlin'de, yuvalanmış sınıf varsayılan olarak statiktir, dolayısıyla o sınıfın herhangi bir nesnesini oluşturmadan erişilebilir. Aşağıdaki örnekte Kotlin'in yuvalanmış sınıfımızı nasıl yorumladığını göreceğiz.
fun main(args: Array<String>) {
val demo = Outer.Nested().foo() // calling nested class method
print(demo)
}
class Outer {
class Nested {
fun foo() = "Welcome to The TutorialsPoint.com"
}
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
Welcome to The TutorialsPoint.comİç Sınıf
İç içe geçmiş bir sınıf "iç" olarak işaretlendiğinde, bu bir Inner sınıfı olarak adlandırılır. Bir iç sınıfa, dış sınıfın veri üyesi tarafından erişilebilir. Aşağıdaki örnekte, dış sınıfın veri üyesine erişeceğiz.
fun main(args: Array<String>) {
val demo = Outer().Nested().foo() // calling nested class method
print(demo)
}
class Outer {
private val welcomeMessage: String = "Welcome to the TutorialsPoint.com"
inner class Nested {
fun foo() = welcomeMessage
}
}Yukarıdaki kod parçası, derleme sırasında Kotlin derleyicileri tarafından sağlanan varsayılan kurucuyu kullanarak yuvalanmış sınıfı çağırdığımız tarayıcıda aşağıdaki çıktıyı verecektir.
Welcome to the TutorialsPoint.comAnonim İç Sınıf
Anonim iç sınıf, bir programcının hayatını çok kolaylaştıran oldukça iyi bir kavramdır. Ne zaman bir arayüz uygularsak, anonim iç blok kavramı ortaya çıkar. Çalışma zamanı nesne başvurusunu kullanarak bir arabirim nesnesi oluşturma kavramı, anonim sınıf olarak bilinir. Aşağıdaki örnekte, bir arayüz oluşturacağız ve Anonymous Inner sınıf mekanizmasını kullanarak bu arayüzün bir nesnesini oluşturacağız.
fun main(args: Array<String>) {
var programmer :Human = object:Human // creating an instance of the interface {
override fun think() { // overriding the think method
print("I am an example of Anonymous Inner Class ")
}
}
programmer.think()
}
interface Human {
fun think()
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
I am an example of Anonymous Inner ClassTür Takma Adları
Tür takma adları, Kotlin derleyicisinin bir özelliğidir. Mevcut bir türden yeni bir ad oluşturma esnekliği sağlar, yeni bir tür oluşturmaz. Tür adı çok uzunsa, kolayca daha kısa bir ad ekleyebilir ve ileride kullanmak için aynısını kullanabilirsiniz. Tür takma adları, karmaşık türler için gerçekten yararlıdır. En son sürümde Kotlin, tür takma adları desteğini iptal etti, ancak Kotlin'in eski bir sürümünü kullanıyorsanız, aşağıdaki gibi kullanabilirsiniz -
typealias NodeSet = Set<Network.Node>
typealias FileTable<K> = MutableMap<K, MutableList<File>>Bu bölümde, Kotlin'deki inşaatçılar hakkında bilgi edineceğiz. Kotlin'in iki tür kurucusu vardır - biriprimary constructor ve diğeri secondary constructor. Bir Kotlin sınıfı, bir birincil oluşturucuya ve bir veya daha fazla ikincil oluşturucuya sahip olabilir. Java yapıcısı üye değişkenleri başlatır, ancak, Kotlin'de birincil kurucu sınıfı başlatırken, ikincil kurucu aynı şeyi başlatırken bazı ekstra mantık eklemeye yardımcı olur. Birincil kurucu, aşağıdaki örnekte gösterildiği gibi sınıf başlığı düzeyinde bildirilebilir.
class Person(val firstName: String, var age: Int) {
// class body
}Yukarıdaki örnekte, birincil kurucuyu parantez içinde ilan ettik. İki alan arasında, alan yaşı düzenlenebilirken, "val" olarak bildirildiği için ad salt okunurdur. Aşağıdaki örnekte birincil kurucuyu kullanacağız.
fun main(args: Array<String>) {
val person1 = Person("TutorialsPoint.com", 15)
println("First Name = ${person1.firstName}") println("Age = ${person1.age}")
}
class Person(val firstName: String, var age: Int) {
}Yukarıdaki kod parçası, iki değişkeni otomatik olarak başlatacak ve tarayıcıda aşağıdaki çıktıyı sağlayacaktır.
First Name = TutorialsPoint.com
Age = 15Daha önce belirtildiği gibi Kotlin, sınıfınız için bir veya daha fazla ikincil kurucu oluşturmanıza izin verir. Bu ikincil kurucu, "yapıcı" anahtar sözcüğü kullanılarak oluşturulur. Kotlin'de birden fazla kurucu oluşturmak istediğinizde veya birincil kurucuya daha fazla mantık dahil etmek istediğinizde gereklidir ve bunu yapamazsınız çünkü birincil kurucu başka bir sınıf tarafından çağrılabilir. İkincil bir kurucu oluşturduğumuz ve aynısını uygulamak için yukarıdaki örneği kullandığımız aşağıdaki örneğe bir göz atın.
fun main(args: Array<String>) {
val HUman = HUman("TutorialsPoint.com", 25)
print("${HUman.message}"+"${HUman.firstName}"+
"Welcome to the example of Secondary constructor, Your Age is-${HUman.age}")
}
class HUman(val firstName: String, var age: Int) {
val message:String = "Hey!!!"
constructor(name : String , age :Int ,message :String):this(name,age) {
}
}Note - Herhangi bir sayıda ikincil oluşturucu oluşturulabilir, ancak bu kurucuların tümü birincil kurucuyu doğrudan veya dolaylı olarak çağırmalıdır.
Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
Hey!!! TutorialsPoint.comWelcome to the example of Secondary constructor, Your Age is- 25Bu bölümde miras hakkında bilgi edineceğiz. Tanımı gereği, mirasın ana sınıfın bazı özelliklerini çocuk sınıfına aktarmak anlamına geldiğini hepimiz biliyoruz. Kotlin'de temel sınıf, Kotlin'de bildirilen "herhangi" varsayılan sınıfın süper sınıfı olan "Herhangi biri" olarak adlandırılır. Diğer tüm OOPS gibi, Kotlin de bu işlevselliği,“:”.
Kotlin'deki her şey varsayılan olarak nihaidir, bu nedenle, kalıtıma izin vermesi için sınıf bildiriminin önünde "açık" anahtar sözcüğünü kullanmamız gerekir. Aşağıdaki kalıtım örneğine bir göz atın.
import java.util.Arrays
open class ABC {
fun think () {
print("Hey!! i am thiking ")
}
}
class BCD: ABC(){ // inheritence happend using default constructor
}
fun main(args: Array<String>) {
var a = BCD()
a.think()
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
Hey!! i am thikingŞimdi, alt sınıfta think () yöntemini geçersiz kılmak istersek ne olur? Ardından, iki sınıf oluşturduğumuz ve işlevlerinden birini alt sınıfta geçersiz kıldığımız aşağıdaki örneği ele almalıyız.
import java.util.Arrays
open class ABC {
open fun think () {
print("Hey!! i am thinking ")
}
}
class BCD: ABC() { // inheritance happens using default constructor
override fun think() {
print("I Am from Child")
}
}
fun main(args: Array<String>) {
var a = BCD()
a.think()
}Yukarıdaki kod parçası, alt sınıfın miras alınan yöntemini çağıracak ve tarayıcıda aşağıdaki çıktıyı verecektir. Java gibi, Kotlin de çoklu mirasa izin vermez.
I Am from ChildBu bölümde Kotlin'deki arayüz hakkında bilgi edineceğiz. Kotlin'de arayüz, Java 8'e tam olarak benzer şekilde çalışır, bu da onların yöntem uygulamasını ve soyut yöntem bildirimini içerebileceği anlamına gelir. Bir arayüz, tanımlanmış işlevselliğini kullanmak için bir sınıf tarafından uygulanabilir. Bölüm 6 - "anonim iç sınıf" bölümünde arabirimle bir örneği zaten tanıttık. Bu bölümde bunun hakkında daha çok şey öğreneceğiz. Aşağıdaki kod parçasında gösterildiği gibi, "arayüz" anahtar kelimesi Kotlin'de bir arayüz tanımlamak için kullanılır.
interface ExampleInterface {
var myVar: String // abstract property
fun absMethod() // abstract method
fun sayHello() = "Hello there" // method with default implementation
}Yukarıdaki örnekte, "ExampleInterface" adında bir arayüz oluşturduk ve bunun içinde bir çift soyut özellik ve yöntemimiz var. Uygulanan bir yöntem olan "sayHello ()" adlı işleve bakın.
Aşağıdaki örnekte, yukarıdaki arayüzü bir sınıfta uygulayacağız.
interface ExampleInterface {
var myVar: Int // abstract property
fun absMethod():String // abstract method
fun hello() {
println("Hello there, Welcome to TutorialsPoint.Com!")
}
}
class InterfaceImp : ExampleInterface {
override var myVar: Int = 25
override fun absMethod() = "Happy Learning "
}
fun main(args: Array<String>) {
val obj = InterfaceImp()
println("My Variable Value is = ${obj.myVar}")
print("Calling hello(): ")
obj.hello()
print("Message from the Website-- ")
println(obj.absMethod())
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
My Variable Value is = 25
Calling hello(): Hello there, Welcome to TutorialsPoint.Com!
Message from the Website-- Happy LearningDaha önce de belirtildiği gibi, Kotlin çoklu kalıtımı desteklemez, ancak aynı şey aynı anda ikiden fazla arayüzün uygulanmasıyla da elde edilebilir.
Aşağıdaki örnekte, iki arayüz oluşturacağız ve daha sonra her iki arayüzü de bir sınıfa uygulayacağız.
interface A {
fun printMe() {
println(" method of interface A")
}
}
interface B {
fun printMeToo() {
println("I am another Method from interface B")
}
}
// implements two interfaces A and B
class multipleInterfaceExample: A, B
fun main(args: Array<String>) {
val obj = multipleInterfaceExample()
obj.printMe()
obj.printMeToo()
}Yukarıdaki örnekte, iki örnek arabirim A, B oluşturduk ve "multipleInterfaceExample" adlı sınıfta daha önce bildirilmiş iki arabirim uyguladık. Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
method of interface A
I am another Method from interface BBu bölümde, Kotlin dilinde mevcut olan farklı değiştiriciler hakkında bilgi edineceğiz. Access modifieruygulamada kullanılan değişkenlerin, yöntemlerin ve sınıfların kullanımını kısıtlamak için kullanılır. Diğer OOP programlama dili gibi, bu değiştirici de sınıf başlığı veya yöntem bildirimi gibi birden çok yerde uygulanabilir. Kotlin'de dört erişim değiştirici mevcuttur.
Özel
Sınıflar, yöntemler ve paketler özel bir değiştirici ile bildirilebilir. Herhangi bir şey özel olarak ilan edildiğinde, hemen kapsamı dahilinde erişilebilir olacaktır. Örneğin, özel bir pakete bu belirli dosya içinde erişilebilir. Özel bir sınıfa veya arayüze yalnızca veri üyeleri vb. Tarafından erişilebilir.
private class privateExample {
private val i = 1
private val doSomething() {
}
}Yukarıdaki örnekte, sınıf “privateExample” ve i değişkeninin her ikisine de yalnızca aynı Kotlin dosyasında erişilebilir, burada hepsinin ifade bloğunda özel olarak bildirildiği yer.
Korumalı
Korumalı, Kotlin için başka bir erişim değiştiricidir ve şu anda herhangi bir paketin korunamayacağı gibi üst düzey bildirim için mevcut değildir. Korumalı bir sınıf veya arabirim yalnızca alt sınıfı tarafından görülebilir.
class A() {
protected val i = 1
}
class B : A() {
fun getValue() : Int {
return i
}
}Yukarıdaki örnekte, değişken “i” korumalı olarak ilan edildiğinden, yalnızca alt sınıfı tarafından görülebilir.
İç
Dahili, Kotlin'de tanıtılan yeni eklenen bir değiştiricidir. Herhangi bir şey dahili olarak işaretlenmişse, o belirli alan dahili alanda olacaktır. Dahili paket yalnızca altında uygulandığı modülün içinde görülebilir. Dahili bir sınıf arabirimi yalnızca aynı pakette veya modülde bulunan diğer sınıf tarafından görülebilir. Aşağıdaki örnekte, dahili bir yöntemin nasıl uygulanacağını göreceğiz.
class internalExample {
internal val i = 1
internal fun doSomething() {
}
}Yukarıdaki örnekte, "doSomething" adlı yöntem ve değişken dahili olarak belirtilmiştir, dolayısıyla bu iki alana yalnızca bildirildiği paketin içinde erişilebilir.
halka açık
Genel değiştiriciye proje çalışma alanındaki herhangi bir yerden erişilebilir. Erişim değiştiricisi belirtilmezse, varsayılan olarak genel kapsamda olacaktır. Önceki tüm örneklerimizde herhangi bir değiştiriciden bahsetmedik, bu nedenle hepsi genel kapsamdadır. Aşağıda, genel bir değişken veya yöntemin nasıl bildirileceğini daha iyi anlamak için bir örnek verilmiştir.
class publicExample {
val i = 1
fun doSomething() {
}
}Yukarıdaki örnekte, herhangi bir değiştiriciden bahsetmedik, bu nedenle tüm bu yöntemler ve değişkenler varsayılan olarak geneldir.
Bu bölümde, Kotlin'in "Uzantı" adlı bir başka yeni özelliğini öğreneceğiz. Uzantıyı kullanarak, bazı yöntem işlevlerini devralmadan veya değiştirmeden bile ekleyebilir veya kaldırabiliriz. Uzantılar istatistiksel olarak çözülür. Gerçekte var olan sınıfı değiştirmez, ancak bir nokta işlemiyle çağrılabilen çağrılabilir bir işlev oluşturur.
İşlev Uzantısı
İşlev uzantısında Kotlin, ana sınıfın dışında bir yöntem tanımlamaya izin verir. Aşağıdaki örnekte, uzantının işlevsel düzeyde nasıl uygulandığını göreceğiz.
class Alien {
var skills : String = "null"
fun printMySkills() {
print(skills)
}
}
fun main(args: Array<String>) {
var a1 = Alien()
a1.skills = "JAVA"
//a1.printMySkills()
var a2 = Alien()
a2.skills = "SQL"
//a2.printMySkills()
var a3 = Alien()
a3.skills = a1.addMySkills(a2)
a3.printMySkills()
}
fun Alien.addMySkills(a:Alien):String{
var a4 = Alien()
a4.skills = this.skills + " " +a.skills
return a4.skills
}Yukarıdaki örnekte, "Alien" sınıfının içinde "addMySkills ()" olarak adlandırılan herhangi bir yöntemimiz yok, ancak yine de aynı yöntemi sınıfın dışında başka bir yerde uyguluyoruz, Bu, uzantının büyüsüdür.
Yukarıdaki kod parçası, tarayıcıda aşağıdaki çıktıyı üretecektir.
JAVA SQLNesne Uzantısı
Kotlin, Java'nın statik işlevselliğini uygulamak için başka bir mekanizma sağlar. Bu, "tamamlayıcı nesne" anahtar sözcüğü kullanılarak elde edilebilir. Bu mekanizmayı kullanarak, bir fabrika yöntemi içinde bir sınıfın bir nesnesini oluşturabiliriz ve daha sonra bu yöntemi sınıf adının referansını kullanarak çağırabiliriz. Aşağıdaki örnekte, bir "tamamlayıcı nesne" oluşturacağız.
fun main(args: Array<String>) {
println("Heyyy!!!"+A.show())
}
class A {
companion object {
fun show():String {
return("You are learning Kotlin from TutorialsPoint.com")
}
}
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
Heyyy!!! You are learning Kotlin from TutorialsPoint.comYukarıdaki örnek Java'da statik gibi görünüyor, ancak gerçek zamanlı olarak aynı sınıfın bir üye değişkeni olarak bir nesne oluşturuyoruz. Bu nedenle, uzantı özelliği altına da dahil edilir ve alternatif olarak bir nesne uzantısı olarak adlandırılabilir. Temel olarak, aynı sınıfın nesnesini üye işlevlerden bazılarını kullanacak şekilde genişletiyorsunuz.
Bu bölümde, Kotlin programlama dilinin Veri sınıfları hakkında daha fazla bilgi edineceğiz. Bir sınıf, "veri" olarak işaretlendiğinde Veri sınıfı olarak işaretlenebilir. Bu tür bir sınıf, temel verileri ayrı tutmak için kullanılabilir. Bunun dışında herhangi bir işlevsellik sağlamaz.
Tüm veri sınıflarının bir birincil kurucuya sahip olması gerekir ve tüm birincil kurucuların en az bir parametresi olmalıdır. Bir sınıf veri olarak işaretlendiğinde, bu veri sınıfının "toString ()", "hashCode ()" gibi bazı dahili işlevlerini kullanabiliriz. Herhangi bir veri sınıfının abstract ve open veya internal gibi bir değiştiricisi olamaz. Veri sınıfı diğer sınıflara da genişletilebilir. Aşağıdaki örnekte, bir veri sınıfı oluşturacağız.
fun main(args: Array<String>) {
val book: Book = Book("Kotlin", "TutorialPoint.com", 5)
println("Name of the Book is--"+book.name) // "Kotlin"
println("Puclisher Name--"+book.publisher) // "TutorialPoint.com"
println("Review of the book is--"+book.reviewScore) // 5
book.reviewScore = 7
println("Printing all the info all together--"+book.toString())
//using inbuilt function of the data class
println("Example of the hashCode function--"+book.hashCode())
}
data class Book(val name: String, val publisher: String, var reviewScore: Int)Yukarıdaki kod parçası, tarayıcıda, verilerin bir kısmını tutmak için bir veri sınıfı oluşturduğumuz ve ana işlevden tüm veri üyelerine eriştiğimiz aşağıdaki çıktıyı verecektir.
Name of the Book is--"Kotlin"
Puclisher Name--"TutorialPoint.com"
Review of the book is--5
Printing all the info all together--(name-Kotlin, publisher-TutorialPoint.com, reviewScore-7)
Example of the hashCode function---1753517245Bu bölümde, "Mühürlü" sınıf adı verilen başka bir sınıf türü hakkında bilgi edineceğiz. Bu sınıf türü, sınırlı bir sınıf hiyerarşisini temsil etmek için kullanılır. Mühürlü, geliştiricilerin önceden tanımlanmış türde bir veri türünü korumasına olanak tanır. Mühürlü bir sınıf oluşturmak için, bu sınıfın bir değiştiricisi olarak "mühürlenmiş" anahtar kelimesini kullanmamız gerekir. Mühürlü bir sınıfın kendi alt sınıfı olabilir, ancak tüm bu alt sınıfların, mühürlenmiş sınıfla birlikte aynı Kotlin dosyası içinde bildirilmesi gerekir. Aşağıdaki örnekte, mühürlenmiş bir sınıfın nasıl kullanılacağını göreceğiz.
sealed class MyExample {
class OP1 : MyExample() // MyExmaple class can be of two types only
class OP2 : MyExample()
}
fun main(args: Array<String>) {
val obj: MyExample = MyExample.OP2()
val output = when (obj) { // defining the object of the class depending on the inuputs
is MyExample.OP1 -> "Option One has been chosen"
is MyExample.OP2 -> "option Two has been chosen"
}
println(output)
}Yukarıdaki örnekte, yalnızca iki türde olabilen "MyExample" adında bir mühürlenmiş sınıfımız var - biri "OP1" ve diğeri "OP2". Ana sınıfta, sınıfımızda bir nesne oluşturuyoruz ve türünü çalışma zamanında atıyoruz. Şimdi, bu "MyExample" sınıfı mühürlendiğinden, son çıktıyı gerçekleştirmek için çalışma zamanında "when" cümlesini uygulayabiliriz.
Mühürlü sınıfta, kodu karmaşık hale getirmek için gereksiz "else" ifadesini kullanmamız gerekmez. Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
option Two has been chosenJava gibi, Kotlin de Generics olarak adlandırılan daha yüksek düzeyde değişken yazım sağlar. Bu bölümde, Kotlin'in Generics'i nasıl uyguladığını ve bir geliştirici olarak jenerik kitaplığında sağlanan bu işlevleri nasıl kullanabileceğimizi öğreneceğiz. Uygulama açısından jenerikler Java'ya oldukça benzer ancak Kotlin geliştiricisi iki yeni anahtar kelime tanıttı“out” ve “in” Kotlin kodlarını geliştirici için daha okunaklı ve kolay hale getirmek.
Kotlin'de bir sınıf ve bir tip tamamen farklı kavramlardır. Örneğe göre List, Kotlin'de bir sınıftır, List <String> ise Kotlin'de bir türdür. Aşağıdaki örnek, jeneriklerin Kotlin'de nasıl uygulandığını gösterir.
fun main(args: Array<String>) {
val integer: Int = 1
val number: Number = integer
print(number)
}Yukarıdaki kodda bir “tamsayı” tanımladık ve daha sonra bu değişkeni bir sayı değişkenine atadık. Bu, "Int" nin Number sınıfının bir alt sınıfı olması nedeniyle mümkündür, bu nedenle tür dönüşümü çalışma zamanında otomatik olarak gerçekleşir ve çıktıyı "1" olarak üretir.
Kotlin'de jenerikler hakkında daha fazla şey öğrenelim. Uygulamada kullanacağımız veri türünden emin olmadığımızda genel veri türüne gitmek daha iyidir. Genel olarak, Kotlin'de jenerikler şu şekilde tanımlanır:<T>"T", Kotlin complier tarafından dinamik olarak belirlenebilen şablon anlamına gelir. Aşağıdaki örnekte, Kotlin programlama dilinde jenerik veri türlerinin nasıl kullanılacağını göreceğiz.
fun main(args: Array<String>) {
var objet = genericsExample<String>("JAVA")
var objet1 = genericsExample<Int>(10)
}
class genericsExample<T>(input:T) {
init {
println("I am getting called with the value "+input)
}
}Yukarıdaki kod parçasında, aşağıdaki gibi temsil edilen genel dönüş tipine sahip bir sınıf oluşturuyoruz. <T>. Bu sınıfın nesnesini oluştururken, değer türünü kanıtlayarak çalıştırmada değerini dinamik olarak tanımladığımız ana yönteme bir göz atın. Kotlin derleyicisi tarafından jenerikler bu şekilde yorumlanır. Bu kodu kodlama alanımızda çalıştırdığımızda, tarayıcıda aşağıdaki çıktıyı alacağız.
I am getting called with the value JAVA
I am getting called with the value 10Jenerik türü herhangi bir süper türüne atamak istediğimizde, "out" anahtar kelimesini kullanmalıyız ve genel türü herhangi bir alt türüne atamak istediğimizde "in" kullanmalıyız. anahtar kelime. Aşağıdaki örnekte, "out" anahtar kelimesini kullanacağız. Benzer şekilde, "in" anahtar kelimesini kullanmayı deneyebilirsiniz.
fun main(args: Array<String>) {
var objet1 = genericsExample<Int>(10)
var object2 = genericsExample<Double>(10.00)
println(objet1)
println(object2)
}
class genericsExample<out T>(input:T) {
init {
println("I am getting called with the value "+input)
}
}Yukarıdaki kod, tarayıcıda aşağıdaki çıktıyı verecektir.
I am getting called with the value 10
I am getting called with the value 10.0
genericsExample@28d93b30
genericsExample@1b6d3586Kotlin destekler “delegation” yeni bir anahtar kelime ekleyerek tasarım şablonu “by”. Bu anahtar sözcüğü veya yetkilendirme metodolojisini kullanan Kotlin, türetilmiş sınıfın belirli bir nesne aracılığıyla bir arayüzün uygulanan tüm genel yöntemlerine erişmesine izin verir. Aşağıdaki örnek, bunun Kotlin'de nasıl olduğunu göstermektedir.
interface Base {
fun printMe() //abstract method
}
class BaseImpl(val x: Int) : Base {
override fun printMe() { println(x) } //implementation of the method
}
class Derived(b: Base) : Base by b // delegating the public method on the object b
fun main(args: Array<String>) {
val b = BaseImpl(10)
Derived(b).printMe() // prints 10 :: accessing the printMe() method
}Örnekte, "printme ()" adlı soyut yöntemi olan bir "Base" arayüzüne sahibiz. BaseImpl sınıfında, bu “printme ()” yi uyguluyoruz ve daha sonra başka bir sınıftan bu uygulamayı “by” anahtar sözcüğünü kullanarak kullanıyoruz.
Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
10Mülkiyet Delegasyonu
Önceki bölümde, "by" anahtar sözcüğünü kullanarak delegasyon tasarım modelini öğrendik. Bu bölümde, Kotlin kütüphanesinde bahsedilen bazı standart yöntemleri kullanarak mülklerin yetkilendirilmesi hakkında bilgi edineceğiz.
Yetki, sorumluluğu başka bir sınıfa veya yönteme devretmek anlamına gelir. Bir özellik zaten bazı yerlerde beyan edildiğinde, onları başlatmak için aynı kodu yeniden kullanmalıyız. Aşağıdaki örneklerde, örneklerimizde yetkilendirmeyi uygularken Kotlin tarafından sağlanan bazı standart yetkilendirme metodolojisini ve bazı standart kütüphane işlevlerini kullanacağız.
Tembel () kullanma
Lazy, bir özelliği girdi olarak alan ve karşılığında bir örnek veren bir lambda işlevidir. Lazy<T><T> temelde kullandığı özelliklerin türüdür. Nasıl çalıştığını anlamak için aşağıdakilere bir göz atalım.
val myVar: String by lazy {
"Hello"
}
fun main(args: Array<String>) {
println(myVar +" My dear friend")
}Yukarıdaki kod parçasında, Lazy işlevine bir "myVar" değişkeni geçiriyoruz, bu da değeri nesnesine atar ve aynısını ana işleve döndürür. Tarayıcıdaki çıktı aşağıdadır.
Hello My dear friendDelegetion.Observable ()
Observable (), nesneyi başlatmak için iki argüman alır ve aynısını çağrılan işleve döndürür. Aşağıdaki örnekte, delegasyonu uygulamak için Observable () yönteminin nasıl kullanılacağını göreceğiz.
import kotlin.properties.Delegates
class User {
var name: String by Delegates.observable("Welcome to Tutorialspoint.com") {
prop, old, new ->
println("$old -> $new")
}
}
fun main(args: Array<String>) {
val user = User()
user.name = "first"
user.name = "second"
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
first -> secondGenel olarak sözdizimi, "by" anahtar sözcüğü yetkilendirildikten sonraki ifadedir. get() ve set() değişkenin yöntemleri p onun için delege edilecek getValue() ve setValue() Delegate sınıfında tanımlanan yöntemler.
class Example {
var p: String by Delegate()
}Yukarıdaki kod parçası için, değişkendeki değeri atamak için üretmemiz gereken delege sınıfı aşağıdadır. p.
class Delegate {
operator fun getValue(thisRef: Any?, property: KProperty<*>): String {
return "$thisRef, thank you for delegating '${property.name}' to me!"
}
operator fun setValue(thisRef: Any?, property: KProperty<*>, value: String) {
println("$value has been assigned to '${property.name} in $thisRef.'")
}
}Okurken getValue () yöntemi çağrılacak ve değişken ayarlanırken setValue () yöntemi çağrılacaktır.
Kotlin statik olarak yazılmış bir dildir, bu nedenle işlevler bunda büyük rol oynar. Örnekler boyunca işlevi kullandığımız için işleve oldukça aşinayız. İşlev, "eğlence" anahtar sözcüğü ile bildirilir. Diğer tüm OOP'ler gibi, bir dönüş türüne ve bir seçenek argüman listesine de ihtiyaç duyar.
Aşağıdaki örnekte, MyFunction adında bir işlev tanımlıyoruz ve ana işlevden bu işlevi çağırıp bir argüman iletiyoruz.
fun main(args: Array<String>) {
println(MyFunction("tutorialsPoint.com"))
}
fun MyFunction(x: String): String {
var c:String = "Hey!! Welcome To ---"
return (c+x)
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
Hey!! Welcome To ---tutorialsPoint.comİşlev aşağıdaki gibi bildirilmelidir -
fun <nameOfFunction>(<argument>:<argumentType>):<ReturnType>Aşağıda, Kotlin'de bulunan farklı işlev türlerinden bazıları verilmiştir.
Lambda İşlevi
Lambda, bir işlevi bildirirken ve aynı şeyi tanımlarken kazan plaka kodunu büyük ölçüde azaltan yüksek seviyeli bir işlevdir. Kotlin, kendi lambda'nızı tanımlamanıza izin verir. Kotlin'de, lambda'nızı bildirebilir ve bu lambda'yı bir işleve geçirebilirsiniz.
Aşağıdaki örneğe bir göz atın.
fun main(args: Array<String>) {
val mylambda :(String)->Unit = {s:String->print(s)}
val v:String = "TutorialsPoint.com"
mylambda(v)
}Yukarıdaki kodda, "mylambda" olarak bilinen kendi lambda'mızı oluşturduk ve bu lambda'ya String türünde ve "TutorialsPoint.com" değerini içeren bir değişken geçirdik.
Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
TutorialsPoint.comSatır İçi İşlev
Yukarıdaki örnek, Kotlin uygulamasında kullanabileceğimiz temel lambda ifadesini göstermektedir. Şimdi, çağıran işlevi bir satır içi işlev yapan çıktımızı elde etmek için başka bir işleve bir lambda geçirebiliriz.
Aşağıdaki örneğe bir göz atın.
fun main(args: Array<String>) {
val mylambda:(String)->Unit = {s:String->print(s)}
val v:String = "TutorialsPoint.com"
myFun(v,mylambda) //passing lambda as a parameter of another function
}
fun myFun(a :String, action: (String)->Unit) { //passing lambda
print("Heyyy!!!")
action(a)// call to lambda function
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir. Satır içi işlevi kullanarak, parametre olarak bir lambda geçirdik. Diğer herhangi bir işlev, "satır içi" anahtar sözcüğü kullanılarak bir satır içi işlev yapılabilir.
Heyyy!!!TutorialsPoint.comKotlin, diğer programlama dillerinin birçok özelliğini içerir. Aynı anda birden fazla değişkeni tanımlamanıza izin verir. Bu tekniğe Yıkım beyanı denir.
Yıkıcı bildiriminin temel sözdizimi aşağıdadır.
val (name, age) = personYukarıdaki sözdiziminde, bir nesne oluşturduk ve hepsini tek bir ifadede birlikte tanımladık. Daha sonra bunları aşağıdaki gibi kullanabiliriz.
println(name)
println(age)Şimdi, aynısını gerçek hayattaki uygulamamızda nasıl kullanabileceğimize bakalım. Bazı niteliklere sahip bir Öğrenci sınıfı oluşturduğumuz ve daha sonra bunları nesne değerlerini yazdırmak için kullanacağımız aşağıdaki örneği düşünün.
fun main(args: Array<String>) {
val s = Student("TutorialsPoint.com","Kotlin")
val (name,subject) = s
println("You are learning "+subject+" from "+name)
}
data class Student( val a :String,val b: String ){
var name:String = a
var subject:String = b
}Yukarıdaki kod parçası tarayıcıda aşağıdaki çıktıyı verecektir.
You are learning Kotlin from TutorialsPoint.comİstisna işleme, bir programlama dilinin çok önemli bir parçasıdır. Bu teknik, uygulamamızın çalışma zamanında yanlış çıktı üretmesini kısıtlar. Bu bölümde, Kotlin'de çalışma zamanı istisnasının nasıl ele alınacağını öğreneceğiz. Kotlin'deki istisnalar, Java'daki istisnalara oldukça benzer. Tüm istisnalar, "Throwable" sınıfının torunlarıdır. Aşağıdaki örnek, Kotlin'de istisna işleme tekniğinin nasıl kullanılacağını göstermektedir.
fun main(args: Array<String>) {
try {
val myVar:Int = 12;
val v:String = "Tutorialspoint.com";
v.toInt();
} catch(e:Exception) {
e.printStackTrace();
} finally {
println("Exception Handeling in Kotlin");
}
}Yukarıdaki kod parçasında, bir String bildirdik ve daha sonra bu dizeyi tam sayıya bağladık, bu aslında bir çalışma zamanı istisnasıdır. Dolayısıyla, tarayıcıda aşağıdaki çıktıyı alacağız.
val myVar:Int = 12;
Exception Handeling in KotlinNote - Java gibi, Kotlin de catch bloğunu yürüttükten sonra final bloğunu yürütür.