<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Yusuf Can Mercan on Medium]]></title>
        <description><![CDATA[Stories by Yusuf Can Mercan on Medium]]></description>
        <link>https://medium.com/@cusufcan?source=rss-0142a79ab291------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*WPxbECHg3IE3UAyWOozGDA.jpeg</url>
            <title>Stories by Yusuf Can Mercan on Medium</title>
            <link>https://medium.com/@cusufcan?source=rss-0142a79ab291------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Thu, 19 Nov 2026 00:55:32 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@cusufcan/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Kotlin-30 : Delegated Properties]]></title>
            <link>https://medium.com/@cusufcan/kotlin-30-delegated-properties-eb445886ee61?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb445886ee61</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Sat, 01 Feb 2025 09:51:53 GMT</pubDate>
            <atom:updated>2025-02-01T09:51:53.247Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-30 : Delegated Properties</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, Kotlin’de yetkilendirilmiş değişkenlerin (Delegated Properties) ne olduğunu ve nasıl kullanıldığını anlatacağım. Kotlin, bir değişkenin (property) yönetimini başka bir nesneye devretmeyi sağlar, böylece get() ve set() işlemleri belirlenen bir nesne tarafından kontrol edilebilir. Delegated properties, farklı senaryolarda kullanışlıdır; <strong>lazy properties (tembel değişkenler)</strong> sayesinde değerler ilk erişimde oluşturulur ve <strong>observable properties (gözlemlenebilir değişkenler)</strong> ile değer değişiklikleri dinlenebilir.</p><h3><strong>Temel Kullanım</strong></h3><pre>class Delegate {<br>    operator fun getValue(thisRef: Any?, property: KProperty&lt;*&gt;): String {<br>        return &quot;$thisRef, &#39;${property.name}&#39; özelliğini bana devrettiniz!&quot;<br>    }<br><br>    operator fun setValue(thisRef: Any?, property: KProperty&lt;*&gt;, value: String) {<br>        println(&quot;&#39;${property.name}&#39; özelliğine &#39;$value&#39; atandı.&quot;)<br>    }<br>}<br><br>class Example {<br>    var p: String by Delegate()<br>}<br><br>fun main() {<br>    val e = Example()<br>    println(e.p) // İlk erişimde getValue() çalışır.<br>    e.p = &quot;Yeni Değer&quot; // Atama yapılınca setValue() çalışır.<br>}<br><br>// Çıktı:<br>// Example@33a17727, &#39;p&#39; özelliğini bana devrettiniz!<br>// &#39;p&#39; özelliğine &#39;Yeni Değer&#39; atandı.</pre><p>Bu örnekte <strong>p</strong> değişkeni <strong>Delegate</strong> sınıfına devrediliyor ve <strong>getValue()</strong> ile <strong>setValue()</strong> metotları sayesinde özel bir erişim mantığı sağlanıyor.</p><h3>Standart Delegates</h3><p>Kotlin, sık kullanılan yetkilendirme senaryoları için <strong>standart delegates</strong> sunar. Bunlar arasında <strong>lazy (tembel başlatma)</strong>, <strong>observable (gözlemlenebilir değişkenler)</strong>, <strong>map-based delegates</strong> gibi yapılar bulunur.</p><h4><strong>1. Lazy Properties (Tembel Başlatma)</strong></h4><p><strong>Lazy initialization</strong>, bir değişkenin <strong>ilk kez erişildiğinde</strong> oluşturulmasını sağlar. Bu sayede gereksiz oluşturmaların önüne geçilir:</p><pre>val lazyValue: String by lazy {<br>    println(&quot;Oluşturuldu!&quot;)<br>    &quot;Merhaba, Kotlin!&quot;<br>}<br><br>fun main() {<br>    println(lazyValue) // &quot;Oluşturuldu!&quot; yazılır ve değeri yazdırır.<br>    println(lazyValue) // Sadece değeri yazdırır.<br>}</pre><p>Görüldüğü gibi, <strong>lazyValue</strong> ilk kez çağrıldığında oluşturuluyor ve sonraki çağrılarda doğrudan önceki sonucu döndürüyor.</p><p><strong>Not: </strong>Varsayılan olarak <strong>lazy()</strong> <strong>thread-safe</strong> çalışır. Eğer <strong>thread</strong> güvenliği gerekmiyorsa <strong>lazy(LazyThreadSafetyMode.NONE)</strong> kullanabilirsiniz.</p><h4><strong>2. Observable Properties (Gözlemlenebilir Değişkenler)</strong></h4><p>Eğer bir değişkenin değeri değiştiğinde belirli bir aksiyon almak istiyorsanız, <strong>Delegates.observable</strong> kullanabilirsiniz. Bu özellik, <strong>değişiklikleri takip etme</strong> ve <strong>loglama</strong> gibi işlemleri kolaylaştırır:</p><pre>import kotlin.properties.Delegates<br><br>class User {<br>    var name: String by Delegates.observable(&quot;&lt;varsayılan&gt;&quot;) { _, old, new -&gt;<br>        println(&quot;$old -&gt; $new&quot;)<br>    }<br>}<br><br>fun main() {<br>    val user = User()<br>    user.name = &quot;Ali&quot;<br>    user.name = &quot;Veli&quot;<br>}<br><br>// Çıktı:<br>// &lt;varsayılan&gt; -&gt; Ali<br>// Ali -&gt; Veli</pre><p>Bu örnekte <strong>name</strong> değişkeni her değiştiğinde eski ve yeni değer ekrana yazdırılıyor.</p><h4><strong>3. Değişkenleri Map Olarak Saklama</strong></h4><p>Bazı durumlarda, <strong>JSON verisi</strong> veya <strong>dinamik nesnelerle</strong> çalışırken özellikleri bir map içinde saklamak faydalı olabilir:</p><pre>class User(val map: Map&lt;String, Any?&gt;) {<br>    val name: String by map<br>    val age: Int by map<br>}<br><br>fun main() {<br>    val user = User(mapOf(&quot;name&quot; to &quot;Ahmet&quot;, &quot;age&quot; to 30))<br>    println(user.name) // Ahmet<br>    println(user.age)  // 30<br>}</pre><p>Burada <strong>User</strong> sınıfındaki <strong>name</strong> ve <strong>age</strong> değişkenleri doğrudan bir <strong>Map</strong> içindeki değerlere bağlanıyor. Bu, JSON veri yapılarıyla çalışırken oldukça kullanışlıdır.</p><h4>4. Yerel Değişkenlerde Yetkilendirme</h4><p>Yetkilendirilmiş değişkenler sadece sınıf seviyesinde değil, <strong>yerel değişkenlerde</strong> de kullanılabilir:</p><pre>fun example(computeFoo: () -&gt; String) {<br>    val memoizedFoo by lazy(computeFoo)<br><br>    println(memoizedFoo) // İlk erişimde oluşturulur.<br>    println(memoizedFoo) // Önceki sonucu kullanır.<br>}<br><br>fun main() {<br>    example { &quot;Oluşturuldu!&quot; }<br>}</pre><p>Bu teknik, ağır maliyetli nesne oluşturmaları <strong>yalnızca ihtiyaç duyulduğunda çalıştırmak</strong> için oldukça faydalıdır.</p><h3>Derleyicinin Delegated Properties’i Yorumlaması</h3><p>Bir değişken delegate edildiğinde, Kotlin arka planda bir <strong>yardımcı değişken ($delegate)</strong> oluşturur:</p><pre>class C {<br>    var prop: String by MyDelegate()<br>}<br><br>// Kotlin bunu şu şekilde çevirir:<br>class C {<br>    private val prop$delegate = MyDelegate()<br>    <br>    var prop: String<br>        get() = prop$delegate.getValue(this, this::prop)<br>        set(value) = prop$delegate.setValue(this, this::prop, value)<br>}</pre><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, Kotlin’de <strong>delegated properties</strong> kavramını, farklı türlerini, nasıl çalıştıklarını ve avantajlarını ele aldım. Delegated properties, Kotlin’in esneklik ve yeniden kullanılabilirlik sağlayan güçlü özelliklerinden biridir. <strong>Lazy</strong>, <strong>observable</strong> ve <strong>map tabanlı değişkenler</strong> gibi mekanizmalar sayesinde kod tekrarını azaltarak daha modüler ve okunabilir bir yapı sunar. Ayrıca, <strong>provideDelegate</strong> operatörü ile başlatma ve doğrulama süreçleri kontrol edilebilir, böylece daha güvenilir ve sürdürülebilir bir kod tabanı oluşturulabilir. Kotlin’in sağladığı bu yetenekler, modern yazılım geliştirme süreçlerinde verimliliği artırarak, dili güçlü ve tercih edilebilir kılan önemli faktörler arasında yer almaktadır.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/delegated-properties.html">https://kotlinlang.org/docs/delegated-properties.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb445886ee61" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin-29 : Delegation]]></title>
            <link>https://medium.com/@cusufcan/kotlin-29-delegation-7ee938dd7e8c?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ee938dd7e8c</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Thu, 30 Jan 2025 10:12:43 GMT</pubDate>
            <atom:updated>2025-01-30T10:12:43.588Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-29 : Delegation</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, delegasyon kavramını detaylı bir şekilde ele alacak ve Kotlin’de nasıl uygulanacağını örneklerle açıklayacağım. Delegasyon, nesne yönelimli programlama dünyasında sıkça kullanılan bir tasarım deseni olup, özellikle <strong>kalıtım</strong> yerine tercih edildiğinde birçok avantaj sunar. Kotlin, bu <strong>design pattern</strong>’i kendiliğinden destekler ve geliştiricinin ekstra bir çaba harcamadan kullanmasına olanak tanır.</p><h3>Delegasyon Nedir?</h3><p>Delegasyon, bir sınıfın belirli sorumluluklarını başka bir nesneye “<strong>devretme</strong>” yöntemidir. Bu yöntem, özellikle sınıfların karmaşıklığını azaltmak, modülerliği artırmak ve daha esnek bir kod yapısı sağlamak amacıyla kullanılır. Kotlin’deki delegasyon özelliği, bir sınıfın bir interface’i implement ederken, o interface’in implementasyonunu başka bir nesneye devretmesini sağlar.</p><h3>Manuel Delegasyon (Manual Delegation)</h3><p>Kotlin’deki <strong>by</strong> anahtar kelimesi delegasyonu oldukça kolaylaştırır. Ancak, aynı işlemi elle kodlayarak da gerçekleştirebiliriz. Bu, delegasyonun nasıl çalıştığını daha iyi anlamak için faydalı olabilir. Aşağıda manuel delegasyonun bir örnek kodu verilmiştir:</p><pre>interface Base {<br>    fun printMessage()<br>    fun printMessageLine()<br>}<br><br>class BaseImpl(val x: Int) : Base {<br>    override fun printMessage() {<br>        println(x)<br>    }<br><br>    override fun printMessageLine() {<br>        println(x)<br>    }<br>}<br><br>class Derived(private val delegate: Base) : Base {<br>    override fun printMessage() {<br>        delegate.printMessage() // Delegasyonu manuel olarak yapıyoruz<br>    }<br><br>    override fun printMessageLine() {<br>        delegate.printMessageLine() // Tüm çağrılar temsilci nesneye iletiliyor<br>    }<br>}</pre><p>Bu örnekte:</p><ul><li><strong>Derived</strong> sınıfı <strong>Base</strong> interface’ini implement eder ve <strong>delegate</strong> adlı bir nesneye sahiptir.</li><li>Tüm interface metodlarının çağrıları, manuel olarak <strong>delegate</strong> nesnesine yönlendirilir.</li></ul><h3>Kotlin’de Delegasyonun Kullanımı</h3><p>Kotlin’de delegasyon, bir sınıfın bir interface’i implement ederken başka bir nesneye dayanarak bu implementasyonu gerçekleştirmesine olanak tanır:</p><pre>interface Base {<br>    fun print()<br>}<br><br>class BaseImpl(val x: Int) : Base {<br>    override fun print() {<br>        println(x)<br>    }<br>}<br><br>class Derived(b: Base) : Base by b</pre><p>Yukarıdaki örnekte:</p><ul><li>Base bir interface’tir.</li><li><strong>BaseImpl</strong>, <strong>Base</strong> interface’ini implement eder ve bir değişkeni <strong>(x)</strong> basitçe yazdırır.</li><li><strong>Derived</strong> sınıfı ise, <strong>Base</strong> interface’ini implement eder ancak bu implementasyonu <strong>BaseImpl</strong> nesnesine devreder. <strong>Base by b</strong> ifadesi tam olarak bu delegasyonu ifade eder.</li></ul><h3>Overriding</h3><p>Delegasyon kullanırken, temsil edilen nesnenin (delegate object) metotlarının override edilmesi mümkündür. Bu durumda Kotlin derleyicisi, önceliği sizin yazdığınız metotlara verir:</p><pre>interface Base {<br>    fun printMessage()<br>    fun printMessageLine()<br>}<br><br>class BaseImpl(val x: Int) : Base {<br>    override fun printMessage() {<br>        println(x)<br>    }<br><br>    override fun printMessageLine() {<br>        println(x)<br>    }<br>}<br><br>class Derived(b: Base) : Base by b {<br>    override fun printMessage() {<br>        println(&quot;abc&quot;)<br>    }<br>}</pre><p>Bu kodun çalışması sırasında:</p><ul><li><strong>printMessage()</strong> çağrıldığında <strong>Derived</strong> sınıfındaki override metodu (<strong>override fun printMessage()</strong>) çalışır ve <strong>abc</strong> yazdırılır.</li><li><strong>printMessageLine()</strong> ise herhangi bir override işlemine uğramadığı için doğrudan <strong>BaseImpl</strong> nesnesinin metodunu çağırır ve <strong>x</strong> değerini yazdırır.</li></ul><h3>Delegate Object Üzerinden Üyelere Erişim</h3><p>Delegasyon kullanırken dikkat edilmesi gereken önemli bir nokta, override edilen üyelerin delegate object’inin içinden doğrudan erişilememesidir:</p><pre>interface Base {<br>    val message: String<br>    fun print()<br>}<br><br>class BaseImpl(x: Int) : Base {<br>    override val message = &quot;BaseImpl: x = $x&quot;<br><br>    override fun print() {<br>        println(message)<br>    }<br>}<br><br>class Derived(b: Base) : Base by b {<br>    override val message = &quot;Message of Derived&quot;<br>}</pre><p>Burada <strong>BaseImpl</strong> sınıfında <strong>message</strong> değişkeni <strong>delegate object’e (BaseImpl)</strong> aittir. Ancak <strong>Derived</strong> sınıfı bu değişkeni override eder. <strong>Derived</strong>’ın içindeki <strong>print()</strong> metodunu çağırdığınızda, <strong>BaseImpl</strong> sınıfındaki orijinal <strong>message</strong> değeri kullanılır. Bunun sebebi, delegate object’in kendi üyelerine (<strong>BaseImpl.message</strong>) erişim sağlamasıdır.</p><p>Çıktı şu şekilde olacaktır:</p><pre>BaseImpl: x = 10<br>Message of Derived</pre><h3>Delegasyonun Avantajları</h3><ul><li><strong>Kalıtıma Alternatif:</strong> Delegasyon, sınıflar arasında sıkı bir hiyerarşi oluşturmadan işlevselliği paylaşmayı mümkün kılar. Bu da daha az karmaşık ve daha esnek bir yapı sağlar.</li><li><strong>Kod Tekrarını Azaltır:</strong> Bir sınıf, birden fazla interface’in sorumluluğunu kolayca devralabilir ve bunları farklı nesnelere devredebilir.</li><li><strong>Modülerlik:</strong> Delegasyon, sistemin parçalarını ayrı tutmayı ve gerektiğinde kolayca değiştirmeyi mümkün kılar.</li></ul><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, delegasyonun ne olduğunu, Kotlin’deki kullanımını ve avantajlarını örneklerle açıkladım. Delegasyon, özellikle karmaşık kalıtım hiyerarşilerinden kaçınmak ve daha esnek bir kod yapısı oluşturmak için harika bir yöntemdir. Kotlin, bu design pattern’i kendiliğinden destekleyerek geliştiricilerin işini kolaylaştırır.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/delegation.html">https://kotlinlang.org/docs/delegation.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ee938dd7e8c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin-28 : Object Declarations & Expressions]]></title>
            <link>https://medium.com/@cusufcan/kotlin-28-object-declarations-expressions-b29757345211?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/b29757345211</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Wed, 29 Jan 2025 10:37:07 GMT</pubDate>
            <atom:updated>2025-01-29T10:37:07.355Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-28 : Object Declarations &amp; Expressions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, object declarations &amp; expressions kavramlarının nasıl çalıştığını, kullanıldıkları durumları ve aralarındaki farkları derinlemesine inceleyeceğim. Kotlin, nesne tabanlı programlamayı destekleyen ve esnek bir dil olduğundan, nesnelerle çalışma farklı yollarla mümkündür.</p><h3>1. Object Declarations</h3><p>Kotlin’de <strong>object declarations</strong>, belirli bir sınıfın <strong>tek bir örneğini (singleton)</strong> tanımlamanızı sağlar. Bu özellik, <strong>singleton design pattern</strong>’e uygun nesneleri kolayca oluşturmanızı mümkün kılar.</p><p>Bir <strong>object declaration</strong>, <strong>object</strong> anahtar kelimesi ile başlar ve o nesnenin bir sınıf tanımını içerir. Bu object declaration, ilk kez erişildiğinde başlatılır ve sonraki erişimlerde aynı nesne örneği kullanılır. Bu da, nesnenin yalnızca bir kez başlatılmasını ve hafızada yalnızca bir kopyasının bulunmasını sağlar.</p><h4>Nasıl Çalışır?</h4><p>Object declaration, yalnızca bir kez oluşturulacak nesneler için idealdir. Örneğin, bir veritabanı bağlantısının veya bir yapılandırma yöneticisinin yalnızca bir örneği olması gerektiğinde, object declaration kullanmak mantıklıdır. Kotlin’deki object declaration <strong>tembel başlatma (Lazy Initialization)</strong> özelliğine sahiptir, yani nesne yalnızca ilk kez kullanıldığında başlatılır:</p><pre>object DatabaseConnection {<br>    val connection = &quot;Bağlantı Açıldı&quot;<br>    <br>    fun connect() {<br>        println(&quot;Veritabanına bağlanılıyor...&quot;)<br>    }<br>    <br>    fun disconnect() {<br>        println(&quot;Veritabanı bağlantısı kapatıldı.&quot;)<br>    }<br>}</pre><p>Yukarıdaki örnekte, <strong>DatabaseConnection</strong> nesnesi yalnızca bir kez başlatılacak ve tüm uygulama süresi boyunca bu nesne kullanılacaktır. <strong>Object declaration</strong> sayesinde nesne, ilk kez erişildiğinde başlatılır ve sonraki erişimler aynı nesne örneğini döndürür.</p><h4>Miras Alma</h4><p>Kotlin’deki object declaration sadece tekil nesneler oluşturmakla kalmaz, aynı zamanda object declarations’ı class veya interface’lerden türetebilir, miras alabilir. Bu, object declaration’ın davranışını daha esnek hale getirir:</p><pre>open class Animal {<br>    open fun sound() = &quot;Ses yok&quot;<br>}<br><br>object Dog : Animal() {<br>    override fun sound() = &quot;Hav hav&quot;<br>}</pre><p>Bu örnekte, Dog nesnesi Animal sınıfından miras almakta ve sound() fonksiyonunu override etmektedir. Dog nesnesi yalnızca bir kez oluşturulacak ve her yerde aynı nesne kullanılarak sound() fonksiyonu çağrılacaktır.</p><p><strong>Kısıtlamaları</strong></p><ul><li><strong>Yerel Olamazlar</strong>: Object declarations, fonksiyonlar içinde yerel olarak tanımlanamazlar. Sadece <strong>üst düzeyde (class dışı)</strong> veya başka bir nesne içinde tanımlanabilirler.</li><li><strong>Kopyalama Yapılamaz</strong>: Object declarations’ın kopyalanması mümkün değildir. Çünkü yalnızca bir örneği olmalıdır.</li></ul><h3>2. Object Expressions</h3><p>Object expressions, genellikle bir sınıfın bir örneğini oluşturup hemen kullanmak için tercih edilen yapılardır. Object expressions, anonim sınıflar oluşturmanıza olanak tanır. Yani, bir nesneyi tanımlarken herhangi bir isim belirtmeden, sadece kullanılacak olan sınıf veya arayüzü belirleyebilirsiniz. Bu, daha esnek ve geçici nesne oluşturma durumları için faydalıdır.</p><h4>Nasıl Çalışır?</h4><p>Object expressions, bir sınıfın bir örneğini tanımladığınızda, sınıfın tüm işlevlerini içeren bir nesne oluşturmanızı sağlar. Bu sınıf doğrudan bir anonim sınıf olarak tanımlanır.</p><pre>val greeting = object {<br>    val message = &quot;Merhaba, Kotlin!&quot;<br>    <br>    fun greet() {<br>        println(message)<br>    }<br>}<br><br>greeting.greet() // Merhaba, Kotlin!</pre><p>Burada, greeting adında anonim bir nesne oluşturulmuştur. Bu nesne, yalnızca bir kez kullanılır ve doğrudan anonim bir sınıf olarak tanımlanır. Bu tür nesneler, yalnızca geçici kullanım senaryoları için uygundur.</p><h4><strong>Object Expressions &amp; Anonymous Classes</strong></h4><p>Object expressions ile anonim sınıflar oluşturabilirsiniz. Kotlin, anonim sınıfları daha basitleştirir, çünkü yeni bir sınıf adı tanımlamanıza gerek yoktur. Yalnızca sınıfın işlevselliklerini belirtirsiniz:</p><pre>val printer = object : Printer {<br>    override fun print() {<br>        println(&quot;Yazdırma işlemi tamamlandı.&quot;)<br>    }<br>}<br><br>printer.print() // Yazdırma işlemi tamamlandı.</pre><p>Burada, <strong>Printer</strong> interface’i için bir anonim sınıf tanımlanmıştır ve <strong>print()</strong> fonksiyonu override edilmiştir. <strong>printer</strong> nesnesi anonim bir nesne olarak oluşturulmuş ve hemen kullanılmıştır.</p><h4>Miras Alma</h4><p>Bir sınıfı genişletmek için object expressions kullanılabilir. Bu, miras alarak yeni işlevsellik eklemek için idealdir. Örneğin, bir sınıfın metotlarını override edebilir ve üzerine yeni işlevsellikler ekleyebilirsiniz:</p><pre>open class Animal {<br>    open fun sound() = &quot;Ses yok&quot;<br>}<br><br>val cat = object : Animal() {<br>    override fun sound() = &quot;Miyav&quot;<br>}</pre><p>Burada, <strong>cat</strong> nesnesi anonim bir sınıf olarak tanımlanmıştır ve <strong>Animal</strong> sınıfından miras alınarak <strong>sound()</strong> metodu özelleştirilmiştir.</p><h3>Object Declarations vs Object Expressions</h3><p>Kotlin’deki object declarations ve object expressions benzer işlevlere sahip olsalar da, bazı önemli farkları vardır:</p><h4><strong>Başlatılma Zamanı</strong></h4><ul><li><strong>Object Declarations:</strong> Yalnızca ilk erişildiğinde başlatılır. Bu <strong>tembel başlatma (lazy initialization)</strong> özelliği sağlar.</li><li><strong>Object Expressions:</strong> Doğrudan tanımlandığı anda başlatılır.</li></ul><h4><strong>Kullanım Amacı</strong></h4><ul><li><strong>Object Declarations:</strong> Genellikle, bir sınıfın yalnızca bir örneği olması gerektiğinde <strong>(singleton)</strong> kullanılır. <strong>object</strong> anahtar kelimesiyle tanımlanan sınıf, tek bir örneğe sahiptir.</li><li><strong>Object Expressions:</strong> Genellikle, bir class veya interface’in tek bir geçici örneğini oluşturmak için kullanılır. Anonim sınıflar yaratmak için idealdir.</li></ul><h4><strong>Miras Alma ve Özelleştirme</strong></h4><ul><li><strong>Object Declarations:</strong> Class veya interface’ten miras alabilir ve işlevselliklerini özelleştirebilir.</li><li><strong>Object Expressions:</strong> Class veya interface’ten miras alabilir, ancak anonim nesneler olduğundan sınıf adı verilemez.</li></ul><h4>Kopyalama</h4><ul><li><strong>Object Declarations:</strong> Kopyalanamaz çünkü yalnızca bir örnek olmalıdır.</li><li><strong>Object Expressions:</strong> Kopyalanamazlar çünkü her nesne yalnızca bir kez kullanılacaktır.</li></ul><h3><strong>Data &amp; Companion Objects</strong></h3><p>Kotlin’de <strong>data objects</strong> ve <strong>companion objects</strong> gibi ek özellikler de bulunmaktadır.</p><h4>Data Objects</h4><p>Data Objects, genellikle <strong>data</strong> anahtar kelimesi ile tanımlanır ve veri taşıyan nesneler için özel olarak tasarlanmıştır. Bu nesneler, <strong>toString()</strong>, <strong>equals()</strong> ve <strong>hashCode()</strong> gibi temel işlevleri otomatik olarak sağlar.</p><h4>Companion Objects</h4><p>Companion Objects, sınıfın işlevsel veya yardımcı metodlarını tutmak için kullanılır. Bu nesneler, sınıf ile ilişkilendirilir ve sınıfın örneği oluşturulmadan erişilebilir. Java’daki <strong>static</strong> kavramı ile benzerdir.</p><pre>class MyClass {<br>    companion object Factory {<br>        fun create() = MyClass()<br>    }<br>}</pre><p>Bu örnekte, <strong>Factory</strong> adlı companion object, <strong>MyClass</strong> sınıfının örneğini oluşturmak için bir metot sağlar.</p><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, Kotlin’deki <strong>object declarations</strong> ve <strong>companion objects </strong>kavramlarının yazılım geliştirmeye nasıl katkı sağladığını inceledim. Kotlin’deki nesneler, nesne tabanlı programlamayı modern bir şekilde destekler. <strong>Object Declarations</strong> ve <strong>Object Expressions</strong>, <strong>sınıflar</strong>, <strong>anonim sınıflar</strong>, <strong>companion objects</strong> gibi yapılar, geliştiricilere esnek ve temiz çözümler sunar. <strong>Singleton</strong> design pattern’ini kullanmak için <strong>object declarations</strong>, sınıf seviyesinde işlevsellik eklemek için <strong>companion objects</strong> ve geçici nesne oluşturmak için <strong>object expressions</strong>, Kotlin’de nesnelerle çalışırken en sık kullanılan tekniklerdendir.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/object-declarations.html">https://kotlinlang.org/docs/object-declarations.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b29757345211" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin-27 : Inline Value Classes]]></title>
            <link>https://medium.com/@cusufcan/kotlin-27-inline-value-classes-89743c711361?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/89743c711361</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Tue, 28 Jan 2025 08:33:49 GMT</pubDate>
            <atom:updated>2025-01-28T08:33:49.477Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-27 : Inline Value Classes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, satır içi sınıfların ne olduğu, nasıl kullanıldığı ve sağladığı faydalar hakkında bilgi vereceğim. Kotlin’de veri modelleme, tür güvenliğini artırma ve performansı optimize etme amacıyla çeşitli araçlar sunulmaktadır. Bunlardan biri de <strong>satır içi sınıflar (inline classes)</strong> olarak adlandırılır. Inline class’lar, özellikle altta yatan bir veri türünü sarmalamak ve bunu daha anlamlı hale getirmek istediğimiz durumlarda son derece yararlıdır. Ancak, bu işlem sırasında geleneksel sınıfların sebep olduğu stack allocations durumundan ve performans kaybından kaçınmak için özel bir şekilde optimize edilmişlerdir.</p><h3>Inline Classes Nedir?</h3><p>Inline classes, Kotlin dilinde performans kayıplarını önlemek amacıyla tasarlanmış, değer tabanlı özel sınıf türleridir. Bir <strong>inline class</strong>, yalnızca tek bir değişkeni tutabilir ve bu değişken, <strong>çalışma zamanında (runtime)</strong> sarmalayıcı nesne yerine doğrudan temsil edilir. Böylece JVM’de gereksiz stack allocations durumu engellenir.</p><p>Inline class tanımlamak için <strong>value</strong> anahtar kelimesi kullanılır:</p><pre>value class Password(private val s: String)</pre><h3>JVM Destekli Inline Classes</h3><p>Kotlin’in JVM üzerinde çalışan projelerinde, inline class’ların doğru şekilde çalışabilmesi için <strong>@JVMInline</strong> anotasyonu kullanılmalıdır:</p><pre>@JvmInline<br>value class Password(private val s: String)</pre><p>Inline class’lar, çalışma zamanında sadece tek bir değişkene sahip olabileceğinden, instance’ları yalnızca bu değişkenin değeri üzerinden temsil edilir:</p><pre>val securePassword = Password(&quot;mySecretPassword&quot;)</pre><p>Yukarıdaki örnekte, <strong>securePassword</strong> bir <strong>Password</strong> instance’ı gibi görünse de JVM bunu yalnızca bir <strong>String</strong> olarak temsil eder.</p><h3>Üyeler (Members)</h3><p>Inline classes, normal sınıfların birçok özelliğini destekler:</p><ul><li>Değişkenler ve fonksiyonlar tanımlanabilir.</li><li><strong>init</strong> blokları kullanılabilir.</li><li>İkincil kurucular (secondary constructors) desteklenir.</li></ul><pre>@JvmInline<br>value class Person(private val fullName: String) {<br>    init {<br>        require(fullName.isNotEmpty()) { &quot;Full name shouldn&#39;t be empty&quot; }<br>    }<br><br>    constructor(firstName: String, lastName: String) : this(&quot;$firstName $lastName&quot;) {<br>        require(lastName.isNotBlank()) { &quot;Last name shouldn&#39;t be empty&quot; }<br>    }<br><br>    val length: Int<br>        get() = fullName.length<br><br>    fun greet() {<br>        println(&quot;Hello, $fullName&quot;)<br>    }<br>}</pre><p>Yukarıdaki örnekte, <strong>Person</strong> sınıfı bir <strong>String</strong> özelliği sarmalamaktadır. Ancak, sınıf aynı zamanda bir <strong>init</strong> bloğu, bir <strong>secondary constructor</strong> ve değişken fonksiyonları da barındırmaktadır.</p><h4>Kısıtlamalar</h4><ul><li>Inline class’ların değişkenleri, <strong>destek alanlarına (backing field)</strong> sahip olamaz. Yalnızca basit hesaplanabilir değişkenlere izin verilir.</li><li><strong>lateinit</strong> veya delege edilmiş değişkenler desteklenmez.</li></ul><h3>Kalıtım (Inheritance)</h3><p>Inline classes, sınıf hiyerarşisinde yer alamaz ve başka sınıfları genişletemez. Ancak, <strong>interface implement</strong> edebilirler:</p><pre>interface Printable {<br>    fun prettyPrint(): String<br>}<br><br>@JvmInline<br>value class Name(val s: String) : Printable {<br>    override fun prettyPrint(): String = &quot;Let&#39;s $s!&quot;<br>}</pre><p>Bu örnekte <strong>Name</strong> sınıfı, <strong>Printable</strong> interface’inden miras alarak <strong>prettyPrint</strong> metodunu override etmektedir. Ancak, <strong>Name</strong> başka bir sınıfı genişletemez.</p><h3>Temsil (Representation)</h3><p>Inline class’ların çalışma zamanı temsili, iki farklı şekilde gerçekleşebilir:</p><ul><li><strong>Altta yatan tür (Underlying Type):</strong> Performansı artırmak için genellikle kullanılır.</li><li><strong>Sarmalayıcı (Wrapper):</strong> Bazı durumlarda gereklidir.</li></ul><p>Aşağıdaki senaryolarda inline class <strong>kutulanır (boxed)</strong>:</p><ul><li>Generic olarak kullanıldığında.</li><li>Bir interface türüne atandığında.</li><li>Nullable (T?) bir tür olarak temsil edildiğinde.</li></ul><pre>@JvmInline<br>value class Foo(val i: Int)<br><br>fun asInline(f: Foo) {} // Unboxed<br>fun &lt;T&gt; asGeneric(x: T) {} // Boxed<br>fun asInterface(i: Any) {} // Boxed<br>fun asNullable(i: Foo?) {} // Boxed</pre><h3>Referans Eşitliği</h3><p>Inline class’lar referans eşitliği kullanamaz, çünkü çalışma zamanında bir nesneye referans yerine altta yatan değerle temsil edilir.</p><h3>Inline Classes vs Type Aliases</h3><p>Inline classes, type aliases’a benzese de temel bir ffark vardır:</p><ul><li><strong>Type aliases</strong> yalnızca mevcut bir türe alternatif bir ad sağlar ve <strong>atama uyumlu (assignment compatible)</strong> kalır.</li><li><strong>Inline classes</strong>, gerçekten yeni bir tür oluşturur ve altta yatan türle uyumlu değildir.</li></ul><pre>typealias NameAlias = String<br><br>@JvmInline<br>value class NameInlineClass(val s: String)<br><br>fun acceptString(s: String) {}<br>fun acceptNameInlineClass(p: NameInlineClass) {}<br><br>val alias: NameAlias = &quot;&quot;<br>val inlineClass = NameInlineClass(&quot;&quot;)<br><br>acceptString(alias) // Geçerli<br>acceptString(inlineClass) // Geçersiz</pre><h3>Delegasyon (Delegation)</h3><p>Inline classes, değerlerine <strong>yetki (delegation)</strong> yoluyla interface implementation’u destekler:</p><pre>interface MyInterface {<br>    fun bar()<br>    fun foo() = &quot;foo&quot;<br>}<br><br>@JvmInline<br>value class MyInterfaceWrapper(val myInterface: MyInterface) : MyInterface by myInterface</pre><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, Kotlin’deki inline class tanımını, kullanımını ve önemli özelliklerini örneklerle açıkladım. Kotlin’in inline class’ları, performans kaygılarını göz önünde bulundurarak tasarlanmış güçlü bir araçtır. Bu sınıflar, hem tür güvenliğini artırır hem de optimize edilmiş çalışma zamanı davranışlarıyla stack allocations durumunu azaltır. Ancak, bu özellikleri kullanırken sınırlamalarını ve <strong>kutulama (boxed)</strong> gibi durumları dikkate almak önemlidir. Bu dengeyi kurarak hem performansı hem de kodun okunabiliriğini artırabilirsiniz.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/inline-classes.html">https://kotlinlang.org/docs/inline-classes.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=89743c711361" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin-26 : Enum Classes]]></title>
            <link>https://medium.com/@cusufcan/kotlin-26-enum-classes-512d23a11f13?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/512d23a11f13</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Mon, 27 Jan 2025 09:05:51 GMT</pubDate>
            <atom:updated>2025-01-27T09:05:51.706Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-26 : Enum Classes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, enum sınıflarının kullanımı ve avantajlarına dair önemli noktaları ele alacağım. Kotlin programlama dilinde, <strong>enum sınıfları</strong>, sabit değerlerden oluşan bir türü temsil etmek için kullanılır. Bu türler, yazılım geliştirme sırasında <strong>tür güvenliğini (type safety)</strong> sağlamak, daha okunabilir kod yazmak ve kodun bakımını kolaylaştırmak için oldukça önemlidir.</p><h3>Enum Sınıflarının Temel Kullanımı</h3><p>Bir enum sınıfı, sabitleri listelemek için aşağıdaki gibi tanımlanabilir:</p><pre>enum class Direction {<br>    NORTH, SOUTH, WEST, EAST<br>}</pre><p>Bu tanımda, <strong>Direction</strong> isimli bir enum sınıfı tanımlanmış ve dört sabit içermektedir: <strong>NORTH</strong>, <strong>SOUTH</strong>, <strong>WEST</strong>, ve <strong>EAST</strong>. Burada her bir sabit, <strong>Direction</strong> sınıfının bir nesnesi gibi değerlendirilebilir.</p><h3>Enum Sabitlerinin Özellikleri</h3><p>Enum sabitleri bir nesne olduğundan, bu sabitler ilave değişkenlere ve metotlara sahip olabilir:</p><pre>enum class Color(val rgb: Int) {<br>    RED(0xFF0000),<br>    GREEN(0x00FF00),<br>    BLUE(0x0000FF)<br>}</pre><p>Bu örnekte, her sabit, enum sınıfının bir nesnesidir. <strong>Color</strong> sınıfı her bir renk için <strong>rgb</strong> değerini alır ve saklar.</p><h3>Anonim Sınıflar ile Çalışma</h3><p>Enum sabitleri, anonim sınıflar tanımlayarak ilgili metotları override edebilir:</p><pre>enum class ProtocolState {<br>    WAITING {<br>        override fun signal() = TALKING<br>    },<br>    TALKING {<br>        override fun signal() = WAITING<br>    };<br><br>    abstract fun signal(): ProtocolState<br>}</pre><p>Bu örnekte, <strong>ProtocolState</strong> sınıfı iki sabit içerir: <strong>WAITING</strong> ve <strong>TALKING</strong>. Her sabit, <strong>signal</strong> metodunu kendine özgü şekilde override eder. <strong>Anonim sınıflar</strong>, her sabitin özelleştirilmesine olanak tanır.</p><h4>Üyeler ve Sabitlerin Ayrımı</h4><p>Bir enum sınıfı, hem üyeler hem de sabitler içeriyorsa, sabitlerin sonuna <strong>noktalı virgül (;)</strong> koyarak bu iki grubu ayırmalıyız.</p><h3>Enum Sınıflarında Interface</h3><p>Enum sınıfları, bir interface implement edebilir. Ayrıca her sabit, interface’in metotlarını kendine özgü bir şekilde override edebilir:</p><pre>enum class IntArithmetics : BinaryOperator&lt;Int&gt;, IntBinaryOperator {<br>    PLUS {<br>        override fun apply(t: Int, u: Int): Int = t + u<br>    },<br>    TIMES {<br>        override fun apply(t: Int, u: Int): Int = t * u<br>    };<br><br>    override fun applyAsInt(t: Int, u: Int): Int = apply(t, u)<br>}</pre><p>Bu örnekte, <strong>IntArithmetics</strong>, iki interface implement eder: <strong>BinaryOperator&lt;Int&gt;</strong> ve <strong>IntBinaryOperator</strong>. Her sabit (<strong>PLUS</strong> ve <strong>TIMES</strong>), <strong>apply</strong> metodunu farklı bir şekilde override etmiştir.</p><h3>Enum Sabitlerinin Karşılaştırılması</h3><p>Kotlin’de tüm enum sınıfları varsayılan olarak <strong>Comparable</strong> interface’ini implement eder. Enum sabitleri, sınıf tanımında sıralandıkları doğal sıraya göre sıralanır.</p><h3>Enum Sabitleriyle Çalışma</h3><p>Kotlin, enum sabitlerini listelemek ve bunlara isimleri ile erişmek için çeşitli yöntemler sunar:</p><h4>Adına Göre Erişim</h4><p>Aşağıdaki gibi <strong>valueOf</strong> metodu kullanılabilir:</p><pre>println(Color.valueOf(&quot;RED&quot;)) // Çıktı: RED<br>// Sabit bulunamazsa, IllegalArgumentException fırlatılır.</pre><h4>Tüm Sabitleri Listeleme</h4><p>Kotlin, enum sabitlerini listelemek için iki yöntem sağlar:</p><ul><li><strong>entries</strong> özelliği</li><li>(eski) <strong>values()</strong> fonksiyonu</li></ul><pre>enum class RGB { RED, GREEN, BLUE }<br><br>for (color in RGB.entries) {<br>    println(color) // Çıktı: RED, GREEN, BLUE<br>}</pre><h4>Genel Fonksiyonlar ile Erişim</h4><p>Enum sabitlerine <strong>tür güvenli (type safe)</strong> bir şekilde erişmek için <strong>enumEntries</strong> ve <strong>enumValueOf</strong> fonksiyonlarını kullanabilirsiniz:</p><pre>inline fun &lt;reified T : Enum&lt;T&gt;&gt; foo() {<br>    println(enumEntries&lt;T&gt;().joinToString { it.name })<br>}<br><br>foo&lt;RGB&gt;() // Çıktı: RED, GREEN, BLUE</pre><h3>Enum Sabitlerinin Özellikleri</h3><p>Her enum sabitinin iki önemli özelliği vardır:</p><ul><li><strong>name</strong>: Sabitin adını döndürür.</li><li><strong>ordinal</strong>: Sabitin enum sınıfındaki sırasını döndürür (0&#39;dan başlar).</li></ul><pre>println(RGB.RED.name) // Çıktı: RED<br>println(RGB.RED.ordinal) // Çıktı: 0</pre><h3>Performans İyileştirmeleri (Kotlin 2.0.0)</h3><p><strong>Kotlin 2.0.0</strong> ile birlikte, enum sabitlerine erişim daha verimli hale getirilmiştir. <strong>enumEntries</strong> fonksiyonu, sabitlerin listesini her çağrıldığında aynı nesneyi döndürür. Bu, performans açısından <strong>enumValues</strong> fonksiyonundan daha iyidir.</p><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, Kotlin’deki enum sınıflarının temel kullanımı, sabit özellikleri, interface implementation ve performans odaklı geliştirmeler gibi önemli konuları ele aldım. Enum sınıfları, tür güvenliğini sağlamak ve daha okunabilir kod yazmak için mükemmel bir araçtır. Anonim sınıflarla, interface implementation’larıyla ve modern Kotlin sürümleriyle gelen yeni özelliklerle enumların gücü artmıştır. Özellikle performans odaklı <strong>enumEntries</strong> fonksiyonunu kullanarak, modern Kotlin kodlarında daha verimli enum yapıları oluşturabilirsiniz.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/enum-classes.html">https://kotlinlang.org/docs/enum-classes.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=512d23a11f13" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin-25 : Nested & Inner Classes]]></title>
            <link>https://medium.com/@cusufcan/kotlin-25-nested-inner-classes-20e324df0f45?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/20e324df0f45</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Tue, 14 Jan 2025 14:17:13 GMT</pubDate>
            <atom:updated>2025-01-14T14:17:13.751Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-25 : Nested &amp; Inner Classes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, Kotlin’deki nested classes, inner classes, anonymous inner classes ve interface’lerle olan etkileşimlerini ele alacağım. Kotlin, programlamada sınıfların birbirlerine nasıl iç içe yerleştirilebileceği konusunda oldukça esneklik sağlar. Bir sınıf, başka bir sınıfın içinde tanımlanabilir ve buna <strong>iç içe sınıflar (nested classes)</strong> denir. Bu özellik, kodun düzenlenmesini kolaylaştırabilir ve belirli işlevsellikleri birbirine yakın tutarak daha temiz ve anlaşılır bir yapı oluşturabilir. Kotlin’de iç içe sınıfların yanı sıra <strong>iç sınıflar (inner classes)</strong> ve <strong>anonim iç sınıflar (anonymous inner classes)</strong> gibi çeşitli kavramlar da bulunur.</p><h3>Nested Classes</h3><p>Kotlin’de bir sınıf, başka bir sınıfın içinde tanımlanabilir. Bu sınıfa nested class denir. Nested class’lar, dış sınıfın üyelerine erişim sağlayamazlar. Yani, iç sınıflar dış sınıfın nesne üyelerine doğrudan erişim iznine sahip değildir. Ancak, genellikle bağımsız sınıflar olarak işlev görürler ve dış sınıfın sadece yapısını temsil ederler:</p><pre>class Outer {<br>    private val bar: Int = 1<br><br>    class Nested {<br>        fun foo() = 2<br>    }<br>}<br><br>val demo = Outer.Nested().foo() // == 2</pre><p>Burada, <strong>Outer</strong> sınıfı içinde tanımlanan <strong>Nested</strong> sınıfı, dış sınıfın üyelerine erişim sağlamadan kendi içinde bağımsız bir işlevsellik sunmaktadır. <strong>Nested</strong> sınıfı doğrudan <strong>Outer</strong> sınıfının nesnesi olmadan da kullanılabilir.</p><h3>Nested Classes With Interfaces</h3><p>Kotlin’deki nested class’lar sadece sınıflarla sınırlı değildir. Interface’ler de iç içe yerleştirilebilir. Kotlin, class’ların ve interface’lerin birbirlerine yerleştirilebileceği esnek bir yapıya sahiptir. Bu kombinasyonları istediğiniz gibi değiştirebilirsiniz:</p><pre>interface OuterInterface {<br>    class InnerClass<br>    interface InnerInterface<br>}<br><br>class OuterClass {<br>    class InnerClass<br>    interface InnerInterface<br>}</pre><p>Burada, <strong>OuterInterface</strong> interface’i içinde bir <strong>InnerClass </strong>sınıfı ve bir <strong>InnerInterface</strong> interface’i tanımlanmıştır. Aynı şekilde, <strong>OuterClass</strong> sınıfı içinde de benzer yapılar oluşturulmuştur.</p><h3>Inner Classes</h3><p>Kotlin’deki inner class’lar, dış sınıfının nesnesine erişim sağlayabilen sınıflardır. Inner class’lar, dış sınıfın bir nesnesine referans taşır, bu da onlara dış sınıfın üye değişkenlerine ve fonksiyonlarına erişim sağlar. <strong>inner</strong> anahtar kelimesi, bir sınıfın inner class olduğunu belirtir. Inner class, dış sınıfın nesnesiyle ilişkilidir ve dış sınıfın üye değişkenlerine doğrudan erişebilir:</p><pre>class Outer {<br>    private val bar: Int = 1<br><br>    inner class Inner {<br>        fun foo() = bar<br>    }<br>}<br><br>val demo = Outer().Inner().foo() // == 1</pre><p>Burada, <strong>Outer</strong> sınıfının içinde tanımlanan <strong>Inner</strong> sınıfı, dış sınıfın <strong>bar</strong> değişkenine erişim sağlar çünkü <strong>Inner</strong> sınıfı bir <strong>inner class</strong> olarak <strong>inner</strong> anahtar kelimesiyle tanımlanmıştır.</p><h3>Anonymous Inner Classes</h3><p><strong>Anonymous inner class</strong>’lar, genellikle tek bir kullanım amacıyla oluşturulan <strong>kullan at</strong> sınıflardır. Bu tür sınıflar, genellikle interface’leri veya abstract sınıfları uygulamak için kullanılır. Anonymous inner class’lar, bir <strong>nesne ifadesi (object expression)</strong> kullanılarak oluşturulur. Bu sınıflar, adlandırılmamışlardır ve genellikle belirli bir işlevi yerine getiren kısa sınıf tanımlamalarıdır:</p><pre>windows.addMouseListener(object : MouseAdapter() {<br>    override fun mouseClicked(e: MouseEvent) { /*...*/ }<br>    override fun mouseEntered(e: MouseEvent) { /*...*/ }<br>})</pre><p>Burada, <strong>MouseAdapter</strong> sınıfının bir anonymous inner class’ı oluşturulmuştur. <strong>MouseAdapter</strong> sınıfının <strong>mouseClicked</strong> ve <strong>mouseEntered</strong> gibi fonksiyonları, anonymous inner class içinde doğrudan implement edilmiştir.</p><h3>Lambda Expressions &amp; Anonymous Inner Classes</h3><p>Kotlin, Java’dan miras aldığı fonksiyonel programlama özelliklerini de destekler. Eğer anonymous inner class bir <strong>Java interface</strong>’i ise ve bu interface yalnızca tek bir abstract metoda sahipse, bu tür bir interface’in nesnesini oluşturmak için <strong>lambda ifadeleri</strong> kullanılabilir. Bu, anonymous inner class’ların daha kısa ve okunabilir olmasını sağlar:</p><pre>val listener = ActionListener { println(&quot;clicked&quot;) }</pre><p>Burada, <strong>ActionListener</strong> interface’i, tek bir abstract metoda sahiptir (yani <strong>actionPerformed</strong>), bu nedenle <strong>ActionListener</strong> interface’inin nesnesi lambda ifadesiyle kolayca oluşturulabilir.</p><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, Kotlin’deki nested classes, inner classes ve anonymous inner classes’ın nasıl kullanıldığını ve birbirleriyle nasıl etkileşimde bulunduklarını açıkladım. Kotlin’de bu yapılar, kodunuzu daha esnek, düzenli ve okunabilir hale getirebilir. Kotlin’in sunduğu bu özellikler sayesinde, nesne yönelimli programlama anlayışını daha verimli bir şekilde kullanabiliriz. İster büyük projelerde, ister küçük uygulamalarda olsun, Kotlin’in bu esnek yapıları, yazılım geliştirmede işinizi kolaylaştırabilir.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/nested-classes.html">https://kotlinlang.org/docs/nested-classes.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=20e324df0f45" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin-24 : Generics]]></title>
            <link>https://medium.com/@cusufcan/kotlin-24-generics-2f2f1ca7224c?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/2f2f1ca7224c</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Sun, 12 Jan 2025 10:11:58 GMT</pubDate>
            <atom:updated>2025-01-12T10:11:58.885Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-24 : Generics</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, Kotlin’de generics kavramını açıklayarak, tip parametreleri ve varyasyonlarıyla nasıl çalışıldığını örneklerle inceleyeceğim. Kotlin’deki sınıflar, tıpkı Java’daki gibi tip parametrelerine sahip olabilir. Bu, kodunuzu daha esnek ve yeniden kullanılabilir hale getirir.</p><h3><strong>Generics ile Sınıf Tanımlama</strong></h3><p>Bir sınıfı generics ile tanımlamak için aşağıdaki gibi tip parametreleri kullanabilirsiniz:</p><pre>class Box&lt;T&gt;(t: T) {<br>    var value = t<br>}</pre><p>Bu sınıfın bir nesnesini oluşturmak için aşağıdaki şekilde bir tip argümanı sağlamalısınız:</p><pre>val box: Box&lt;Int&gt; = Box(1)</pre><p>Eğer tip parametresi, constructor argümanlarından çıkarılabiliyorsa, tip argümanlarını yazmanıza gerek yoktur:</p><pre>val box = Box(1) // Tip otomatik olarak bilinir. (Int)</pre><h3>Variance</h3><p>Kotlin, Java’daki <strong>wildcard</strong> yapılarının yerine daha açık ve anlaşılır olan <strong>declaration-site variance (in, out)</strong> ve <strong>type projections</strong> mekanizmalarını sunar.</p><h4>Variance &amp; Java’daki Wildcards</h4><p>Java’da genel tipler değişmezdir. Örneğin, List&lt;String&gt; ve List&lt;Object&gt; birbiriyle ilişkili değildir. Bu tasarım, <strong>çalışma zamanı hatalarını (runtime error)</strong> önlemek için getirilmiştir. Ancak bu, bazen türlerin uyumsuzluğu gibi sorunlara yol açabilir:</p><pre>// Java&#39;da<br>List&lt;String&gt; strs = new ArrayList&lt;&gt;();<br>List&lt;Object&gt; objs = strs; // DERLEME HATASI</pre><p>Java’da bu tür sorunları çözmek için <strong>(? extends)</strong> ve <strong>(? super)</strong> wildcard’ları kullanılır:</p><pre>interface Collection&lt;E&gt; {<br>    void addAll(Collection&lt;? extends E&gt; items);<br>}</pre><p>Bu, <strong>Collection&lt;? extends E&gt;</strong>’nin E veya onun alt türlerinden oluşabileceğini belirtir. <strong>Kotlin’de bu tür kullanım out ve in ile çözülür.</strong></p><h4><strong>Kotlin’de Declaration-Site Variance</strong></h4><p>Kotlin’de tip parametresini, <strong>in</strong> veya <strong>out</strong> anahtar kelimeleri ile <strong>declaration-site variance</strong> kullanarak tanımlayabilirsiniz.</p><p><strong>Out:</strong> Bir tip parametresi yalnızca döndürüldüğünde kullanılacaksa, yani <strong>bir alt tip, üst bir tipe eşitlenecekse</strong> <strong>(out)</strong> anahtar kelimesini kullanabilirsiniz:</p><pre>interface Source&lt;out T&gt; {<br>    fun next(): T<br>}<br><br>fun demo(strs: Source&lt;String&gt;) {<br>    val objects: Source&lt;Any&gt; = strs // Güvenli çünkü T &#39;out&#39; olarak tanımlı.<br>}</pre><p><strong>out,</strong> tipin yalnızca üretici olarak kullanıldığını garanti eder ve bu nedenle <strong>covariance</strong> sağlar.</p><p><strong>In:</strong> Eğer bir tip parametresi yalnızca türetilecekse, yani <strong>bir üst tip, alt bir tipe eşitlenecekse (in)</strong> kullanabilirsiniz:</p><pre>interface Comparable&lt;in T&gt; {<br>    fun compareTo(other: T): Int<br>}<br><br>fun demo(x: Comparable&lt;Number&gt;) {<br>    x.compareTo(1.0) // 1.0, Number&#39;ın bir alt türü.<br>    val y: Comparable&lt;Double&gt; = x // Güvenli!<br>}</pre><p><strong>in,</strong> tipin yalnızca tüketici olarak kullanıldığını garanti eder ve bu nedenle <strong>contravariance</strong> sağlar.</p><h3><strong>Type Projections</strong></h3><p>Bazı durumlarda, bir sınıf hem <strong>in</strong> hem de <strong>out</strong> olamaz. Örneğin, <strong>Array</strong> sınıfı:</p><pre>class Array&lt;T&gt;(val size: Int) {<br>    operator fun get(index: Int): T { /*...*/ }<br>    operator fun set(index: Int, value: T) { /*...*/ }<br>}</pre><p>Bir fonksiyonda bir dizinin içeriğini başka bir diziye kopyalamak istiyorsanız:</p><pre>fun copy(from: Array&lt;out Any&gt;, to: Array&lt;Any&gt;) {<br>    for (i in from.indices)<br>        to[i] = from[i] // Yalnızca `from` dizisinden okuyabilirsiniz.<br>}</pre><p>Bu, <strong>declaration-site variance</strong>’ın bir örneğidir.</p><h3>Star-Projections</h3><p>Bazen tip argümanı hakkında hiçbir şey bilmediğinizde, star projections kullanabilirsiniz:</p><pre>fun printList(list: List&lt;*&gt;) {<br>    list.forEach { println(it) } // Elemanlar Any? tipinde olur.<br>}</pre><p>Star projections, Java’nın ham tiplerine benzese de daha güvenlidir.</p><h3><strong>Generic Functions</strong></h3><p>Fonksiyonlar da generics kullanabilir. Tip parametresi, fonksiyon adından önce belirtilir:</p><pre>fun &lt;T&gt; singletonList(item: T): List&lt;T&gt; {<br>    return listOf(item)<br>}</pre><p>Tip parametresi, otomatik olarak anlaşılabiliyorsa yazılmasına gerek yoktur:</p><pre>val list = singletonList(1) // Tip otomatik anlaşılır. (Int)</pre><h3><strong>Generic Constraints</strong></h3><h4>Upper Bounds</h4><p>Bir tip parametresinin üst sınırını belirtmek için <strong>(: Type)</strong> kullanabilirsiniz:</p><pre>fun &lt;T : Comparable&lt;T&gt;&gt; sort(list: List&lt;T&gt;) { /*...*/ }</pre><p>Bu, yalnızca <strong>Comparable&lt;T&gt;</strong> alt türlerinin kabul edileceği anlamına gelir:</p><pre>sort(listOf(1, 2, 3)) // Geçerli<br>sort(listOf(HashMap&lt;Int, String&gt;())) // HATA</pre><h4>Multiple Constraints</h4><p>Birden fazla üst sınır gerektiğinde <strong>where</strong> anahtar kelimesini kullanabilirsiniz:</p><pre>fun &lt;T&gt; copyWhenGreater(list: List&lt;T&gt;, threshold: T): List&lt;String&gt;<br>        where T : CharSequence, T : Comparable&lt;T&gt; {<br>    return list.filter { it &gt; threshold }.map { it.toString() }<br>}</pre><h3><strong>Definitely Non-Nullable Types</strong></h3><p>Eğer bir tipin kesinlikle nullable olmadığını belirtmek istiyorsanız, <strong>T &amp; Any</strong> kullanabilirsiniz:</p><pre>interface Game&lt;T&gt; {<br>    fun save(x: T): T<br>    fun load(x: T &amp; Any): T &amp; Any<br>}</pre><h3><strong>Type Erasure</strong></h3><p>Kotlin’de generics, çalışma zamanında tip argümanlarını saklamaz. Bu, <strong>type erasure</strong> olarak bilinir:</p><pre>if (list is List&lt;*&gt;) {<br>    // Elemanlar Any? tipindedir.<br>}</pre><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, Kotlin’deki generics kavramını, tip parametreleri ve varyasyonlarıyla nasıl çalıştığını detaylı bir şekilde inceledim. Kotlin’deki generics, esnek ve yeniden kullanılabilir kod yazımını sağlar. <strong>in</strong> ve <strong>out</strong>, tip parametrelerinde <strong>declaration-site variance</strong> sağlar; <strong>out</strong> yalnızca <strong>üretici</strong>, <strong>in</strong> ise yalnızca <strong>tüketici</strong> olarak kullanılır. <strong>Type projections</strong>, <strong>in</strong> ve <strong>out</strong> kullamadığında devreye girer, <strong>star-projections</strong> ise tip argümanına gerek duyulmadığında kullanılır. Generics, fonksiyonlar ve sınıflar için de kullanılabilir; <strong>upper bounds</strong> ve <strong>where</strong> ile kısıtlamalar eklenebilir. Çalışma zamanında <strong>type erasure</strong> mekanizması kullanılır. Kotlin’in generics sistemi, Java’ya kıyasla daha anlaşılır ve güçlüdür.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/generics.html">https://kotlinlang.org/docs/generics.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2f2f1ca7224c" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin-23 : Sealed Classes]]></title>
            <link>https://medium.com/@cusufcan/kotlin-23-sealed-classes-144d49c36b22?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/144d49c36b22</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Sat, 11 Jan 2025 09:56:00 GMT</pubDate>
            <atom:updated>2025-01-11T09:56:00.492Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-23 : Sealed Classes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, sealed classes özelliklerini, kullanım alanlarını ve faydalarını inceleyeceğim. Sealed classes, Kotlin dilinin güçlü ve esnek yapılarından biridir. Bu yapı, sınıf hiyerarşilerinin kontrolünü sağlayarak, özellikle karmaşık sistemlerde kodun güvenli ve sürdürülebilir olmasını mümkün kılar. Sealed class’ın alt sınıfları derleme zamanında bilinir ve bu da type safety sağlarken, gelecekte beklenmedik davranışların önüne geçer. Sealed classes, sınıf hiyerarşisinin net sınırlarla çizilmesini sağlar. Bu sayede kod, daha kolay anlaşılır ve bakım yapılabilir bir yapıya dönüşür.</p><h3>Neden Sealed Class?</h3><p>Sealed class, farklı iş gereksinimlerini karşılamak için çeşitli avantajlar sunar:</p><ul><li><strong>Tür Güvenliği (Type Safety):</strong> Sealed classes, <strong>when</strong> ifadeleri ile birlikte kullanıldığında, derleyicinin tüm olası durumların kapsandığını kontrol etmesini sağlar. Bu, tür güvenliğini artırır ve programın beklenmedik hatalar üretme ihtimalini azaltır.</li><li><strong>Sınırlı Kalıtım (Restricted Inheritance):</strong> Bir sealed class’ın yalnızca belirli bir alt sınıf kümesi olabilir. Bu, sınıf hiyerarşisinin dışarıdan genişletilmesini önler ve tasarımın net bir şekilde kontrol edilmesine olanak tanır.</li><li><strong>Yapılandırılmış Kod (Structured Code):</strong> Kodun daha düzenli ve yapılandırılmış hale gelmesini sağlar. Özellikle durum yönetimi ve hata işleme gibi karmaşık mantıkların uygulanmasında sealed classes büyük avantaj sunar.</li><li><strong>Kapsayıcı API Tasarımı (Comprehensive API Design):</strong> Sealed classes, üçüncü taraf kullanıcıların yalnızca belirlenen sınıflar üzerinden API ile etkileşim kurmasını sağlar. Bu, sistemin kontrolünü geliştiriciye bırakır.</li></ul><h3>Sealed Class Tanımlama</h3><p>Sealed class tanımlamak oldukça basittir. <strong>sealed</strong> anahtar kelimesi, sınıf veya interface tanımından önce kullanılarak bu yapı oluşturulur:</p><pre>sealed interface Error<br><br>sealed class IOError : Error<br><br>class FileReadError(val file: File) : IOError()<br>class DatabaseError(val source: DataSource) : IOError()<br><br>object RuntimeError : Error</pre><p>Bu örnekte, <strong>Error</strong> adında bir sealed interface ve bunu miras alan <strong>IOError</strong> adında bir sealed class bulunmaktadır. Ayrıca, <strong>FileReadError</strong> ve <strong>DatabaseError</strong> gibi doğrudan alt sınıfları ile <strong>RuntimeError</strong> gibi bir object tanımlanmıştır.</p><p>Sealed classes, kalıtım hiyerarşisinin tasarımını kontrol etmek için kullanılır. Bu sınıfları kalıtım alan her sınıf, aynı paket içinde tanımlanmalıdır. Ayrıca, bu sınıflar yerel veya anonim nesneler olamaz; tüm alt sınıfların adlandırılmış olması gerekir.</p><h3>Sealed Class Constructors</h3><p>Sealed class’ın kendisi soyut bir sınıf olduğundan, doğrudan nesnesi oluşturulamaz. Ancak alt sınıfları için constructor tanımlanabilir ve bu constructor’lar iki farklı görünürlükte olabilir:</p><ul><li><strong>protected:</strong> Constructor sadece sealed class’ın kendisi ve alt sınıfları tarafından erişilebilir.</li><li><strong>private:</strong> Constructor yalnızca sealed class içinde kullanılabilir.</li></ul><pre>sealed class IOError {<br>    protected constructor() { /* Alt sınıflar için görünür */ }<br>    private constructor(description: String) : this() { /* Sadece bu sınıfta görünür */ }<br>}</pre><h3>“when” &amp; Sealed Classes</h3><p>Sealed class’ların en önemli avantajlarından biri, <strong>when</strong> ifadeleri ile birliktek ullanıldığında ortaya çıkar. Derleyici, <strong>when</strong> ifadesi içerisinde sealed class’ın tüm alt sınıflarının ele alındığını doğrular. Bu nedenle else eklenmesine gerek yoktur:</p><pre>sealed class Error {<br>    class FileReadError : Error()<br>    class DatabaseError : Error()<br>    object RuntimeError : Error()<br>}<br><br>fun log(e: Error) = when (e) {<br>    is Error.FileReadError -&gt; println(&quot;Error while reading file&quot;)<br>    is Error.DatabaseError -&gt; println(&quot;Error while reading from database&quot;)<br>    Error.RuntimeError -&gt; println(&quot;Runtime error&quot;)<br>}</pre><p>Bu yapı, kodun daha okunabilir olmasını ve tüm olası durumların açıkça ele alınmasını sağlar.</p><h3>Kullanım Senaryoları</h3><p>Sealed class’lar, farklı senaryolarda etkili bir şekilde kullanılabilir. Aşağıda bu senaryolara dair ayrıntılı açıklamalar yer almaktadır:</p><h4>UI State Management</h4><p>Kullanıcı arayüzü geliştirme süreçlerinde, farklı UI durumlarını temsil etmek için sealed class’ları kullanmak yaygın bir yaklaşımdır:</p><pre>sealed class UIState {<br>    data object Loading : UIState()<br>    data class Success(val data: String) : UIState()<br>    data class Error(val exception: Exception) : UIState()<br>}<br><br>fun updateUI(state: UIState) {<br>    when (state) {<br>        is UIState.Loading -&gt; showLoadingIndicator()<br>        is UIState.Success -&gt; showData(state.data)<br>        is UIState.Error -&gt; showError(state.exception)<br>    }<br>}</pre><p>Bu yapı, uygulamanın farklı durumlarını güvenli ve yapılandırılmış bir şekilde yönetmeyi sağlar.</p><h4>Payment Method Handling</h4><p>E-ticaret uygulamalarında, çeşitli ödeme yöntemlerini yönetmek için sealed class’lar etkili bir araçtır:</p><pre>sealed class Payment {<br>    data class CreditCard(val number: String, val expiryDate: String) : Payment()<br>    data class PayPal(val email: String) : Payment()<br>    data object Cash : Payment()<br>}<br><br>fun processPayment(payment: Payment) {<br>    when (payment) {<br>        is Payment.CreditCard -&gt; foo(payment.number, payment.expiryDate)<br>        is Payment.PayPal -&gt; foo(payment.email)<br>        is Payment.Cash -&gt; foo()<br>    }<br>}</pre><p>Yukarıdaki örnekte, <strong>Payment</strong> sealed class’ı ve alt sınıfları, ödeme yöntemlerini temsil eder. Bu yapı, tüm ödeme türlerinin sistem tarafından doğru bir şekilde ele alınmasını sağlar.</p><h4>API Request-Response Handling</h4><p>API çağrılarında request-response işleme, sealed class’ların sıkça kullanıldığı bir başka alandır:</p><pre>sealed interface ApiRequest<br>data class LoginRequest(val username: String, val password: String) : ApiRequest<br>data object LogoutRequest : ApiRequest<br><br>sealed class ApiResponse {<br>    data class UserSuccess(val user: UserData) : ApiResponse()<br>    data object UserNotFound : ApiResponse()<br>    data class Error(val message: String) : ApiResponse()<br>}<br><br>data class UserData(val userId: String, val name: String, val email: String)<br><br>fun handleRequest(request: ApiRequest): ApiResponse {<br>    return when (request) {<br>        is LoginRequest -&gt; {<br>            if (isValidUser(request.username, request.password)) {<br>                ApiResponse.UserSuccess(UserData(&quot;userId&quot;, &quot;userName&quot;, &quot;userEmail&quot;))<br>            } else {<br>                ApiResponse.Error(&quot;Invalid username or password&quot;)<br>            }<br>        }<br>        is LogoutRequest -&gt; ApiResponse.UserSuccess(UserData(&quot;userId&quot;, &quot;userName&quot;, &quot;userEmail&quot;))<br>    }<br>}</pre><p>Bu yapı, API çağrılarında type safety’i artırır ve uygulamanın daha kolay genişletilebilir olmasını sağlar.</p><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, sealed classes tanımını, kullanım senaryolarını ve avantajlarını ele aldım. Sealed classes, yazılım geliştirme süreçlerinde type safety, kod düzenliliği ve sürdürülebilirlik sağlar. Bu yapılar, karmaşık durumların yönetiminde, API tasarımında ve kullanıcı arayüzü geliştirme süreçlerinde etkin bir şekilde kullanılabilir. Kotlin gibi modern programlama dillerinde sealed class’ların doğru bir şekilde uygulanması, daha güvenli ve hatasız bir yazılım tasarımına olanak tanır.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/sealed-classes.html">https://kotlinlang.org/docs/sealed-classes.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=144d49c36b22" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin-22 : Data Classes]]></title>
            <link>https://medium.com/@cusufcan/kotlin-22-data-classes-bee09906fe72?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/bee09906fe72</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Fri, 10 Jan 2025 12:17:47 GMT</pubDate>
            <atom:updated>2025-01-10T12:17:47.523Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-22 : Data Classes</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, Kotlin <strong>veri sınıflarını (data classes)</strong> detaylı bir şekilde inceleyeceğim. Kotlin’deki veri sınıfları, öncelikli olarak veriyi temsil etmek ve yönetmek için kullanılan sınıf türleridir. Bu sınıflar, derleyici tarafından otomatik olarak üretilen ek fonksiyonlar sayesinde veri odaklı programlama süreçlerini kolaylaştırır. Veri sınıfları, programcıların yazması gereken kod miktarını azaltırken, aynı zamanda kodun daha okunabilir ve tutarlı olmasını sağlar.</p><h3>Veri Sınıflarının Tanımı</h3><p>Veri sınıfları, <strong>data</strong> anahtar kelimesiyle tanımlanır ve veriyi temsil etmek için kullanılır:</p><pre>data class User(val name: String, val age: Int)</pre><p>Bu sınıf, bir kullanıcının adını ve yaşını tutar. <strong>data</strong> anahtar kelimesi sayesinde Kotlin derleyicisi, bu sınıf için çeşitli fonksiyonları otomatik olarak oluşturur.</p><h3>Derleyici Tarafından Üretilen Fonksiyonlar</h3><p>Bir veri sınıf tanımlandığında, aşağıdaki fonksiyonlar otomatik olarak oluşturulur:</p><ul><li><strong>equals() / hashCode():</strong> Sınıfın instance’larını karşılaştırmak ve benzersiz kimlikler oluşturmak için kullanılır.</li><li><strong>toString():</strong> Instance’ı okunabilir bir formatta döndürür. Örneğin: <strong>User(name=John, age=42)</strong></li><li><strong>componentN() fonksiyonları:</strong> Sınıf değişkenlerine sırasıyla erişim sağlar. Örneğin, <strong>component1()</strong> <strong>name</strong> değişkenini, <strong>component2()</strong> ise <strong>age</strong> değişkenini döndürür. Destructuring Declaration kavramı bu fonksiyon sayesinde kullanılabilir.</li><li><strong>copy() fonksiyonu:</strong> Bir instance’ın kopyasını oluşturur ve istenirse bazı değişkenleri değiştirmenize olanak tanır.</li></ul><h3>Veri Sınıflarının Gereksinimleri</h3><p>Veri sınıflarının doğru bir şekilde çalışabilmesi için belirli gereksinimleri karşılaması gerekir:</p><ul><li>Primary constructor’da <strong>en az bir parametre</strong> bulunmalıdır.</li><li>Tüm primary constructor parametreleri <strong>val</strong> veya <strong>var</strong> ile işaretlenmelidir.</li><li>Veri sınıfları <strong>abstract</strong>, <strong>open</strong>, <strong>sealed</strong> veya <strong>inner</strong> olamaz.</li></ul><p>Bu gereksinimlere uymayan veri sınıfları derleme hatası verecektir.</p><h3>Üst Sınıflardan Kalıtım</h3><p>Veri sınıfları, diğer sınıflardan türetilebilir. Ancak, aşağıdaki kurallar geçerlidir:</p><ul><li><strong>equals()</strong>, <strong>hashCode()</strong> veya <strong>toString()</strong> fonksiyonlarının üst sınıflarda tanımlanmış <strong>final</strong> metotları varsa, bu metotlar yeniden oluşturulmaz.</li><li>Üst sınıfın <strong>componentN()</strong> fonksiyonları varsa, veri sınıfı bu fonksiyonları override eder. Ancak, uyumsuz final fonksiyonlar varsa, derleme hatası oluşur.</li></ul><h3>Değişkenlerin Sınıf Gövdesinde Tanımlanması</h3><p>Bir veri sınıfında otomatik olarak oluşturulan fonksiyonlar, yalnızca primary constructor’da tanımlanan değişkenleri dikkate alır. Eğer bir değişken sınıf gövdesinde tanımlanmışsa, bu değişken otomatik fonksiyonlara dahil edilmez:</p><pre>data class Person(val name: String) {<br>    var age: Int = 0<br>}</pre><p>Bu örnekte, <strong>name</strong> değişkeni otomatik fonksiyonlara dahil edilirken, <strong>age</strong> değişkeni hariç tutulur. Sonuç olarak, aşağıdaki iki <strong>Person</strong> instance’ı eşit kabul edilir. Çünkü <strong>equals</strong> gibi fonksiyonlar, yukarıda dediğim gibi sadece primary constructor’da tanımlananları dikkate alır:</p><pre>val person1 = Person(&quot;John&quot;)<br>val person2 = Person(&quot;John&quot;)<br>person1.age = 10<br>person2.age = 20<br><br>println(person1 == person2) // true</pre><h3>Kopyalama (Copying)</h3><p>Bir veri sınıfı <strong>instance</strong>’ını kopyalamak için <strong>copy()</strong> fonksiyonu kullanılır. Bu fonksiyon, belirli değişkenleri değiştirmenize ve diğerlerini aynı tutabilmenizi sağlar:</p><pre>data class User(val name: String, val age: Int)<br><br>val jack = User(&quot;Jack&quot;, 1)<br>val olderJack = jack.copy(age = 2)<br><br>println(jack) // User(name=Jack, age=1)<br>println(olderJack) // User(name=Jack, age=2)</pre><h3>Veri Sınıfları &amp; Destructuring Declarations</h3><p>Veri sınıflarındaki <strong>component</strong> fonksiyonları, <strong>destructuring declarations</strong>’ta kullanılabilir. Bu sayede bir veri sınıfının değişkenlerine kolayca erişilebilir:</p><pre>val jane = User(&quot;Jane&quot;, 35)<br>val (name, age) = jane<br>println(&quot;$name, $age years of age&quot;) // Jane, 35 years of age</pre><h3>Standart Veri Sınıfları</h3><p>Kotlin’in standart kütüphanesi, <strong>Pair</strong> ve <strong>Triple</strong> gibi genel amaçlı veri sınıflarını sağlar. Ancak, belirli bir bağlam için anlamlı özellik adları içeren veri sınıfları kullanmak daha iyi bir tasarım yaklaşımıdır:</p><pre>val pair = Pair(&quot;A&quot;, 1)<br>println(pair) // (A, 1)<br><br>data class Coordinate(val x: Int, val y: Int)<br>val point = Coordinate(10, 20)<br>println(point) // Coordinate(x=10, y=20)</pre><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, Kotlin veri sınıflarının tanımı, özellikleri ve kullanım örneklerini detaylıca ele aldım. Kotlin veri sınıfları, veri odaklı programlama süreçlerini basitleştirir ve daha okunabilir bir kod yapısı sunar. Otomatik olarak oluşturulan fonksiyonlar, programcıların ve benim tekrarlayan kod yazmamızı önler ve yazılım geliştirme sürecini hızlandırır. Veri sınıflarını doğru bir şekilde kullanarak, hem performanslı hem de anlamlı uygulamalar geliştirebilirsiniz.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/data-classes.html">https://kotlinlang.org/docs/data-classes.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bee09906fe72" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Kotlin-21 : Extensions]]></title>
            <link>https://medium.com/@cusufcan/kotlin-21-extensions-34d23b337e84?source=rss-0142a79ab291------2</link>
            <guid isPermaLink="false">https://medium.com/p/34d23b337e84</guid>
            <category><![CDATA[kotlin]]></category>
            <dc:creator><![CDATA[Yusuf Can Mercan]]></dc:creator>
            <pubDate>Thu, 09 Jan 2025 09:10:38 GMT</pubDate>
            <atom:updated>2025-01-09T09:10:38.891Z</atom:updated>
            <content:encoded><![CDATA[<h3>Kotlin-21 : Extensions</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LJe2ZsEnk1M3HjTFmSEvsw.png" /></figure><p>Merhaba. Bu yazımda, Kotlin extensions konusunun tüm yönlerini detaylı bir şekilde ele alacağım. Kotlin, bir class veya interface’i miras almak ya da tasarım kalıplarını kullanmak zorunda kalmadan genişletme yeteneği sunan modern bir programlama dilidir. Bu mekanizma, extensions adı verilen özel bildirimlerle sağlanır.</p><h3>1. Extensions Nedir?</h3><p>Kotlin’de extensions, bir class’a veya interface’e yeni işlevsellik eklemenizi sağlar. Bu, özellikle değiştiremeyeceğiniz üçüncü taraf kütüphanelerdeki class’lar veya interface’ler için faydalıdır. Örneğin, extensions sayesinde bir sınıfa ait olmayan bir fonksiyon, o sınıfın doğal bir parçasıymış gibi kullanılabilir.</p><h3>2. Extension Functions</h3><p>Bir sınıfa yeni bir işlev eklemek için <strong>extension function</strong> tanımlayabilirsiniz. Bunun için, fonksiyon adının öncesine <strong>alıcı türü (receiver type)</strong> eklenir:</p><pre>fun &lt;T&gt; MutableList&lt;T&gt;.swap(index1: Int, index2: Int) {<br>    val tmp = this[index1]<br>    this[index1] = this[index2]<br>    this[index2] = tmp<br>}</pre><p>Yukarıdaki örnekte, <strong>swap</strong> fonksiyonu bir <strong>MutableList</strong> üzerinde tanımlanmıştır ve iki elemanın yer değiştirmesini sağlar. <strong>this</strong> anahtar kelimesi, uzantı fonksiyonunda listeyi ifade eder.</p><h3>3. Extensions Static’tir</h3><p>Extensions, genişlettikleri sınıfların üyeleri olmazlar. Yani, extensions statik olarak çözülür ve çağrılacak fonksiyon, alıcı türüne bağlı olarak <strong>derleme zamanında</strong> belirlenir:</p><pre>open class Shape<br>class Rectangle : Shape()<br><br>fun Shape.getName() = &quot;Shape&quot;<br>fun Rectangle.getName() = &quot;Rectangle&quot;<br><br>fun foo(s: Shape) {<br>    println(s.getName())<br>}</pre><p>Bu kodda, <strong>foo</strong> fonksiyonuna <strong>Rectangle</strong> nesnesi geçirilse bile, <strong>getName</strong> fonksiyonu <strong>alıcı türüne (Shape)</strong> göre çözümlenir ve <strong>“Shape”</strong> yazdırılır.</p><h3>4. Üye Fonksiyon &amp; Extension Function Çakışmaları</h3><p>Bir sınıfın üye fonksiyonu ile aynı isimli bir extension function tanımlandığında, üye fonksiyonu <strong>öncelikli</strong> olarak çağrılır:</p><pre>class Example {<br>    fun printFunctionType() {<br>        println(&quot;Class method&quot;)<br>    }<br>}<br><br>fun Example.printFunctionType() {<br>    println(&quot;Extension function&quot;)<br>}</pre><p>Bu durumda, printFunctionType çağrıldığında, “Class method” yazdırılır. Ancak, farklı isme sahip extension fonksiyonlar ile üye fonksiyonlar bir arada çalışabilir:</p><pre>fun Example.printFunctionType(i: Int) {<br>    println(&quot;Extension function #$i&quot;)<br>}</pre><h3>5. Nullable Alıcılar (Nullable Receivers)</h3><p>Bir extension fonksiyonu, alıcı türünün <strong>null</strong> olmasına izin verebilir. Bu sayede, <strong>null</strong> bir nesne üzerinde bile güvenle çağrılabilir:</p><pre>fun Any?.toString(): String {<br>    return if (this == null) &quot;null&quot; else toString()<br>}</pre><p>Bu fonksiyon, <strong>null</strong> değerler için <strong>“null”</strong> döner, diğer durumlarda nesnenin <strong>toString</strong> metodunu çağırır.</p><h3>6. Extension Değişkenler (Extension Properties)</h3><p>Extensions, yalnızca fonksiyonlarla sınırlı değildir; ayrıca değişkenler de tanımlanabilir. Ancak, extension değişkenlerinin <strong>destek alanı (backing field)</strong> olmaz:</p><pre>val &lt;T&gt; List&lt;T&gt;.lastIndex: Int<br>    get() = size - 1</pre><h3>7. Companion Object Extensions</h3><p>Bir sınıfın companion object’i için de extension tanımlayabilirsiniz:</p><pre>class MyClass {<br>    companion object {}<br>}<br><br>fun MyClass.Companion.foo() {<br>    println(&quot;Companion extension&quot;)<br>}</pre><p>Bu extension, yalnızca sınıf adı kullanılarak çağrılabilir.</p><h3>8. Scope of Extensions</h3><p>Extensions, genellikle en üst düzeyde, paketlerin altında tanımlanır. Başka bir paket içinde kullanılacaksa, import edilmesi gerekir.</p><h4>Deklarasyon:</h4><pre>package org.example.declarations<br><br>fun List&lt;String&gt;.getLongestString(): String? {<br>    return this.maxByOrNull { it.length }<br>}</pre><h4>Kullanım:</h4><pre>import org.example.declarations.getLongestString<br><br>fun foo() {<br>    val list = listOf(&quot;Kotlin&quot;, &quot;Extensions&quot;, &quot;Tutorial&quot;)<br>    println(list.getLongestString()) // Outputs: &quot;Extensions&quot;<br>}</pre><h3>9. Üye Olarak Extensions</h3><p>Bir sınıfın içinde başka bir sınıf için extensions tanımlayabilirsiniz. Bu tür extension’lar hem extension receiver’ının hem de dağıtım receiver’ının üyelerine erişebilir:</p><pre>class Host(val hostname: String)<br><br>class Connection(val host: Host, val port: Int) {<br>    fun Host.getConnectionString(): String {<br>        return &quot;$hostname:$port&quot;<br>    }<br><br>    fun connect() {<br>        println(host.getConnectionString())<br>    }<br>}</pre><h3>10. Virtual Dispatch &amp; Statik Çözümleme</h3><p>Üye olarak tanımlanan extensions, dağıtım receiver’ına göre <strong>virtual</strong>; extension receiver’ına göre <strong>static</strong> olarak çözülür:</p><pre>open class Base<br>class Derived : Base()<br><br>open class BaseCaller {<br>    open fun Base.foo() {<br>        println(&quot;Base extension in BaseCaller&quot;)<br>    }<br><br>    open fun Derived.foo() {<br>        println(&quot;Derived extension in BaseCaller&quot;)<br>    }<br><br>    fun call(b: Base) {<br>        b.foo()<br>    }<br>}</pre><h3>11. Görünürlük (Visibility)</h3><p>Extensions, aynı kapsamda bildirilen fonksiyonlarla aynı görünürlük kurallarına sahiptir. Ancak, bir <strong>extension</strong>, receiver türünün <strong>private</strong> veya <strong>protected</strong> üyelerine erişemez.</p><h3>Sonuç ve Kaynaklar</h3><p>Bu yazımda, Kotlin’de extensions, extension functions, properties, static resolution ve scope gibi temel konuları anlattım. Kotlin extensions, mevcut sınıfları değiştirmeden işlevsellik eklemenin güçlü ve esnek bir yoludur. Ancak, extension’ların sınıflara üye eklemediğini ve static olarak çözümlendiğini unutmamak önemlidir. Bu mekanizmayı doğru bir şekilde anlamak, daha temiz ve genişletilebilir kodlar yazmanıza yardımcı olacaktır.</p><p>Eğer bu yazıda bahsedilen konular hakkında daha fazla bilgi edinmek isterseniz, faydalandığım kaynaklara göz atabilirsiniz:</p><ol><li><a href="https://kotlinlang.org/docs/extensions.html">https://kotlinlang.org/docs/extensions.html</a></li></ol><h3>Teşekkürler!</h3><p>Bu yazıyı okuduğunuz için teşekkür ederim. Daha fazla içerik ve bağlantı için bana ulaşabilirsiniz:</p><ul><li><strong>LinkedIn</strong>: <a href="http://linkedin.com/in/cusufcan">linkedin.com/in/cusufcan</a></li><li><strong>GitHub</strong>: <a href="http://github.com/cusufcan">github.com/cusufcan</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=34d23b337e84" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>