Kotlin Bootcamp for Programmers 6: Functional manipulation

Bu codelab, Kotlin Bootcamp for Programmers kursunun bir parçasıdır. Bu kurstan en iyi şekilde yararlanmak için codelab'leri sırayla tamamlamanızı öneririz. Bilgi düzeyinize bağlı olarak bazı bölümleri gözden geçirebilirsiniz. Bu kurs, nesne yönelimli bir dil bilen ve Kotlin'i öğrenmek isteyen programcılara yöneliktir.

Giriş

Bu, Kotlin Temel Eğitim Programı'ndaki son codelab'dir. Bu codelab'de ek açıklamalar ve etiketli aralar hakkında bilgi edineceksiniz. Kotlin'in temel parçaları olan lambda ifadelerini ve yüksek sıralı işlevleri incelersiniz. Ayrıca satır içi işlevler ve Tek Soyut Yöntem (SAM) arayüzleri hakkında daha fazla bilgi edinebilirsiniz. Son olarak, Kotlin Standart Kitaplığı hakkında daha fazla bilgi edineceksiniz.

Bu kurstaki dersler, tek bir örnek uygulama oluşturmak yerine bilginizi artırmak için tasarlanmıştır ancak birbirlerinden yarı bağımsız oldukları için aşina olduğunuz bölümleri gözden geçirebilirsiniz. Örneklerin çoğu, bunları bir araya getirmek için akvaryum temasını kullanır. Akvaryumun hikayesinin tamamını görmek isterseniz Kotlin Bootcamp for Programmers (Programcılar için Kotlin Temel Eğitim Programı) adlı Udacity kursuna göz atın.

Bilmeniz gerekenler

  • Kotlin işlevlerinin, sınıflarının ve yöntemlerinin söz dizimi
  • IntelliJ IDEA'da yeni bir sınıf oluşturma ve program çalıştırma
  • Lambda'lar ve yüksek sıralı işlevlerle ilgili temel bilgiler

Neler öğreneceksiniz?

  • Notlarla ilgili temel bilgiler
  • Etiketli mola nasıl kullanılır?
  • Yüksek sıralı işlevler hakkında daha fazla bilgi
  • Tek Soyut Yöntem (SAM) arayüzleri hakkında
  • Kotlin Standart Kitaplığı hakkında

Yapacaklarınız

  • Basit bir ek açıklama oluşturun.
  • Etiketli bir sayfa/sütun sonu kullanın.
  • Kotlin'deki lambda işlevlerini inceleyin.
  • Yüksek sıralı işlevleri kullanma ve oluşturma
  • Bazı Tek Soyut Yöntem arayüzlerini çağırın.
  • Kotlin Standart Kitaplığı'ndaki bazı işlevleri kullanma

Açıklamalar, koda meta veri eklemenin bir yoludur ve Kotlin'e özgü değildir. Açıklamalar derleyici tarafından okunur ve kod veya mantık oluşturmak için kullanılır. Ktor ve Kotlinx gibi birçok çerçeve ile Room, nasıl çalışacaklarını ve kodunuzla nasıl etkileşim kuracaklarını yapılandırmak için ek açıklamaları kullanır. Çerçeveleri kullanmaya başlayana kadar herhangi bir ek açıklamayla karşılaşmanız olası değildir ancak ek açıklamaları nasıl okuyacağınızı bilmek faydalıdır.

Ayrıca, Kotlin standart kitaplığı aracılığıyla kullanılabilen ve kodun derlenme şeklini kontrol eden ek açıklamalar da vardır. Kotlin'i Java koduna aktarıyorsanız bu türler çok kullanışlıdır ancak aksi takdirde bu türlere pek ihtiyacınız olmaz.

Açıklamalar, açıklama eklenen öğenin hemen öncesine yerleştirilir ve çoğu öğeye (sınıflar, işlevler, yöntemler ve hatta kontrol yapıları) açıklama eklenebilir. Bazı ek açıklamalar bağımsız değişken alabilir.

Aşağıda bazı ek açıklamaların örneği verilmiştir.

@file:JvmName("InteropFish")
class InteropFish {
   companion object {
       @JvmStatic fun interop()
   }
}

Bu örnekte, dosyanın dışa aktarılan adının InteropFish olduğu ve JvmName notunun kullanıldığı belirtiliyor. JvmName notu, "InteropFish" bağımsız değişkenini alıyor. Companion nesnesinde @JvmStatic, Kotlin'e interop() işlevini InteropFish içinde statik bir işlev haline getirmesini söyler.

Kendi ek açıklamalarınızı da oluşturabilirsiniz ancak bu özellik en çok çalışma zamanında sınıflarla ilgili belirli bilgilere ihtiyaç duyan bir kitaplık (ör. yansıtma) yazıyorsanız kullanışlıdır.

1. adım: Yeni bir paket ve dosya oluşturun

  1. src altında yeni bir paket oluşturun, example.
  2. Örnek'te Annotations.kt adlı yeni bir Kotlin dosyası oluşturun.

2. adım: Kendi ek açıklamanızı oluşturun

  1. Annotations.kt içinde trim() ve fertilize() olmak üzere iki yöntemle Plant sınıfı oluşturun.
class Plant {
        fun trim(){}
        fun fertilize(){}
}
  1. Bir sınıftaki tüm yöntemleri yazdıran bir işlev oluşturun. Çalışma zamanında bir sınıf hakkında bilgi edinmek için ::class kullanın. Bir sınıfın yöntemlerinin listesini almak için declaredMemberFunctions kullanın. (Buna erişmek için kotlin.reflect.full.* içe aktarmanız gerekir)
import kotlin.reflect.full.*    // required import

class Plant {
    fun trim(){}
    fun fertilize(){}
}

fun testAnnotations() {
    val classObj = Plant::class
    for (m in classObj.declaredMemberFunctions) {
        println(m.name)
    }
}
  1. Test rutininizi çağırmak için bir main() işlevi oluşturun. Programınızı çalıştırın ve çıktıyı inceleyin.
fun main() {
    testAnnotations()
}
 
⇒ trim
fertilize
  1. Basit bir not oluşturun, ImAPlant.
annotation class ImAPlant

Bu işlem, yalnızca açıklama eklendiğini belirtir.

  1. Plant sınıfınızın önüne ek açıklamayı ekleyin.
@ImAPlant class Plant{
    ...
}
  1. Bir sınıftaki tüm ek açıklamaları yazdırmak için testAnnotations() simgesini değiştirin. Bir sınıfa ait tüm ek açıklamaları almak için annotations uygulamasını kullanın. Programınızı çalıştırın ve sonucu gözlemleyin.
fun testAnnotations() {
    val plantObject = Plant::class
    for (a in plantObject.annotations) {
        println(a.annotationClass.simpleName)
    }
}
 
⇒ ImAPlant
  1. ImAPlant ek açıklamasını bulmak için testAnnotations() değerini değiştirin. Belirli bir açıklamayı bulmak için findAnnotation() simgesini kullanın. Programınızı çalıştırın ve sonucu gözlemleyin.
fun testAnnotations() {
    val plantObject = Plant::class
    val myAnnotationObject = plantObject.findAnnotation<ImAPlant>()
    println(myAnnotationObject)
}

⇒ @example.ImAPlant()

3. adım: Hedefli bir not oluşturun

Açıklamalar, alıcıları veya ayarlayıcıları hedefleyebilir. Bu durumda, @get: veya @set: önekini kullanarak bunları uygulayabilirsiniz. Bu durum, ek açıklamalar içeren çerçeveler kullanılırken sıkça görülür.

  1. Yalnızca özellik getter'larına uygulanabilen OnGet ve yalnızca özellik setter'larına uygulanabilen OnSet olmak üzere iki ek açıklama bildirin. Her birinde @Target(AnnotationTarger.PROPERTY_GETTER) veya PROPERTY_SETTER kullanın.
annotation class ImAPlant

@Target(AnnotationTarget.PROPERTY_GETTER)
annotation class OnGet
@Target(AnnotationTarget.PROPERTY_SETTER)
annotation class OnSet

@ImAPlant class Plant {
    @get:OnGet
    val isGrowing: Boolean = true

    @set:OnSet
    var needsFood: Boolean = false
}

Açıklamalar, hem çalışma zamanında hem de bazen derleme zamanında öğeleri inceleyen kitaplıklar oluşturmak için gerçekten çok güçlüdür. Ancak normal uygulama kodu yalnızca çerçeveler tarafından sağlanan ek açıklamaları kullanır.

Kotlin'de akışı kontrol etmenin çeşitli yolları vardır. Bir işlevden onu içeren işleve dönen return ile zaten tanışmıştınız. break kullanmak, return kullanmaya benzer ancak döngüler için geçerlidir.

Kotlin, etiketli kesme adı verilen bir özellik sayesinde döngüler üzerinde daha fazla kontrol sahibi olmanızı sağlar. Bir etiketle nitelendirilen break, bu etiketle işaretlenen döngüden hemen sonraki yürütme noktasına atlar. Bu, özellikle iç içe geçmiş döngülerle çalışırken yararlıdır.

Kotlin'deki tüm ifadeler etiketle işaretlenebilir. Etiketler, tanımlayıcı biçiminde olup ardından @ işareti gelir.

  1. Annotations.kt içinde, iç döngüden çıkıp etiketli bir kesme denemesi yapın.
fun labels() {
    outerLoop@ for (i in 1..100) {
         print("$i ")
         for (j in 1..100) {
             if (i > 10) break@outerLoop  // breaks to outer loop
        }
    }
}

fun main() {
    labels()
}
  1. Programınızı çalıştırın ve çıktıyı inceleyin.
⇒ 1 2 3 4 5 6 7 8 9 10 11

Benzer şekilde, etiketli bir continue da kullanabilirsiniz. Etiketli döngüden çıkmak yerine, etiketli devam işlemi döngünün bir sonraki yinelemesine geçer.

Lambda'lar, adı olmayan işlevler olan anonim işlevlerdir. Bunları değişkenlere atayabilir ve işlevlere ve yöntemlere bağımsız değişken olarak iletebilirsiniz. Bu türler son derece faydalıdır.

1. adım: Basit bir lambda oluşturun

  1. IntelliJ IDEA'da REPL'yi başlatın: Tools > Kotlin > Kotlin REPL.
  2. dirty: Int bağımsız değişkeniyle bir lambda oluşturun. Bu lambda, dirty değerini 2'ye bölerek hesaplama yapar. Lambda'yı bir değişkene atayın, waterFilter.
val waterFilter = { dirty: Int -> dirty / 2 }
  1. 30 değerini ileterek waterFilter numaralı telefonu arayın.
waterFilter(30)
 
⇒ res0: kotlin.Int = 15

2. adım: Filtre lambda'sı oluşturun

  1. REPL'de kalmaya devam ederek bir özellik (name) içeren bir veri sınıfı (Fish) oluşturun.
data class Fish(val name: String)
  1. Flipper, Moby Dick ve Dory adlarında 3 Fish listele.
val myFish = listOf(Fish("Flipper"), Fish("Moby Dick"), Fish("Dory"))
  1. "i" harfini içeren adları kontrol etmek için filtre ekleyin.
myFish.filter { it.name.contains("i")}

⇒ res3: kotlin.collections.List<Line_1.Fish> = [Fish(name=Flipper), Fish(name=Moby Dick)]

Lambda ifadesinde it, geçerli liste öğesini ifade eder ve filtre, her liste öğesine sırayla uygulanır.

  1. Ayırıcı olarak ", " işaretini kullanarak sonuca joinString() uygulayın.
myFish.filter { it.name.contains("i")}.joinToString(", ") { it.name }

⇒ res4: kotlin.String = Flipper, Moby Dick

joinToString() işlevi, belirtilen dizeyle ayrılmış filtrelenmiş adları birleştirerek bir dize oluşturur. Bu işlev, Kotlin standart kitaplığına yerleştirilmiş birçok yararlı işlevden biridir.

Bir lambda veya başka bir işlevi, bir işlevin bağımsız değişkeni olarak iletmek, yüksek sıralı bir işlev oluşturur. Yukarıdaki filtre, bunun basit bir örneğidir. filter() bir işlevdir ve bu işlev için, listenin her öğesinin nasıl işleneceğini belirten bir lambda geçirirsiniz.

Uzantı lambda'ları ile yüksek sıralı işlevler yazmak, Kotlin dilinin en gelişmiş kısımlarından biridir. Bu tür istemleri yazmayı öğrenmek biraz zaman alsa da kullanımları oldukça kolaydır.

1. adım: Yeni bir sınıf oluşturun

  1. example paketinde Fish.kt adlı yeni bir Kotlin dosyası oluşturun.
  2. Fish.kt içinde, bir özelliği olan name ile bir veri sınıfı Fish oluşturun.
data class Fish (var name: String)
  1. İşlev oluşturma fishExamples(). fishExamples() içinde "splashy" adında bir balık oluşturun. Adı tamamen küçük harflerle yazın.
fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
}
  1. fishExamples() işlevini çağıran bir main() işlevi oluşturun.
fun main () {
    fishExamples()
}
  1. main() simgesinin solundaki yeşil üçgeni tıklayarak programınızı derleyip çalıştırın. Henüz çıkış yok.

2. adım: Yüksek sıralı bir işlev kullanın

with() işlevi, bir nesneye veya mülke bir veya daha fazla referans vermenizi daha kompakt bir şekilde sağlar. this kullanılıyor. with() aslında daha yüksek sıralı bir işlevdir ve lambda'da sağlanan nesneyle ne yapılacağını belirtirsiniz.

  1. with() tuşunu kullanarak fishExamples() içindeki balık adının ilk harfini büyük yazın. Kıvırcık parantezlerin içinde this, with()'ye iletilen nesneyi ifade eder. 
fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        this.capitalize()
    }
}
  1. Çıkış yok. Bu nedenle, çıkışın etrafına println() ekleyin. Ayrıca this örtülü olduğundan gerekli değildir ve kaldırılabilir.
fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    with (fish.name) {
        println(capitalize())
    }
}
 
⇒ Splashy

3. adım: Yüksek sıralı bir işlev oluşturun

Perde arkasında, with() daha yüksek sıralı bir işlevdir. Bunun nasıl çalıştığını görmek için with() öğesinin yalnızca dizeler için çalışan, büyük ölçüde basitleştirilmiş bir sürümünü oluşturabilirsiniz.

  1. Fish.kt içinde iki bağımsız değişken alan bir işlev myWith() tanımlayın. Bağımsız değişkenler, üzerinde işlem yapılacak nesne ve işlemi tanımlayan bir işlevdir. İşlevle birlikte kullanılan bağımsız değişken adının kuralı block'dır. Bu durumda, işlev hiçbir şey döndürmez. Bu durum Unit ile belirtilir.
fun myWith(name: String, block: String.() -> Unit) {}

myWith() içinde block() artık String'ın bir uzantı işlevi. Genişletilen sınıfa genellikle alıcı nesne denir. Bu durumda name, alıcı nesnedir.

  1. myWith() gövdesinde, iletilen işlevi (block()) alıcı nesneye (name) uygulayın.
fun myWith(name: String, block: String.() -> Unit) {
    name.block()
}
  1. fishExamples() içinde with() ifadesini myWith() ile değiştirin.
fun fishExamples() {
    val fish = Fish("splashy")  // all lowercase
    myWith (fish.name) {
        println(capitalize())
    }
}

fish.name, ad bağımsız değişkeni, println(capitalize()) ise blok işlevidir.

  1. Programı çalıştırın. Program, önceki gibi çalışır.
⇒ Splashy

4. adım: Diğer yerleşik uzantıları keşfedin

with() uzantı lambda'sı çok kullanışlıdır ve Kotlin Standart Kitaplığı'nın bir parçasıdır. İşinize yarayabilecek diğer bazı kısayollar: run(), apply() ve let().

run() işlevi, tüm türlerle çalışan bir uzantıdır. Bağımsız değişken olarak bir lambda alır ve lambda'nın yürütülmesinin sonucunu döndürür.

  1. fishExamples() bölgesinde, adı öğrenmek için fish numaralı telefonu run()'dan arayın.
fish.run {
   name
}

Bu yalnızca name özelliğini döndürür. Bunu bir değişkene atayabilir veya yazdırabilirsiniz. Bu örnekte mülke doğrudan erişebileceğiniz için bu ifade aslında yararlı değildir ancak run() daha karmaşık ifadeler için faydalı olabilir.

apply() işlevi, run() işlevine benzer ancak lambda'nın sonucu yerine uygulandığı değiştirilmiş nesneyi döndürür. Bu, yeni oluşturulan bir nesnede yöntem çağırmak için faydalı olabilir.

  1. fish öğesinin bir kopyasını oluşturun ve yeni kopyanın adını ayarlamak için apply() öğesini çağırın.
val fish2 = Fish(name = "splashy").apply {
     name = "sharky"
}
println(fish2.name)

⇒ sharky

let() işlevi apply() işlevine benzer ancak değişikliklerle birlikte nesnenin kopyasını döndürür. Bu, manipülasyonları birlikte zincirlemek için yararlı olabilir.

  1. let() işlevini kullanarak fish öğesinin adını alın, büyük harflerle yazın, başka bir dizeyi ekleyin, sonucun uzunluğunu alın, uzunluğa 31 ekleyin ve sonucu yazdırın.
println(fish.let { it.name.capitalize()}
.let{it + "fish"}
.let{it.length}
.let{it + 31})
 
⇒ 42

Bu örnekte, it ile belirtilen nesne türü sırasıyla Fish, String, tekrar String ve son olarak Int'dür.

  1. let() işlevini çağırdıktan sonra fish işlevini yazdırın. Değişmediğini görürsünüz.
println(fish.let { it.name.capitalize()}
    .let{it + "fish"}
    .let{it.length}
    .let{it + 31})
println(fish)
 
⇒ 42
Fish(name=splashy)

Lambda'lar ve yüksek sıralı işlevler gerçekten çok kullanışlıdır ancak bilmeniz gereken bir şey vardır: Lambda'lar nesnedir. Lambda ifadesi, Function arayüzünün bir örneğidir ve Function, Object'nin bir alt türüdür. Daha önce verilen myWith() örneğini inceleyelim.

myWith(fish.name) {
    capitalize()
}

Function arayüzünde, lambda ifadesini çağırmak için geçersiz kılınan bir invoke() yöntemi bulunur. Bu kod, uzun biçimde yazıldığında aşağıdaki gibi görünür.

// actually creates an object that looks like this
myWith(fish.name, object : Function1<String, Unit> {
    override fun invoke(name: String) {
        name.capitalize()
    }
})

Nesne oluşturma ve işlev çağırma çok fazla ek yük (yani bellek ve CPU süresi) gerektirmediğinden bu durum genellikle sorun oluşturmaz. Ancak her yerde kullandığınız myWith() gibi bir şeyi tanımlıyorsanız ek yük artabilir.

Kotlin, derleyiciye biraz daha fazla iş yükü ekleyerek çalışma zamanındaki ek yükü azaltmak için bu durumu işleme yöntemi olarak inline sağlar. (inline hakkında, daha önceki derste somutlaştırılmış türlerden bahsederken biraz bilgi edinmiştiniz.) Bir işlevi inline olarak işaretlemek, işlev her çağrıldığında derleyicinin kaynak kodu işlevi "satır içi" olacak şekilde dönüştüreceği anlamına gelir. Yani derleyici, kodu değiştirerek lambda'yı lambda içindeki talimatlarla değiştirir.

Yukarıdaki örnekte myWith(), inline ile işaretlenirse:

inline myWith(fish.name) {
    capitalize()
}

doğrudan aramaya dönüştürülür:

// with myWith() inline, this becomes
fish.name.capitalize()

Büyük işlevlerin satır içi olarak eklenmesinin kod boyutunuzu artırdığını unutmayın. Bu nedenle, bu özellik en iyi şekilde myWith() gibi birçok kez kullanılan basit işlevler için kullanılır. Daha önce öğrendiğiniz kitaplıklardaki uzantı işlevleri inline ile işaretlenir. Bu nedenle, ek nesnelerin oluşturulması konusunda endişelenmenize gerek yoktur.

Single Abstract Method (Tek Soyut Yöntem), yalnızca bir yöntemi olan bir arayüz anlamına gelir. Java programlama dilinde yazılmış API'ler kullanılırken çok yaygın oldukları için SAM kısaltmasıyla ifade edilirler. Örneğin, tek bir soyut yöntemi olan run()'ye sahip Runnable ve tek bir soyut yöntemi olan call()'ye sahip Callable, işlevsel arayüzlerdir.

Kotlin'de, SAM'leri parametre olarak alan işlevleri sürekli olarak çağırmanız gerekir. Aşağıdaki örneği deneyin.

  1. example klasöründe bir Java sınıfı (JavaRun) oluşturun ve aşağıdaki kodu dosyaya yapıştırın.
package example;

public class JavaRun {
    public static void runNow(Runnable runnable) {
        runnable.run();
    }
}

Kotlin, türün önüne object: ekleyerek bir arayüzü uygulayan bir nesne oluşturmanıza olanak tanır. Bu işlev, parametreleri SAM'lere iletmek için kullanışlıdır.

  1. Fish.kt'ya geri dönün. object: kullanarak Runnable oluşturan bir runExample() işlevi oluşturun. Nesne, "I'm a Runnable" yazdırarak run()'yi uygulamalıdır.
fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
}
  1. Oluşturduğunuz nesneyle JavaRun.runNow() işlevini çağırın.
fun runExample() {
    val runnable = object: Runnable {
        override fun run() {
            println("I'm a Runnable")
        }
    }
    JavaRun.runNow(runnable)
}
  1. main() konumundan runExample() adlı kişiyi arayın ve programı çalıştırın.
⇒ I'm a Runnable

Bir şeyi yazdırmak için çok fazla iş yapılması gerekiyor ancak SAM'in nasıl çalıştığına dair iyi bir örnek. Elbette Kotlin, bunu yapmanın daha basit bir yolunu sunar. Bu kodu çok daha kompakt hale getirmek için nesne yerine lambda kullanın.

  1. runExample içindeki mevcut kodu kaldırın, lambda ile runNow()'u çağıracak şekilde değiştirin ve programı çalıştırın.
fun runExample() {
    JavaRun.runNow({
        println("Passing a lambda as a Runnable")
    })
}

⇒ Passing a lambda as a Runnable
  1. Son parametre çağrısı söz dizimini kullanarak bunu daha da kısa hale getirebilir ve parantezleri kaldırabilirsiniz.
fun runExample() {
    JavaRun.runNow {
        println("Last parameter is a lambda as a Runnable")
    }
}
 
⇒ Last parameter is a lambda as a Runnable

Tek Soyut Yöntem (SAM) ile ilgili temel bilgiler bunlardır. Şu kalıbı kullanarak tek bir kod satırıyla SAM'yi başlatabilir, geçersiz kılabilir ve SAM'ye çağrı yapabilirsiniz:
Class.singleAbstractMethod { lambda_of_override }

Bu derste, Kotlin'in önemli parçaları olan lambda ifadeleri ve yüksek sıralı işlevler daha ayrıntılı bir şekilde ele alındı. Ayrıca notlar ve etiketlenmiş aralar hakkında bilgi edindiniz.

  • Derleyiciye iletilecek bilgileri belirtmek için ek açıklamaları kullanın. Örneğin:
    @file:JvmName("Foo")
  • Kodunuzun iç içe yerleştirilmiş döngülerin içinden çıkmasını sağlamak için etiketli kesmeler kullanın. Örneğin:
    if (i > 10) break@outerLoop // breaks to outerLoop label
  • Lambdalar, yüksek sıralı işlevlerle birlikte kullanıldığında çok güçlü olabilir.
  • Lambda'lar nesnedir. Nesne oluşturmayı önlemek için işlevi inline ile işaretleyebilirsiniz. Derleyici, lambda'nın içeriğini doğrudan koda yerleştirir.
  • inline işlevini dikkatli bir şekilde kullanın. Bu işlev, programınızın kaynak kullanımını azaltmaya yardımcı olabilir.
  • SAM (Single Abstract Method), yaygın bir kalıptır ve lambda ifadeleriyle daha basit hale getirilmiştir. Temel kalıp:
    Class.singleAbstractMethod { lamba_of_override }
  • Kotlin Standart Kitaplığı, birkaç SAM dahil olmak üzere çok sayıda faydalı işlev sunar. Bu nedenle, kitaplığın içeriğini öğrenin.

Kotlin'in kursta ele alınanlardan çok daha fazlası var ancak artık kendi Kotlin programlarınızı geliştirmeye başlamak için gereken temel bilgilere sahipsiniz. Bu etkileyici dilin sizi heyecanlandırdığını ve daha az kod yazarak daha fazla işlevsellik oluşturmayı dört gözle beklediğinizi umuyoruz (özellikle Java programlama dilinden geliyorsanız). Kotlin'de uzmanlaşmanın en iyi yolu pratik yapmak ve öğrenmektir. Bu nedenle, Kotlin'i kendi kendinize keşfetmeye ve öğrenmeye devam edin.

Kotlin belgeleri

Bu kurstaki herhangi bir konu hakkında daha fazla bilgi edinmek veya takıldığınız noktaları aşmak için https://kotlinlang.org adresini ziyaret edebilirsiniz.

Kotlin eğitimleri

https://try.kotlinlang.org web sitesinde Kotlin Koans adlı zengin eğitimler, web tabanlı bir yorumlayıcı ve örneklerle birlikte eksiksiz bir referans dokümanı seti yer alır.

Udacity kursu

Bu konuyla ilgili Udacity kursunu görüntülemek için Kotlin Bootcamp for Programmers'a (Programcılar için Kotlin Temel Eğitimi) göz atın.

IntelliJ IDEA

IntelliJ IDEA ile ilgili dokümanları JetBrains web sitesinde bulabilirsiniz.

Kotlin Standart Kitaplığı

Kotlin Standart Kitaplığı, çok sayıda faydalı işlev sunar. Kendi işlevinizi veya arayüzünüzü yazmadan önce, birinin size yardımcı olup olmadığını görmek için her zaman Standart Kitaplığı kontrol edin. Yeni işlevler sık sık eklendiği için bu sayfayı zaman zaman kontrol edin.

Kotlin eğitimleri

https://try.kotlinlang.org web sitesinde Kotlin Koans adlı zengin eğitimler, web tabanlı bir yorumlayıcı ve örneklerle birlikte eksiksiz bir referans dokümanı seti yer alır.

Udacity kursu

Bu konuyla ilgili Udacity kursunu görüntülemek için Kotlin Bootcamp for Programmers'a (Programcılar için Kotlin Temel Eğitimi) göz atın.

IntelliJ IDEA

IntelliJ IDEA ile ilgili dokümanları JetBrains web sitesinde bulabilirsiniz.

Bu bölümde, bir eğitmenin yönettiği kurs kapsamında bu codelab'i tamamlayan öğrenciler için olası ödevler listelenmektedir. Eğitmen, aşağıdakileri yapmalıdır:

  • Gerekirse ödev atayın.
  • Öğrencilere ev ödevi ödevlerini nasıl göndereceklerini bildirin.
  • Ödevlere not verin.

Eğitmenler bu önerileri istedikleri kadar kullanabilir ve uygun olduğunu düşündükleri diğer ödevleri verebilirler.

Bu codelab'i kendi başınıza tamamlıyorsanız bilginizi test etmek için bu ödevleri kullanabilirsiniz.

Bu soruları yanıtlayın

1. Soru

Kotlin'de SAM şu anlama gelir:

▢ Güvenli Bağımsız Değişken Eşleştirme

▢ Basit Erişim Yöntemi

▢ Tek Soyut Yöntem (Single Abstract Method)

▢ Stratejik Erişim Metodolojisi

2. Soru

Aşağıdakilerden hangisi Kotlin Standart Kitaplığı uzantı işlevi değildir?

▢ elvis()

▢ apply()

▢ run()

▢ with()

3. Soru

Aşağıdakilerden hangisi Kotlin'deki lambda ifadeleri için doğru değildir?

▢ Lambda'lar anonim işlevlerdir.

▢ Satır içi olmayan lambda'lar nesnedir.

▢ Lambdalar kaynak yoğun olduğundan kullanılmamalıdır.

▢ Lambda'lar diğer işlevlere aktarılabilir.

4. Soru

Kotlin'deki etiketler, ardından aşağıdaki işaretlerin geldiği bir tanımlayıcıyla belirtilir:

▢ :

▢ ::

▢ @:

▢ @

Tebrikler! Programcılar için Kotlin Temel Eğitim Programı codelab'ini tamamlamış olmanız gerekir.

Diğer codelab'lerin bağlantıları da dahil olmak üzere kursa genel bir bakış için "Kotlin Bootcamp for Programmers: Welcome to the course." başlıklı makaleyi inceleyin.