{"id":35017,"date":"2025-11-24T22:31:15","date_gmt":"2025-11-24T19:31:15","guid":{"rendered":"https:\/\/fatihsoysal.com\/blog\/kotlin-lambdalari-fonksiyonel-programlamanin-guclu-araci\/"},"modified":"2025-11-24T22:31:15","modified_gmt":"2025-11-24T19:31:15","slug":"kotlin-lambdalari-fonksiyonel-programlamanin-guclu-araci","status":"publish","type":"post","link":"https:\/\/fatihsoysal.com\/blog\/kotlin-lambdalari-fonksiyonel-programlamanin-guclu-araci\/","title":{"rendered":"Kotlin Lambdalar\u0131: Fonksiyonel Programlaman\u0131n G\u00fc\u00e7l\u00fc Arac\u0131"},"content":{"rendered":"

Kotlin lambdalar\u0131, modern Android ve backend geli\u015ftirmenin vazge\u00e7ilmez bir par\u00e7as\u0131d\u0131r. Bu kapsaml\u0131 rehberde, lambdalar\u0131n temellerini \u00f6\u011frenin, ileri d\u00fczey kullan\u0131mlar\u0131n\u0131 ke\u015ffedin ve kodunuzu daha temiz, daha k\u0131sa ve daha ifade edici hale getirerek optimize edin.<\/p>\n

Yaz\u0131l\u0131m geli\u015ftirme d\u00fcnyas\u0131nda, kodun sadece \u00e7al\u0131\u015fmas\u0131 yeterli de\u011fildir; ayn\u0131 zamanda okunabilir, s\u00fcrd\u00fcr\u00fclebilir ve verimli olmas\u0131 gerekir. Genellikle kar\u015f\u0131la\u015ft\u0131\u011f\u0131m\u0131z en b\u00fcy\u00fck zorluklardan biri, belirli bir i\u015flevi yerine getirmek i\u00e7in tekrar eden kod bloklar\u0131 yazmak veya karma\u015f\u0131k geri \u00e7a\u011f\u0131rma (callback) mekanizmalar\u0131 kullanmakt\u0131r. Bu durum, \u00f6zellikle asynchronous programlama veya olay tabanl\u0131 sistemlerde kodun i\u00e7 i\u00e7e ge\u00e7mesine ve anla\u015f\u0131lmas\u0131 zor “callback hell” senaryolar\u0131na yol a\u00e7abilir. \u0130\u015fte tam da bu noktada lambdalar ve fonksiyonel programlama, Kotlin geli\u015ftiricileri i\u00e7in bir kurtar\u0131c\u0131 olarak sahneye \u00e7\u0131k\u0131yor. Lambdalar, kodunuzu daha conciseness (k\u0131sa ve \u00f6z), daha deklaratif (ne yapt\u0131\u011f\u0131n\u0131 do\u011frudan s\u00f6yleyen) ve daha g\u00fc\u00e7l\u00fc hale getirmenize olanak tan\u0131r. Peki, bu sihirli yap\u0131lar tam olarak nedir ve neden bu kadar pop\u00fclerdir?<\/p>\n

Fonksiyonel programlama paradigmas\u0131, programlar\u0131n durum (state) de\u011fi\u015fikliklerinden ve mutable (de\u011fi\u015ftirilebilir) verilerden ziyade, saf fonksiyonlar ve de\u011fi\u015fmez (immutable) veriler \u00fczerine in\u015fa edilmesini savunur. Kotlin, object-oriented (nesneye y\u00f6nelik) bir dil olmas\u0131na ra\u011fmen, fonksiyonel programlama \u00f6zelliklerini m\u00fckemmel bir \u015fekilde harmanlar. Lambdalar, bu harmanlaman\u0131n kalbinde yer al\u0131r. Esas\u0131nda, lambda ifadeleri “isimsiz fonksiyonlar” olarak d\u00fc\u015f\u00fcn\u00fclebilir. Bunlar, herhangi bir belirli isme sahip olmayan, do\u011frudan tan\u0131mlan\u0131p bir de\u011fi\u015fkene atanabilen veya ba\u015fka bir fonksiyona arg\u00fcman olarak ge\u00e7irilebilen kod bloklar\u0131d\u0131r. Bu yetenek, lambdalar\u0131n Kotlin’de “ilk s\u0131n\u0131f vatanda\u015f” (first-class citizen) olmas\u0131n\u0131 sa\u011flar; yani fonksiyonlar\u0131 de\u011fi\u015fkenler gibi i\u015fleyebiliriz, onlar\u0131 geri d\u00f6nd\u00fcrebiliriz veya ba\u015fka fonksiyonlara aktarabiliriz.<\/p>\n

Bu yetenek bizi “y\u00fcksek mertebeden fonksiyonlar” (higher-order functions) kavram\u0131na g\u00f6t\u00fcr\u00fcr. Y\u00fcksek mertebeden fonksiyonlar, bir veya daha fazla fonksiyonu arg\u00fcman olarak alan ya da bir fonksiyon d\u00f6nd\u00fcren fonksiyonlard\u0131r. Kotlin’deki filter<\/code>, map<\/code>, forEach<\/code> gibi standart k\u00fct\u00fcphane fonksiyonlar\u0131n\u0131n \u00e7o\u011fu, asl\u0131nda y\u00fcksek mertebeden fonksiyonlard\u0131r ve i\u00e7lerinde lambdalar\u0131 arg\u00fcman olarak kabul ederler. \u00d6rne\u011fin, bir liste \u00fczerinde belirli bir ko\u015fula g\u00f6re filtreleme yapmak istedi\u011finizde, ko\u015fulu bir lambda olarak filter<\/code> fonksiyonuna verebilirsiniz. Bu, d\u00f6ng\u00fcleri manuel olarak yazmaktan \u00e7ok daha okunakl\u0131 ve s\u00fcrd\u00fcr\u00fclebilirdir. Kotlin’in lambdalarla sa\u011flad\u0131\u011f\u0131 bu esneklik, geli\u015ftiricilere daha az boilerplate (basmakal\u0131p) kod yazma ve daha \u00e7ok i\u015f mant\u0131\u011f\u0131na odaklanma imkan\u0131 sunar. Ayr\u0131ca, bu sayede kodunuz daha mod\u00fcler hale gelir, \u00e7\u00fcnk\u00fc k\u00fc\u00e7\u00fck, ba\u011f\u0131ms\u0131z i\u015flev birimleri kolayca bir araya getirilebilir veya yeniden kullan\u0131labilir. Lambdalar, ayn\u0131 zamanda asenkron i\u015flemlerde de s\u0131k\u00e7a kullan\u0131l\u0131r; \u00f6rne\u011fin, bir arka plan g\u00f6revi bitti\u011finde \u00e7al\u0131\u015facak kodu tan\u0131mlamak i\u00e7in bir callback lambda g\u00f6nderebilirsiniz. Bu temel kavramlar, Kotlin’de lambdalar\u0131n g\u00fcc\u00fcn\u00fc anlamak i\u00e7in bir ba\u015flang\u0131\u00e7 noktas\u0131d\u0131r ve kodunuzu bir sonraki seviyeye ta\u015f\u0131man\u0131z i\u00e7in size kap\u0131lar\u0131 aralar.<\/p>\n

\u0130lk Ad\u0131mlar: Basit Bir Lambda Nas\u0131l Tan\u0131mlan\u0131r ve Kullan\u0131l\u0131r?<\/h2>\n

Lambdalar\u0131n ne oldu\u011funu ve neden \u00f6nemli olduklar\u0131n\u0131 anlad\u0131ktan sonra, pratik uygulamalara ge\u00e7mek ve kendi lambdalar\u0131m\u0131z\u0131 yazmay\u0131 \u00f6\u011frenmek do\u011fal bir sonraki ad\u0131md\u0131r. Kotlin’de bir lambda ifadesi tan\u0131mlamak ve kullanmak olduk\u00e7a sezgiseldir ve dilin esnekli\u011fi sayesinde \u00e7e\u015fitli bi\u00e7imlerde yap\u0131labilir. En temel haliyle, bir lambda ifadesi k\u00fcme parantezleri {}<\/code> aras\u0131na yaz\u0131l\u0131r ve genellikle parametreleri, ard\u0131ndan bir ok -><\/code> ve sonras\u0131nda fonksiyon g\u00f6vdesini i\u00e7erir. Parametreler parantez i\u00e7ine al\u0131n\u0131r, ancak tek bir parametre oldu\u011funda veya parametre tip \u00e7\u0131kar\u0131m\u0131 yap\u0131labildi\u011finde bu parantezler genellikle atlanabilir. \u015eimdi, ad\u0131m ad\u0131m basit bir lambda’n\u0131n nas\u0131l tan\u0131mlan\u0131p kullan\u0131ld\u0131\u011f\u0131na bakal\u0131m.<\/p>\n

Tek Parametreli Lambdalar ve ‘it’ Anahtar Kelimesi<\/h3>\n

Kotlin’de, bir lambda yaln\u0131zca tek bir parametreye sahipse ve bu parametrenin t\u00fcr\u00fc derleyici taraf\u0131ndan \u00e7\u0131kar\u0131labiliyorsa, bu parametreyi explicit (a\u00e7\u0131k\u00e7a) belirtmek zorunda de\u011filsiniz. Bunun yerine, Kotlin otomatik olarak it<\/code> ad\u0131nda implicit (\u00f6rt\u00fck) bir ad sa\u011flar. Bu, kodu daha da k\u0131sa ve okunabilir hale getirir.<\/p>\n

\nval printMessage: (String) -> Unit = { message -> println(message) }\nprintMessage(\"Merhaba D\u00fcnya!\")\n<\/pre>\n
<\/code><\/p>\n
Yukar\u0131daki \u00f6rnekte, printMessage<\/code> bir String<\/code> al\u0131p Unit<\/code> (Kotlin'de void'e e\u015fde\u011fer) d\u00f6nd\u00fcren bir fonksiyondur. Parametre olarak message<\/code> belirtilmi\u015ftir. Ancak, it<\/code> kullanarak bu lambda'y\u0131 daha da k\u0131saltabiliriz:<\/p>\n
\nval printMessageWithIt: (String) -> Unit = { println(it) }\nprintMessageWithIt(\"Merhaba Kotlin!\")\n<\/pre>\n
<\/code><\/p>\n
G\u00f6rd\u00fc\u011f\u00fcn\u00fcz gibi, it<\/code> anahtar kelimesi tek parametreli lambdalarda kodun karma\u015f\u0131kl\u0131\u011f\u0131n\u0131 azaltmak i\u00e7in harika bir yoldur.<\/p>\n
Birden Fazla Parametreli Lambdalar<\/h3>\n
E\u011fer lambdan\u0131z birden fazla parametreye sahipse, it<\/code> anahtar kelimesini kullanamazs\u0131n\u0131z. Bu durumda, t\u00fcm parametreleri a\u00e7\u0131k\u00e7a belirtmeniz ve parantez i\u00e7ine alman\u0131z gerekir:<\/p>\n
\nval sum: (Int, Int) -> Int = { a, b -> a + b }\nprintln(\"Toplam: ${sum(5, 3)}\") \/\/ \u00c7\u0131kt\u0131: Toplam: 8\n<\/pre>\n
<\/code><\/p>\n
Burada sum<\/code> lambdas\u0131 iki Int<\/code> parametresi al\u0131r (a<\/code> ve b<\/code>) ve onlar\u0131n toplam\u0131n\u0131 bir Int<\/code> olarak d\u00f6nd\u00fcr\u00fcr. Parametre adlar\u0131n\u0131 a\u00e7\u0131k\u00e7a belirtti\u011fimizden, lambda'n\u0131n ne bekledi\u011fi daha net anla\u015f\u0131l\u0131r.<\/p>\n
D\u00f6n\u00fc\u015f Tipleri ve Blok G\u00f6vdeli Lambdalar<\/h3>\n
Lambdalar\u0131n d\u00f6n\u00fc\u015f tipleri genellikle otomatik olarak \u00e7\u0131kar\u0131l\u0131r, ancak bazen a\u00e7\u0131k\u00e7a belirtmek isteyebilirsiniz, \u00f6zellikle karma\u015f\u0131k mant\u0131k i\u00e7eren durumlarda. Bir lambda'n\u0131n son ifadesi, lambdan\u0131n d\u00f6n\u00fc\u015f de\u011feri olarak kabul edilir. E\u011fer lambdan\u0131z birden fazla sat\u0131rdan olu\u015fuyorsa, bu bir \"blok g\u00f6vdeli lambda\" olarak adland\u0131r\u0131l\u0131r.<\/p>\n
\nval calculateArea: (Int, Int) -> Int = { width, height ->\n    println(\"Geni\u015flik: $width, Y\u00fckseklik: $height\")\n    width * height \/\/ Son ifade d\u00f6n\u00fc\u015f de\u011feridir\n}\nprintln(\"Alan: ${calculateArea(10, 5)}\") \/\/ \u00c7\u0131kt\u0131: Alan: 50\n<\/pre>\n
<\/code><\/p>\n
Bu \u00f6rnekte, calculateArea<\/code> lambdas\u0131 iki sat\u0131rdan olu\u015fur. \u0130lk sat\u0131r bir \u00e7\u0131kt\u0131 \u00fcretirken, ikinci sat\u0131r (width * height<\/code>) lambdan\u0131n d\u00f6n\u00fc\u015f de\u011ferini belirler. Bu esneklik, lambdalar\u0131 sadece tek sat\u0131rl\u0131k ifadeler i\u00e7in de\u011fil, daha karma\u015f\u0131k i\u015f mant\u0131\u011f\u0131n\u0131 kapsayacak \u015fekilde de kullanabilece\u011fimiz anlam\u0131na gelir. Lambda ifadelerinin bu temel yap\u0131lar\u0131n\u0131 anlamak, Kotlin'deki fonksiyonel programlama becerilerinizi geli\u015ftirmenin ilk ve en \u00f6nemli ad\u0131m\u0131d\u0131r. Bu sayede, daha temiz, daha \u00f6zl\u00fc ve daha etkili kodlar yazmaya ba\u015flayabilirsiniz.<\/p>\n
Y\u00fcksek Mertebeden Fonksiyonlar ve Lambdalar\u0131n Dans\u0131: Kotlin'de G\u00fcc\u00fc Ke\u015ffedin<\/h2>\n
Kotlin'de lambdalar, tek ba\u015flar\u0131na g\u00fc\u00e7l\u00fc olsalar da, ger\u00e7ek potansiyellerini y\u00fcksek mertebeden fonksiyonlarla birle\u015ftiklerinde ortaya \u00e7\u0131kar\u0131rlar. Y\u00fcksek mertebeden fonksiyonlar, ad\u0131ndan da anla\u015f\u0131laca\u011f\u0131 gibi, ba\u015fka fonksiyonlar\u0131 arg\u00fcman olarak alabilen veya bir fonksiyon d\u00f6nd\u00fcrebilen fonksiyonlard\u0131r. Bu yetenek, kodun inan\u0131lmaz derecede esnek, mod\u00fcler ve yeniden kullan\u0131labilir olmas\u0131n\u0131 sa\u011flar. Kotlin Standart K\u00fct\u00fcphanesi, koleksiyonlar \u00fczerinde \u00e7al\u0131\u015fan ve lambdalar\u0131 yo\u011fun bir \u015fekilde kullanan zengin bir y\u00fcksek mertebeden fonksiyon setine sahiptir. Bu fonksiyonlar sayesinde, veri i\u015fleme, d\u00f6n\u00fc\u015f\u00fcm ve filtreleme gibi yayg\u0131n g\u00f6revleri \u00e7ok daha k\u0131sa ve okunabilir bir \u015fekilde ger\u00e7ekle\u015ftirebiliriz. \u015eimdi, en s\u0131k kullan\u0131lanlardan baz\u0131lar\u0131na ve lambdalarla nas\u0131l dans ettiklerine yak\u0131ndan bakal\u0131m.<\/p>\n
filter, map, forEach: Koleksiyon \u0130\u015flemlerinin Temel Ta\u015flar\u0131<\/h3>\n
Bu \u00fc\u00e7 fonksiyon, koleksiyonlarla \u00e7al\u0131\u015f\u0131rken en \u00e7ok ba\u015fvurulan y\u00fcksek mertebeden fonksiyonlardand\u0131r:<\/p>\n
    \n
  • filter<\/code>: Bir koleksiyondaki elemanlar\u0131 belirli bir ko\u015fula g\u00f6re filtrelemek i\u00e7in kullan\u0131l\u0131r. Ko\u015ful, bir lambda olarak filter<\/code> fonksiyonuna ge\u00e7irilir.<\/li>\n
  • map<\/code>: Bir koleksiyondaki her eleman\u0131 belirli bir d\u00f6n\u00fc\u015f\u00fcm i\u015fleminden ge\u00e7irerek yeni bir koleksiyon olu\u015fturur. D\u00f6n\u00fc\u015f\u00fcm mant\u0131\u011f\u0131, yine bir lambda ile sa\u011flan\u0131r.<\/li>\n
  • forEach<\/code>: Bir koleksiyondaki her eleman \u00fczerinde belirli bir i\u015flemi ger\u00e7ekle\u015ftirmek i\u00e7in kullan\u0131l\u0131r. Bu i\u015flem, genellikle bir yan etki (side effect) yarat\u0131r, \u00f6rne\u011fin eleman\u0131 yazd\u0131rmak gibi.<\/li>\n<\/ul>\n
    \nval sayilar = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n\n\/\/ Sadece \u00e7ift say\u0131lar\u0131 filtrele\nval ciftSayilar = sayilar.filter { it % 2 == 0 }\nprintln(\"\u00c7ift Say\u0131lar: $ciftSayilar\") \/\/ \u00c7\u0131kt\u0131: \u00c7ift Say\u0131lar: [2, 4, 6, 8, 10]\n\n\/\/ Her say\u0131n\u0131n karesini al\nval kareleri = sayilar.map { it * it }\nprintln(\"Say\u0131lar\u0131n Kareleri: $kareleri\") \/\/ \u00c7\u0131kt\u0131: Say\u0131lar\u0131n Kareleri: [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]\n\n\/\/ Her say\u0131y\u0131 ekrana yazd\u0131r\nprintln(\"T\u00fcm Say\u0131lar:\")\nsayilar.forEach { println(it) }\n<\/pre>\n
    <\/code><\/p>\n
    Bu \u00f6rnekler, lambdalar\u0131n koleksiyon i\u015flemleriyle nas\u0131l sorunsuz bir \u015fekilde entegre oldu\u011funu ve kodunuzu nas\u0131l daha \u00f6zl\u00fc hale getirdi\u011fini a\u00e7\u0131k\u00e7a g\u00f6stermektedir. Geleneksel d\u00f6ng\u00fclerle ayn\u0131 i\u015flemleri yapmak \u00e7ok daha fazla kod sat\u0131r\u0131 gerektirecektir.<\/p>\n
    apply, with, run, let, also: Kapsam Fonksiyonlar\u0131 (Scope Functions)<\/h3>\n
    Kotlin'deki kapsam fonksiyonlar\u0131, belirli bir nesne \u00fczerinde kod bloklar\u0131n\u0131 y\u00fcr\u00fctmek i\u00e7in tasarlanm\u0131\u015f y\u00fcksek mertebeden fonksiyonlard\u0131r. Her biri farkl\u0131 bir kullan\u0131m senaryosu i\u00e7in optimize edilmi\u015ftir ve kodunuzun okunabilirli\u011fini ve ak\u0131c\u0131l\u0131\u011f\u0131n\u0131 \u00f6nemli \u00f6l\u00e7\u00fcde art\u0131rabilir.<\/p>\n
      \n
    • apply<\/code>: Bir nesne \u00fczerinde yap\u0131land\u0131rma veya ba\u015flatma i\u015flemleri yapmak i\u00e7in kullan\u0131l\u0131r. Lambda i\u00e7inde nesneye this<\/code> ile eri\u015filir ve nesnenin kendisini d\u00f6nd\u00fcr\u00fcr.<\/li>\n
    • with<\/code>: Bir nesne \u00fczerinde birden fazla i\u015flem yapmak i\u00e7in kullan\u0131l\u0131r. Lambda i\u00e7inde nesneye this<\/code> ile eri\u015filir ve lambda'n\u0131n son sonucunu d\u00f6nd\u00fcr\u00fcr. Genellikle null olmayan bir nesne \u00fczerinde kullan\u0131l\u0131r.<\/li>\n
    • run<\/code>: with<\/code> gibi, bir nesne \u00fczerinde i\u015flem yapmak i\u00e7in kullan\u0131l\u0131r, ancak null g\u00fcvenli bir \u015fekilde \u00e7a\u011fr\u0131labilir (?.run<\/code>). Lambda i\u00e7inde nesneye this<\/code> ile eri\u015filir ve lambda'n\u0131n son sonucunu d\u00f6nd\u00fcr\u00fcr. Genellikle nesneye ait \u00fcyeleri \u00e7a\u011f\u0131rmak i\u00e7in kullan\u0131l\u0131r.<\/li>\n
    • let<\/code>: Bir nesne \u00fczerinde belirli bir i\u015flem yapmak i\u00e7in kullan\u0131l\u0131r, genellikle null g\u00fcvenli\u011fi kontrol\u00fc ile birlikte (?.let<\/code>). Lambda i\u00e7inde nesneye it<\/code> ile eri\u015filir ve lambda'n\u0131n son sonucunu d\u00f6nd\u00fcr\u00fcr. Genellikle tek bir parametre alan lambdalar i\u00e7in idealdir.<\/li>\n
    • also<\/code>: apply<\/code> gibi, bir nesne \u00fczerinde yan etkili i\u015flemler yapmak i\u00e7in kullan\u0131l\u0131r. Lambda i\u00e7inde nesneye it<\/code> ile eri\u015filir ve nesnenin kendisini d\u00f6nd\u00fcr\u00fcr. Genellikle zincirleme \u00e7a\u011fr\u0131larda nesnenin durumunu loglamak veya ek bir i\u015flem yapmak i\u00e7in kullan\u0131l\u0131r.<\/li>\n<\/ul>\n
      \ndata class Kullanici(var ad: String, var yas: Int)\n\nval kullanici = Kullanici(\"Ay\u015fe\", 30).apply {\n    yas = 31 \/\/ 'this' anahtar kelimesi \u00f6rt\u00fck olarak kullan\u0131l\u0131yor\n    \/\/ Birden fazla yap\u0131land\u0131rma i\u015flemi yap\u0131labilir\n}\nprintln(\"Apply ile yap\u0131land\u0131r\u0131lm\u0131\u015f kullan\u0131c\u0131: $kullanici\")\n\nval sonuc = with(kullanici) {\n    println(\"Kullan\u0131c\u0131 ad\u0131: $ad, Ya\u015f: $yas\") \/\/ 'this' anahtar kelimesi \u00f6rt\u00fck olarak kullan\u0131l\u0131yor\n    yas + 10 \/\/ Lambda'n\u0131n son sonucu\n}\nprintln(\"With ile hesaplanan ya\u015f + 10: $sonuc\")\n\nval kullaniciBilgisi = kullanici.let {\n    \"Ad\u0131: ${it.ad}, Ya\u015f\u0131: ${it.yas}\" \/\/ 'it' anahtar kelimesi kullan\u0131l\u0131yor\n}\nprintln(\"Let ile al\u0131nan bilgi: $kullaniciBilgisi\")\n\nkullanici.also {\n    println(\"Kullan\u0131c\u0131 nesnesi \u00fczerinde ek i\u015flem: $it\") \/\/ 'it' kullan\u0131l\u0131yor, nesne d\u00f6nd\u00fcr\u00fcl\u00fcyor\n}\n<\/pre>\n
      <\/code><\/p>\n
      Vaka Analizi: Veri \u0130\u015fleme Ak\u0131\u015f\u0131<\/h3>\n
      Ger\u00e7ek d\u00fcnya senaryosunda, bir kullan\u0131c\u0131 listesini filtreleyip, isimlerini b\u00fcy\u00fct\u00fcp, ya\u015flar\u0131na g\u00f6re s\u0131ralayabiliriz:<\/p>\n
      \ndata class User(val name: String, val age: Int, val isActive: Boolean)\n\nval users = listOf(\n    User(\"Ali\", 25, true),\n    User(\"Veli\", 30, false),\n    User(\"Ay\u015fe\", 22, true),\n    User(\"Fatma\", 35, true),\n    User(\"Mehmet\", 28, false)\n)\n\nval activeAdultUsers = users\n    .filter { it.isActive && it.age >= 18 } \/\/ Aktif ve yeti\u015fkin kullan\u0131c\u0131lar\u0131 filtrele\n    .map { it.name.toUpperCase() } \/\/ \u0130simlerini b\u00fcy\u00fck harfe d\u00f6n\u00fc\u015ft\u00fcr\n    .sorted() \/\/ Alfabetik s\u0131raya g\u00f6re s\u0131rala\n    .forEach { println(\"Aktif yeti\u015fkin kullan\u0131c\u0131: $it\") } \/\/ Sonu\u00e7lar\u0131 yazd\u0131r\n<\/pre>\n
      <\/code><\/p>\n
      Bu ak\u0131\u015f, geleneksel d\u00f6ng\u00fclerle yaz\u0131ld\u0131\u011f\u0131nda \u00e7ok daha uzun ve okunmas\u0131 zor olurdu. Y\u00fcksek mertebeden fonksiyonlar ve lambdalar sayesinde, veri i\u015fleme mant\u0131\u011f\u0131 do\u011fal bir ak\u0131\u015fta ifade edilebilir, bu da kodun hem daha anla\u015f\u0131l\u0131r hem de daha s\u00fcrd\u00fcr\u00fclebilir olmas\u0131n\u0131 sa\u011flar. Bu g\u00fc\u00e7l\u00fc kombinasyon, Kotlin geli\u015ftiricilerinin karma\u015f\u0131k g\u00f6revleri zarif ve verimli bir \u015fekilde \u00e7\u00f6zmelerine olanak tan\u0131r.<\/p>\n
      Kapan\u0131\u015flar (Closures) ve Yakalanan De\u011fi\u015fkenler: Lambdalar\u0131n Bellekle \u0130li\u015fkisi Nedir?<\/h2>\n
      Kotlin'de lambdalar\u0131 kullanmaya ba\u015flad\u0131\u011f\u0131m\u0131zda, genellikle kar\u015f\u0131la\u015ft\u0131\u011f\u0131m\u0131z ancak tam olarak anlamad\u0131\u011f\u0131m\u0131z g\u00fc\u00e7l\u00fc bir kavram olan \"closure\" (kapan\u0131\u015f) devreye girer. Bir lambda veya anonim fonksiyon, tan\u0131mland\u0131\u011f\u0131 kapsamdaki (scope) de\u011fi\u015fkenlere eri\u015febilir ve bu de\u011fi\u015fkenleri kullanabilir. Bu yetenek, lambdan\u0131n \"kapan\u0131\u015f\" olarak hareket etmesini sa\u011flar. Yani, lambda tan\u0131m\u0131n\u0131n yap\u0131ld\u0131\u011f\u0131 yerdeki \u00e7evresel de\u011fi\u015fkenleri \"kapat\u0131r\" veya \"yakalar\". Bu, lambdan\u0131n tan\u0131mland\u0131\u011f\u0131 kapsamdan ayr\u0131lsa bile, yakalad\u0131\u011f\u0131 de\u011fi\u015fkenlere eri\u015fmeye devam edebilece\u011fi anlam\u0131na gelir. Bu \u00f6zellik, b\u00fcy\u00fck bir esneklik sunar ancak ayn\u0131 zamanda dikkatli kullan\u0131lmad\u0131\u011f\u0131nda baz\u0131 potansiyel tuzaklar\u0131 da beraberinde getirebilir, \u00f6zellikle bellek y\u00f6netimi a\u00e7\u0131s\u0131ndan.<\/p>\n
      Closure Tan\u0131m\u0131 ve De\u011fi\u015fken Eri\u015fimi<\/h3>\n
      Bir closure, kendi tan\u0131m\u0131ndan ba\u011f\u0131ms\u0131z olarak, bir fonksiyonun d\u0131\u015f kapsam\u0131ndaki de\u011fi\u015fkenlere eri\u015febilen bir fonksiyondur. Kotlin'de, lambdalar varsay\u0131lan olarak closure'lard\u0131r. Bu, bir lambda blo\u011funun d\u0131\u015f\u0131ndaki bir de\u011fi\u015fkene at\u0131fta bulunuldu\u011funda, bu de\u011fi\u015fkenin lambda taraf\u0131ndan \"yakaland\u0131\u011f\u0131\" anlam\u0131na gelir. Yakalanan bu de\u011fi\u015fken, lambda \u00e7a\u011fr\u0131ld\u0131\u011f\u0131nda hala eri\u015filebilir durumda olur, hatta lambda orijinal kapsam\u0131n\u0131n d\u0131\u015f\u0131na \u00e7\u0131km\u0131\u015f olsa bile.<\/p>\n
      \nfun createCounter(): () -> Int {\n    var count = 0 \/\/ Yakalanacak de\u011fi\u015fken\n    return {\n        count++ \/\/ Lambda, d\u0131\u015f kapsamdaki 'count' de\u011fi\u015fkenine eri\u015fir ve onu de\u011fi\u015ftirir\n        count\n    }\n}\n\nval counter1 = createCounter()\nprintln(counter1()) \/\/ \u00c7\u0131kt\u0131: 1\nprintln(counter1()) \/\/ \u00c7\u0131kt\u0131: 2\n\nval counter2 = createCounter()\nprintln(counter2()) \/\/ \u00c7\u0131kt\u0131: 1 (Kendi 'count' de\u011fi\u015fkenine sahip)\n<\/pre>\n
      <\/code><\/p>\n
      Yukar\u0131daki \u00f6rnekte, createCounter<\/code> fonksiyonu bir lambda d\u00f6nd\u00fcr\u00fcyor. Bu lambda, createCounter<\/code> fonksiyonu i\u00e7indeki count<\/code> de\u011fi\u015fkenini yakal\u0131yor. Her createCounter<\/code> \u00e7a\u011fr\u0131s\u0131, count<\/code> de\u011fi\u015fkeninin yeni bir \u00f6rne\u011fini olu\u015fturur ve dolay\u0131s\u0131yla her counter<\/code> \u00f6rne\u011fi, kendi ba\u011f\u0131ms\u0131z count<\/code> de\u011fi\u015fkenini y\u00f6netir. Bu, closure'lar\u0131n nas\u0131l \u00e7al\u0131\u015ft\u0131\u011f\u0131n\u0131n klasik bir \u00f6rne\u011fidir.<\/p>\n
      Mutable vs Immutable Yakalanan De\u011fi\u015fkenler<\/h3>\n
      Kotlin'de, bir lambda taraf\u0131ndan yakalanan de\u011fi\u015fkenler val<\/code> (immutable) veya var<\/code> (mutable) olabilir.<\/p>\n
        \n
      • val<\/code> de\u011fi\u015fkenleri:<\/strong> Lambda taraf\u0131ndan sadece okunabilirler. De\u011ferleri lambda i\u00e7inde de\u011fi\u015ftirilemez.<\/li>\n
      • var<\/code> de\u011fi\u015fkenleri:<\/strong> Lambda taraf\u0131ndan okunabilir ve de\u011fi\u015ftirilebilirler. Yukar\u0131daki count<\/code> \u00f6rne\u011fi, var<\/code> de\u011fi\u015fkeninin nas\u0131l de\u011fi\u015ftirilebildi\u011fini g\u00f6stermektedir.<\/li>\n<\/ul>\n
        Bu, lambdan\u0131n tan\u0131mland\u0131\u011f\u0131 kapsamdaki de\u011fi\u015fkenlerin durumunu do\u011frudan etkileyebilece\u011fi anlam\u0131na gelir. Bu g\u00fc\u00e7l\u00fc bir yetenek olmakla birlikte, dikkatli kullan\u0131lmazsa beklenmedik sonu\u00e7lara yol a\u00e7abilir. \u00d6zellikle e\u015fzamanl\u0131 (concurrent) programlamada, birden fazla thread'in ayn\u0131 yakalanm\u0131\u015f var<\/code> de\u011fi\u015fkenine eri\u015fmeye \u00e7al\u0131\u015fmas\u0131, yar\u0131\u015f ko\u015fullar\u0131na (race conditions) ve hatalara neden olabilir.<\/p>\n
        Potansiyel Tuzaklar: Bellek S\u0131z\u0131nt\u0131lar\u0131 (Memory Leaks)<\/h3>\n
        Closure'lar\u0131n g\u00fcc\u00fc, ayn\u0131 zamanda potansiyel bir zay\u0131fl\u0131\u011f\u0131 da bar\u0131nd\u0131r\u0131r: bellek s\u0131z\u0131nt\u0131lar\u0131. \u00d6zellikle Android geli\u015ftirme gibi kaynak k\u0131s\u0131tl\u0131 ortamlarda bu durum kritik \u00f6nem ta\u015f\u0131r. Bir lambda, kendisini tan\u0131mlayan bir Activity veya Fragment'taki bir g\u00f6r\u00fcn\u00fcm\u00fc (View) veya bir ba\u011flam\u0131 (Context) yakalarsa, Activity\/Fragment yok edildi\u011finde bile lambda hala bu nesnelere referans tutmaya devam edebilir. Bu durumda, Activity\/Fragment \u00e7\u00f6p toplay\u0131c\u0131 (Garbage Collector) taraf\u0131ndan temizlenemez ve bellekte kalmaya devam eder, bu da bellek s\u0131z\u0131nt\u0131s\u0131na yol a\u00e7ar.<\/p>\n
        \n  Uzman \u0130pucu: Bellek Y\u00f6netimi ve Dikkat Edilmesi Gerekenler<\/b>
        \n  Android'de, bir Activity veya Fragment i\u00e7inden tan\u0131mlanan lambdalar\u0131n, bu Activity\/Fragment'\u0131n Context'ine veya View'lerine g\u00fc\u00e7l\u00fc referanslar tutmamas\u0131na \u00f6zen g\u00f6sterin. E\u011fer lambda uzun \u00f6m\u00fcrl\u00fc bir nesneye (\u00f6rne\u011fin bir singleton) atan\u0131yorsa ve bu lambda bir Activity Context'ini yakal\u0131yorsa, Activity yok olsa bile Context bellekte kalmaya devam edecektir. Bu t\u00fcr durumlarda, ya lambda'y\u0131 Activity'nin ya\u015fam d\u00f6ng\u00fcs\u00fcne ba\u011flamal\u0131 ya da zay\u0131f referanslar (WeakReference) kullanmay\u0131 d\u00fc\u015f\u00fcnmelisiniz. Alternatif olarak, lambda'y\u0131 inline<\/code> olarak i\u015faretleyerek derleyicinin lambdan\u0131n kodunu do\u011frudan \u00e7a\u011f\u0131ran fonksiyona yap\u0131\u015ft\u0131rmas\u0131n\u0131 sa\u011flayabilir ve b\u00f6ylece bir closure nesnesi olu\u015fturma maliyetinden ka\u00e7\u0131nabilirsiniz, ancak bu her zaman bir \u00e7\u00f6z\u00fcm de\u011fildir ve inline hakk\u0131nda ayr\u0131nt\u0131l\u0131 bilgi i\u00e7in bir sonraki b\u00f6l\u00fcme bakmal\u0131s\u0131n\u0131z.\n<\/div>\n
        \u00d6zetle, closure'lar Kotlin'de lambdalar\u0131n \u00e7ok g\u00fc\u00e7l\u00fc bir \u00f6zelli\u011fidir ve fonksiyonel programlaman\u0131n temel ta\u015flar\u0131ndan biridir. D\u0131\u015f kapsamdaki de\u011fi\u015fkenlere eri\u015fim yetene\u011fi sayesinde daha esnek ve mod\u00fcler kodlar yazabiliriz. Ancak, bu g\u00fcc\u00fc kullan\u0131rken bellek y\u00f6netimi ve olas\u0131 yan etkiler konusunda dikkatli olmak, \u00f6zellikle mobil veya y\u00fcksek performans gerektiren uygulamalarda kritik \u00f6neme sahiptir. Closure'lar\u0131 do\u011fru anlamak ve y\u00f6netmek, daha sa\u011flam ve verimli Kotlin uygulamalar\u0131 geli\u015ftirmenizin anahtar\u0131d\u0131r.<\/p>\n
        \u0130leri D\u00fczey Lambda Kullan\u0131mlar\u0131: Inline Fonksiyonlar ve Kontrol Ak\u0131\u015f\u0131<\/h2>\n
        Kotlin'de lambdalar\u0131n temel ve y\u00fcksek mertebeden kullan\u0131mlar\u0131n\u0131 anlad\u0131ktan sonra, daha ileri d\u00fczey konulara dalmak, kodunuzu daha da optimize etmenize ve belirli senaryolarda daha g\u00fc\u00e7l\u00fc kontrol ak\u0131\u015flar\u0131 olu\u015fturman\u0131za olanak tan\u0131r. Bu b\u00f6l\u00fcmde, inline<\/code> anahtar kelimesinin performansa etkilerini, etiketli return<\/code> ifadelerini ve lambdalar\u0131n Unit<\/code> d\u00f6n\u00fc\u015f tipini ele alaca\u011f\u0131z. Bu konular, \u00f6zellikle k\u00fct\u00fcphane geli\u015ftiricileri veya y\u00fcksek performansl\u0131 uygulamalar yazanlar i\u00e7in b\u00fcy\u00fck \u00f6nem ta\u015f\u0131r.<\/p>\n
        Inline Fonksiyonlar: Performans\u0131 Art\u0131rman\u0131n Yolu<\/h3>\n
        Kotlin'de y\u00fcksek mertebeden fonksiyonlar ve lambdalar, kodun okunabilirli\u011fini ve esnekli\u011fini art\u0131r\u0131rken, baz\u0131 durumlarda ufak bir performans maliyeti getirebilir. Her lambda \u00e7a\u011f\u0131rma, arkas\u0131nda bir fonksiyon nesnesi olu\u015fturulmas\u0131n\u0131 ve bu nesnenin \u00e7a\u011fr\u0131lmas\u0131n\u0131 gerektirir. K\u00fc\u00e7\u00fck lambdalar ve s\u0131k\u00e7a \u00e7a\u011fr\u0131lan fonksiyonlar i\u00e7in bu durum, \u00f6zellikle mobil cihazlar gibi kaynak k\u0131s\u0131tl\u0131 ortamlarda performansa etki edebilir. \u0130\u015fte tam bu noktada inline<\/code> anahtar kelimesi devreye girer.<\/p>\n
        Bir fonksiyonu inline<\/code> olarak i\u015faretledi\u011finizde, Kotlin derleyicisi bu fonksiyonun ve ona arg\u00fcman olarak ge\u00e7irilen lambdalar\u0131n kodunu, \u00e7a\u011fr\u0131ld\u0131\u011f\u0131 yere do\u011frudan kopyalar (yap\u0131\u015ft\u0131r\u0131r). Bu, bir fonksiyon \u00e7a\u011fr\u0131s\u0131 olu\u015fturma ve bir lambda nesnesi tahsis etme maliyetini ortadan kald\u0131r\u0131r. Sonu\u00e7 olarak, performans art\u0131\u015f\u0131 sa\u011flan\u0131r, \u00f6zellikle de lambda i\u00e7eren fonksiyonlar d\u00f6ng\u00fclerin i\u00e7inde s\u0131k\u00e7a \u00e7a\u011fr\u0131l\u0131yorsa.<\/p>\n
        \ninline fun measureTime(block: () -> Unit) {\n    val start = System.nanoTime()\n    block() \/\/ Lambda do\u011frudan buraya yap\u0131\u015ft\u0131r\u0131l\u0131r\n    val end = System.nanoTime()\n    println(\"\u0130\u015flem s\u00fcresi: ${(end - start) \/ 1_000_000.0} ms\")\n}\n\nfun main() {\n    measureTime {\n        var sum = 0\n        for (i in 1..1_000_000) {\n            sum += i\n        }\n    }\n}\n<\/pre>\n
        <\/code><\/p>\n
        Yukar\u0131daki measureTime<\/code> fonksiyonu inline<\/code> olarak i\u015faretlendi\u011fi i\u00e7in, main<\/code> fonksiyonundaki lambda'n\u0131n kodu do\u011frudan measureTime<\/code> \u00e7a\u011fr\u0131s\u0131n\u0131n i\u00e7ine kopyalanacakt\u0131r. Bu, \u00e7al\u0131\u015fma zaman\u0131nda ek bir fonksiyon \u00e7a\u011fr\u0131s\u0131 veya nesne tahsisi olmamas\u0131 anlam\u0131na gelir.<\/p>\n
        noinline<\/code> ve crossinline<\/code><\/h4>\n
        Bazen bir inline<\/code> fonksiyona birden fazla lambda arg\u00fcman\u0131 ge\u00e7irebiliriz, ancak bunlardan baz\u0131lar\u0131n\u0131n inline olmas\u0131n\u0131 istemeyebiliriz. Bu durumda, noinline<\/code> anahtar kelimesini kullanarak belirli bir lambda parametresinin inline edilmesini engelleyebiliriz. Bu, \u00f6zellikle lambday\u0131 bir alanda saklaman\u0131z veya ba\u015fka bir fonksiyon taraf\u0131ndan daha sonra \u00e7a\u011fr\u0131lmas\u0131n\u0131 istiyorsan\u0131z kullan\u0131\u015fl\u0131d\u0131r.<\/p>\n
        crossinline<\/code> ise, inline fonksiyonun bir lambday\u0131 inline etmesini sa\u011flarken, bu lambdan\u0131n i\u00e7inde non-local return<\/code> (etiketli return<\/code> hari\u00e7) kullanmas\u0131n\u0131 engeller. Bu, \u00f6zellikle callback'ler i\u00e7in \u00f6nemlidir, \u00e7\u00fcnk\u00fc callback'in \u00e7a\u011f\u0131ran fonksiyondan erken \u00e7\u0131kmas\u0131n\u0131 istemeyebilirsiniz.<\/p>\n
        Non-local Return ve Etiketli Return<\/h3>\n
        Normalde, bir lambda i\u00e7inden return<\/code> kulland\u0131\u011f\u0131n\u0131zda, bu, en yak\u0131n fun<\/code> anahtar kelimesiyle tan\u0131mlanm\u0131\u015f fonksiyondan \u00e7\u0131kar. Bu, \"non-local return\" olarak bilinir ve bazen istenmeyen davran\u0131\u015flara yol a\u00e7abilir, \u00f6zellikle bir d\u00f6ng\u00fc i\u00e7inde lambda kullan\u0131yorsan\u0131z ve sadece lambdan\u0131n kendisinden \u00e7\u0131kmak istiyorsan\u0131z.<\/p>\n
        \nfun findEvenNumber(numbers: List) {\n    numbers.forEach {\n        if (it % 2 == 0) {\n            println(\"\u00c7ift say\u0131 bulundu: $it\")\n            return \/\/ Bu, findEvenNumber fonksiyonundan \u00e7\u0131kar\n        }\n    }\n    println(\"Hi\u00e7 \u00e7ift say\u0131 bulunamad\u0131.\")\n}\n\nfun main() {\n    findEvenNumber(listOf(1, 3, 5, 2, 7)) \/\/ \u00c7\u0131kt\u0131: \u00c7ift say\u0131 bulundu: 2\n    println(\"Fonksiyondan \u00e7\u0131k\u0131ld\u0131.\")\n}\n<\/pre>\n
        <\/code><\/p>\n
        Bu \u00f6rnekte, forEach<\/code> i\u00e7indeki return<\/code> ifadesi, findEvenNumber<\/code> fonksiyonundan tamamen \u00e7\u0131kar. E\u011fer sadece lambdan\u0131n kendisinden \u00e7\u0131kmak (yani, forEach<\/code> d\u00f6ng\u00fcs\u00fcn\u00fcn bir sonraki eleman\u0131na ge\u00e7mek) istiyorsak, \"etiketli return\" kullan\u0131r\u0131z.<\/p>\n
        \nfun findEvenNumberWithLabel(numbers: List) {\n    numbers.forEach lamba@{\n        if (it % 2 == 0) {\n            println(\"\u00c7ift say\u0131 bulundu: $it\")\n            return@lamba \/\/ Sadece lambdadan \u00e7\u0131kar, forEach d\u00f6ng\u00fcs\u00fc devam eder\n        }\n    }\n    println(\"T\u00fcm say\u0131lar kontrol edildi.\")\n}\n\nfun main() {\n    findEvenNumberWithLabel(listOf(1, 3, 5, 2, 7))\n    \/\/ \u00c7\u0131kt\u0131:\n    \/\/ \u00c7ift say\u0131 bulundu: 2\n    \/\/ T\u00fcm say\u0131lar kontrol edildi.\n}\n<\/pre>\n
        <\/code><\/p>\n
        Burada lamba@<\/code> etiketi, forEach<\/code> lambdas\u0131n\u0131n kendisini temsil eder ve return@lamba<\/code> ifadesi, sadece bu lambda blo\u011fundan \u00e7\u0131k\u0131lmas\u0131n\u0131 sa\u011flar, ana findEvenNumberWithLabel<\/code> fonksiyonunun \u00e7al\u0131\u015fmas\u0131na devam etmesine olanak tan\u0131r. Bu, kontrol ak\u0131\u015f\u0131n\u0131 \u00e7ok daha esnek bir \u015fekilde y\u00f6netmenizi sa\u011flar.<\/p>\n
        Unit<\/code> D\u00f6n\u00fc\u015f Tipi<\/h3>\n
        Kotlin'de fonksiyonlar veya lambdalar bir de\u011fer d\u00f6nd\u00fcrmedi\u011finde, d\u00f6n\u00fc\u015f tipi Unit<\/code> olarak kabul edilir. Unit<\/code> asl\u0131nda hi\u00e7bir de\u011fer d\u00f6nd\u00fcrmeyen void'in bir Kotlin e\u015fde\u011feridir, ancak bir nesnedir. Genellikle a\u00e7\u0131k\u00e7a belirtmek zorunda kalmazs\u0131n\u0131z, \u00e7\u00fcnk\u00fc derleyici bunu otomatik olarak \u00e7\u0131kar\u0131r. Ancak, bazen a\u00e7\u0131kl\u0131k i\u00e7in Unit<\/code> d\u00f6nd\u00fcren bir lambda'n\u0131n d\u00f6n\u00fc\u015f tipini a\u00e7\u0131k\u00e7a belirtebiliriz.<\/p>\n
        \nval doSomething: () -> Unit = {\n    println(\"Bir \u015feyler yap\u0131l\u0131yor...\")\n}\ndoSomething()\n<\/pre>\n
        <\/code><\/p>\n
        Bu ileri d\u00fczey kullan\u0131mlar, Kotlin'in lambdalarla sa\u011flad\u0131\u011f\u0131 derinli\u011fi ve esnekli\u011fi ortaya koyar. inline<\/code> fonksiyonlar performans\u0131 optimize ederken, etiketli return'ler kontrol ak\u0131\u015f\u0131n\u0131 hassas bir \u015fekilde y\u00f6netmenize olanak tan\u0131r. Bu \u00f6zellikler, daha verimli, daha okunakl\u0131 ve daha kontrol edilebilir Kotlin kodu yazman\u0131z i\u00e7in g\u00fc\u00e7l\u00fc ara\u00e7lar sunar.<\/p>\n
        Ger\u00e7ek D\u00fcnya Senaryolar\u0131nda Kotlin Lambdalar\u0131: Pratik Vaka Analizleri<\/h2>\n
        Lambdalar\u0131n teorik y\u00f6nlerini ve s\u00f6zdizimini \u00f6\u011frendikten sonra, bunlar\u0131n ger\u00e7ek d\u00fcnya uygulamalar\u0131nda nas\u0131l kullan\u0131ld\u0131\u011f\u0131n\u0131 g\u00f6rmek, konuyu tam olarak kavraman\u0131n en iyi yoludur. Kotlin lambdalar\u0131, modern yaz\u0131l\u0131m geli\u015ftirmenin bir\u00e7ok alan\u0131nda, \u00f6zellikle Android mobil, backend servisleri ve veri i\u015fleme g\u00f6revlerinde vazge\u00e7ilmez bir rol oynar. Bu b\u00f6l\u00fcmde, lambdalar\u0131n pratik de\u011ferini g\u00f6steren birka\u00e7 vaka analizi sunaca\u011f\u0131z.<\/p>\n
        Vaka 1: Android Geli\u015ftirmede Olay \u0130\u015fleme (Event Handling)<\/h3>\n
        Android geli\u015ftirmenin kalbinde, kullan\u0131c\u0131 etkile\u015fimlerini y\u00f6netmek yatar. Bir d\u00fc\u011fmeye t\u0131klama, bir metin alan\u0131na metin girme veya bir listeden \u00f6\u011fe se\u00e7me gibi olaylar s\u00fcrekli olarak ger\u00e7ekle\u015fir. Geleneksel olarak, bu t\u00fcr olaylar, aray\u00fczler (interfaces) uygulayan veya anonim i\u00e7 s\u0131n\u0131flar (anonymous inner classes) kullanan listener'lar arac\u0131l\u0131\u011f\u0131yla i\u015flenirdi. Kotlin lambdalar\u0131, bu s\u00fcre\u00e7leri radikal bir \u015fekilde basitle\u015ftirmi\u015ftir.<\/p>\n
        \u00d6rne\u011fin, bir Button<\/code> i\u00e7in OnClickListener<\/code> tan\u0131mlamak:<\/p>\n
        \n\/\/ Geleneksel y\u00f6ntem (Java benzeri)\nval myButton = findViewById