Kotlin Sınıfları ve Yapıcı Metotları: Derinlemesine Bir Bakış

Kotlin Sınıfları ve Yapıcı Metotları: Derinlemesine Bir Bakış

Kotlin’e Giriş ve Sınıfların Önemi

Kotlin, JetBrains tarafından geliştirilen ve özellikle Android uygulama geliştirme dünyasında hızla popülerlik kazanan, modern, statik tipli bir programlama dilidir. Java Sanal Makinesi (JVM) üzerinde çalışabilmesi, Java ile tam uyumlu olması ve daha kısa, okunabilir kod yazma imkanı sunması gibi özellikleriyle dikkat çeker. Kotlin’in nesne yönelimli programlama (OOP) paradigmasını benimsemesi, sınıfları ve bu sınıfların nesnelerini oluşturmak için kullanılan yapıcı metotları dilin temel yapı taşlarından biri haline getirir. Bu makalede, Kotlin sınıflarının nasıl tanımlandığını, özelliklerini ve özellikle yapıcı metotların (primary ve secondary constructors) detaylı kullanımını, miras alma durumlarındaki davranışlarını ve en iyi uygulamalarını derinlemesine inceleyeceğiz.

Nesne yönelimli programlamanın merkezinde, gerçek dünyadaki varlıkları modellemek için kullanılan “sınıflar” bulunur. Bir sınıf, belirli bir türdeki nesnelerin özelliklerini (veri) ve davranışlarını (metotlar) tanımlayan bir şablondur. Bu şablonu kullanarak oluşturulan her bir örneğe “nesne” veya “örnek” (instance) denir. Kotlin’de sınıflar, verileri kapsüllemek, kod tekrarını azaltmak ve daha modüler, sürdürülebilir uygulamalar geliştirmek için vazgeçilmezdir. Bir nesne oluşturulduğunda, onun başlangıç durumunu ayarlamak, yani gerekli başlangıç değerlerini atamak için yapıcı metotlar devreye girer. Kotlin’in yapıcı metotlara yaklaşımı, Java’dan farklı ve daha esnektir, bu da onu anlamayı kritik hale getirir.

Kotlin Sınıflarının Temelleri

Kotlin’de bir sınıf tanımlamak oldukça basittir ve class anahtar kelimesiyle başlar. Bir sınıf, özellikler (properties) ve metotlar (functions) içerebilir.

Sınıf Tanımlama

Bir sınıf, class anahtar kelimesiyle tanımlanır. En basit haliyle, bir sınıf boş olabilir:

class Kisiler {
    // Sınıfın gövdesi buraya gelir
}

Bu Kisiler sınıfı henüz hiçbir özellik veya metot içermemektedir. Ancak, bu haliyle bile Kisiler tipinde nesneler oluşturulabilir:

val kisi1 = Kisiler() // Kisiler sınıfından bir nesne oluşturuldu

Özellikler (Properties) ve Alanlar (Fields)

Sınıfların temel amacı, veriyi kapsüllemektir. Bu veriler, sınıfın “özellikleri” olarak adlandırılır. Kotlin’de özellikler, val (salt okunur) veya var (değiştirilebilir) anahtar kelimeleriyle tanımlanır.

class Urun {
    var ad: String = "Varsayılan Ürün"
    val fiyat: Double = 0.0
    var stokAdedi: Int = 0
}

Yukarıdaki Urun sınıfında ad, fiyat ve stokAdedi adında üç özellik bulunmaktadır. ad ve stokAdedi var ile tanımlandığı için değerleri sonradan değiştirilebilirken, fiyat val olduğu için sadece başlangıçta atanabilir ve sonradan değiştirilemez.

Kotlin’de özellikler, arka planda otomatik olarak oluşturulan “alanlar” (backing fields) ve “erişimciler” (accessors – getter/setter) ile desteklenir. val özellikler için sadece bir getter, var özellikler için ise hem getter hem de setter otomatik olarak oluşturulur. Bu, Java’daki boilerplate kodunu (getter/setter metotlarını elle yazma zorunluluğunu) ortadan kaldırır. Gerekirse, bu erişimcileri özel mantıkla özelleştirmek de mümkündür:

class Dikdortgen(val en: Int, val boy: Int) {
    val alan: Int
        get() = en * boy // 'alan' özelliği için özel getter
}

val dikdortgen = Dikdortgen(5, 10)
println(dikdortgen.alan) // Çıktı: 50

Kotlin Yapıcı Metotları (Constructors)

Yapıcı metotlar, bir sınıfın yeni bir nesnesi oluşturulduğunda çağrılan özel metotlardır. Temel amacı, nesnenin başlangıç durumunu ayarlamak, yani özelliklerine ilk değerlerini atamaktır. Kotlin, Java’dan farklı olarak, birincil (primary) ve ikincil (secondary) yapıcı metotlar olmak üzere iki tür yapıcı metot sunar.

Yapıcı Metot Nedir?

Bir yapıcı metot, sınıfın adıyla aynı ada sahip olan ve dönüş tipi olmayan bir metot olarak düşünülebilir. Kotlin’de bu durum biraz farklıdır. Yapıcı metotlar, sınıfın örneklendiği anda (yani Urun() gibi bir çağrı yapıldığında) otomatik olarak çalışır. Nesnenin özelliklerini başlatmak, gerekli bağımlılıkları sağlamak veya nesnenin geçerli bir durumda olduğundan emin olmak için kullanılırlar.

Birincil Yapıcı Metot (Primary Constructor)

Kotlin’de bir sınıfın birincil yapıcı metodu, sınıf başlığının bir parçası olarak tanımlanır. Bu, sınıf adından sonra parantez içinde belirtilen parametrelerdir.

class Musteri(val id: String, var ad: String, var soyad: String) {
    // Sınıfın gövdesi
}

Yukarıdaki Musteri sınıfında, (val id: String, var ad: String, var soyad: String) kısmı birincil yapıcı metottur. Bu yapıcı, üç parametre alır: id, ad ve soyad. Bu parametreler, doğrudan sınıfın özellikleri olarak tanımlanmıştır (val veya var ile). Bu, Kotlin’in önemli bir özelliğidir; yapıcı parametrelerini doğrudan özellik olarak tanımlayarak boilerplate kodunu azaltırız.

Eğer birincil yapıcı metot herhangi bir açıklama (erişim belirleyici veya @Inject gibi annotation) içermiyorsa, constructor anahtar kelimesi atlanabilir:

class Kitap(val baslik: String, val yazar: String, var sayfaSayisi: Int)

Ancak, eğer yapıcıya bir erişim belirleyici (örneğin private) veya herhangi bir annotation eklemek istersek, constructor anahtar kelimesini kullanmak zorunludur:

class Kasiyer private constructor(val kimlikNo: String) {
    // ...
}

Birincil yapıcı metot, sınıf gövdesinde herhangi bir kod içermez. Yapıcıya ek mantık eklemek, parametreleri doğrulamak veya başka başlatma işlemleri yapmak için init blokları kullanılır.

class Kullanici(val ad: String, val yas: Int) {
    init {
        println("Kullanıcı $ad oluşturuldu. Yaşı: $yas")
        require(yas >= 0) { "Yaş negatif olamaz." } // Parametre doğrulama
    }

    // ... diğer özellikler ve metotlar
}

val user1 = Kullanici("Ali", 30) // Çıktı: Kullanıcı Ali oluşturuldu. Yaşı: 30
// val user2 = Kullanici("Ayşe", -5) // IllegalArgumentException fırlatır

Bir sınıfta birden fazla init bloğu olabilir ve bunlar tanımlandıkları sıraya göre çalıştırılır. Birincil yapıcı parametreleri, init blokları ve özellik başlatıcıları, sınıf örneklendiğinde bu sırayla çalışır.

İkincil Yapıcı Metotlar (Secondary Constructors)

Bir sınıfın birincil yapıcı metodu yoksa veya farklı parametre setleriyle nesne oluşturmak istiyorsak, ikincil yapıcı metotlar tanımlayabiliriz. İkincil yapıcı metotlar, sınıf gövdesinde constructor anahtar kelimesiyle tanımlanır.

Önemli Kural: Bir sınıfın birincil yapıcı metodu varsa, tüm ikincil yapıcı metotların doğrudan veya dolaylı olarak birincil yapıcıyı çağırması gerekir. Bu çağrı, this() anahtar kelimesi kullanılarak yapılır. Eğer birincil yapıcı yoksa, ikincil yapıcılar birbirlerini this() ile çağırabilir.

class Personel(val ad: String, val soyad: String) { // Birincil yapıcı

    var departman: String = "Genel"
    var maas: Double = 0.0

    // İkincil yapıcı: Sadece ad ve soyad ile oluşturulur
    constructor(ad: String, soyad: String, departman: String) : this(ad, soyad) {
        this.departman = departman
    }

    // İkincil yapıcı: Tüm bilgilerle oluşturulur
    constructor(ad: String, soyad: String, departman: String, maas: Double) : this(ad, soyad, departman) {
        this.maas = maas
    }

    init {
        println("Personel nesnesi oluşturuldu: $ad $soyad")
    }

    fun bilgileriGoster() {
        println("Ad: $ad, Soyad: $soyad, Departman: $departman, Maaş: $maas")
    }
}

fun main() {
    val personel1 = Personel("Ayşe", "Yılmaz")
    personel1.bilgileriGoster()
    // Çıktı:
    // Personel nesnesi oluşturuldu: Ayşe Yılmaz
    // Ad: Ayşe, Soyad: Yılmaz, Departman: Genel, Maaş: 0.0

    val personel2 = Personel("Mehmet", "Demir", "IT")
    personel2.bilgileriGoster()
    // Çıktı:
    // Personel nesnesi oluşturuldu: Mehmet Demir
    // Ad: Mehmet, Soyad: Demir, Departman: IT, Maaş: 0.0

    val personel3 = Personel("Zeynep", "Can", "HR", 7500.0)
    personel3.bilgileriGoster()
    // Çıktı:
    // Personel nesnesi oluşturuldu: Zeynep Can
    // Ad: Zeynep, Soyad: Can, Departman: HR, Maaş: 7500.0
}

Yukarıdaki örnekte, Personel sınıfının birincil yapıcı metodu (val ad: String, val soyad: String)‘dir. Diğer iki ikincil yapıcı metot, this(ad, soyad) veya this(ad, soyad, departman) çağrısıyla birincil yapıcıyı veya başka bir ikincil yapıcıyı zincirleme olarak çağırmaktadır. Bu, yapıcı metotların aşırı yüklenmesini (overloading) sağlar ve nesneleri farklı parametre kombinasyonlarıyla oluşturma esnekliği sunar.

Yapıcı Metotların Kapsamı (Visibility Modifiers)

Kotlin’de yapıcı metotlar için de erişim belirleyiciler (visibility modifiers) kullanılabilir: public, private, protected, internal. Varsayılan olarak, yapıcı metotlar public‘tir.

* public: Her yerden erişilebilir (varsayılan).
* private: Sadece sınıfın içinde erişilebilir. Bu, fabrika metotları (factory methods) ile nesne oluşturmak istediğimizde faydalıdır.
* protected: Sadece sınıfın içinde ve türetilmiş sınıflarda erişilebilir. (Ancak, birincil yapıcı için protected kullanılamaz. Eğer bir sınıfın yapıcı metodu protected olacaksa, bu bir ikincil yapıcı olmalı ve temel sınıfın birincil yapıcısı protected olamaz.)
* internal: Aynı modül içinde her yerden erişilebilir.

Örnek olarak private bir yapıcı metot:

class Singleton private constructor() {
    init {
        println("Singleton nesnesi oluşturuldu.")
    }

    companion object {
        val instance = Singleton() // Sadece sınıf içinden çağrılabilir
    }

    fun mesajGoster() {
        println("Merhaba, ben Singleton!")
    }
}

fun main() {
    // val s = Singleton() // Hata: Yapıcı 'private'
    val s = Singleton.instance
    s.mesajGoster()
}

Sınıf Mirası ve Yapıcı Metotlar

Kotlin’de, Java’nın aksine, sınıflar varsayılan olarak “kapalı” (final) durumdadır. Bu, başka sınıfların ondan miras alamayacağı anlamına gelir. Bir sınıfın miras alınabilmesi için open anahtar kelimesiyle işaretlenmesi gerekir.

Açık Sınıflar (Open Classes)

open class TemelSınıf(val ad: String) {
    init {
        println("TemelSınıf oluşturuldu: $ad")
    }
}

class TüretilmişSınıf(ad: String, val yas: Int) : TemelSınıf(ad) {
    init {
        println("TüretilmişSınıf oluşturuldu: $ad, Yaş: $yas")
    }
}

fun main() {
    val turetilmis = TüretilmişSınıf("Deneme", 25)
    // Çıktı:
    // TemelSınıf oluşturuldu: Deneme
    // TüretilmişSınıf oluşturuldu: Deneme, Yaş: 25
}

Türetilmiş Sınıflar (Derived Classes) ve Yapıcılar

Bir türetilmiş sınıfın birincil yapıcı metodu varsa, temel sınıfın birincil yapıcısını doğrudan çağırması gerekir. Bu çağrı, temel sınıf adından sonra parantez içinde super() çağrısı gibi yapılır.

open class Calisan(val tcKimlik: String, val isim: String) {
    open fun calis() {
        println("$isim çalışıyor.")
    }
}

class Yonetici(tcKimlik: String, isim: String, val departman: String) : Calisan(tcKimlik, isim) {
    override fun calis() {
        super.calis() // Temel sınıfın metodunu çağır
        println("$isim $departman departmanını yönetiyor.")
    }
}

fun main() {
    val yonetici = Yonetici("12345678901", "Can Yılmaz", "Pazarlama")
    yonetici.calis()
    // Çıktı:
    // Can Yılmaz çalışıyor.
    // Can Yılmaz Pazarlama departmanını yönetiyor.
}

Eğer türetilmiş sınıfın birincil yapıcı metodu yoksa ve sadece ikincil yapıcı metotları varsa, bu ikincil yapıcı metotların super() anahtar kelimesiyle temel sınıfın bir yapıcısını çağırması gerekir.

open class Esya {
    constructor(ad: String) {
        println("Esya oluşturuldu: $ad")
    }
}

class Mobilya : Esya {
    constructor(ad: String, malzeme: String) : super(ad) {
        println("Mobilya oluşturuldu: $ad, Malzeme: $malzeme")
    }
}

fun main() {
    val masa = Mobilya("Çalışma Masası", "Ahşap")
    // Çıktı:
    // Esya oluşturuldu: Çalışma Masası
    // Mobilya oluşturuldu: Çalışma Masası, Malzeme: Ahşap
}

Veri Sınıfları (Data Classes) ve Yapıcı Metotlar

Kotlin’in en kullanışlı özelliklerinden biri de data class‘lardır. Veri sınıfları, sadece veri tutmak için tasarlanmış sınıflardır ve equals(), hashCode(), toString(), copy() ve componentN() gibi standart metotları otomatik olarak oluşturur.

Data Class Nedir?

Bir sınıfı data anahtar kelimesiyle işaretlemek, onu bir veri sınıfı yapar. Data class’ların en az birincil yapıcı parametresi olması zorunludur. Bu parametreler, otomatik olarak oluşturulan metotlar için kullanılır.

data class KullaniciBilgisi(val id: Int, val ad: String, val email: String)

fun main() {
    val user1 = KullaniciBilgisi(1, "Ali", "ali@example.com")
    val user2 = KullaniciBilgisi(1, "Ali", "ali@example.com")
    val user3 = KullaniciBilgisi(2, "Ayşe", "ayse@example.com")

    println(user1)          // toString() otomatik: KullaniciBilgisi(id=1, ad=Ali, email=ali@example.com)
    println(user1 == user2) // equals() otomatik: true (değer eşitliği kontrolü)
    println(user1 == user3) // false

    val user1Kopya = user1.copy(email = "ali.yeni@example.com") // copy() otomatik
    println(user1Kopya)     // KullaniciBilgisi(id=1, ad=Ali, email=ali.yeni@example.com)

    val (id, ad, email) = user1 // componentN() ve destructuring declaration
    println("ID: $id, Ad: $ad, Email: $email")
}

Data class’larda ikincil yapıcı metotlar da tanımlanabilir, ancak bu ikincil yapıcıların da birincil yapıcıyı çağırması ve birincil yapıcıda tanımlanan tüm özellikleri başlatması gerekir. Data class’ların temel gücü, birincil yapıcı parametrelerinden türetilen otomatik metotlarda yatar, bu yüzden bu parametrelerin doğru şekilde tanımlanması kritik öneme sahiptir.

Nesne Oluşturma ve Yapıcı Metot Çağrısı

Kotlin’de nesne oluşturmak için Java’daki gibi new anahtar kelimesine ihtiyaç yoktur. Doğrudan sınıf adını ve parantezleri kullanarak bir nesne oluşturulur.

class Araba(val marka: String, val model: String)

fun main() {
    val araba1 = Araba("BMW", "X5") // Yapıcı metot çağrısı
    println("${araba1.marka} ${araba1.model}")
}

Parametreleri olan yapıcı metotları çağırırken, parametrelerin sırasına dikkat etmek önemlidir. Kotlin, “isimli argümanlar” (named arguments) özelliğini sunarak bu konuda esneklik sağlar. Bu sayede, parametrelerin sırası değişse bile kodun okunabilirliği artar ve varsayılan değerler varken hangi parametreye değer atandığı açıkça belirtilebilir.

class PersonelDetay(val ad: String, val soyad: String, val yas: Int = 30, val departman: String = "Genel")

fun main() {
    val p1 = PersonelDetay("Ayşe", "Yılmaz") // Varsayılan yaş ve departman kullanılır
    val p2 = PersonelDetay("Mehmet", "Demir", 40) // Yaş override edilir, departman varsayılan
    val p3 = PersonelDetay(ad = "Zeynep", soyad = "Can", departman = "İnsan Kaynakları") // İsimli argümanlar ve varsayılan yaş
    val p4 = PersonelDetay(soyad = "Kara", ad = "Ahmet", yas = 35, departman = "Muhasebe") // Sıra önemli değil

    println("${p1.ad} ${p1.soyad}, Yaş: ${p1.yas}, Departman: ${p1.departman}")
    println("${p2.ad} ${p2.soyad}, Yaş: ${p2.yas}, Departman: ${p2.departman}")
    println("${p3.ad} ${p3.soyad}, Yaş: ${p3.yas}, Departman: ${p3.departman}")
    println("${p4.ad} ${p4.soyad}, Yaş: ${p4.yas}, Departman: ${p4.departman}")
}

Pratik Senaryolar ve En İyi Uygulamalar

Kotlin’in yapıcı metot esnekliği, farklı senaryolar için en uygun tasarımı seçme imkanı sunar.

Ne Zaman Birincil, Ne Zaman İkincil Yapıcı?

* Birincil Yapıcı: Çoğu durumda tercih edilen yöntemdir. Sınıfın temel özelliklerini doğrudan tanımlayarak kodun daha kısa ve okunabilir olmasını sağlar. Sınıfın ana işlevselliği için gerekli olan tüm parametreleri içerir. init blokları ile ek başlatma mantığı eklenebilir.
* İkincil Yapıcılar:
* Aşırı Yükleme: Nesneleri farklı parametre setleriyle oluşturma ihtiyacı olduğunda kullanılır. Örneğin, bir nesneyi minimum bilgiyle veya tüm detaylarıyla oluşturmak isteyebilirsiniz.
* Java Interoperability: Java koduyla etkileşimde bulunurken, Java’nın yapıcı aşırı yükleme modeline daha yakın bir yapı sunar.
* Karmaşık Başlatma: Bazen birincil yapıcı çok fazla parametre alabilir veya başlatma mantığı çok karmaşık olabilir. Bu durumda, daha basit bir birincil yapıcı tanımlayıp, ikincil yapıcıları kullanarak farklı başlatma senaryolarını ele almak faydalı olabilir.

Yapıcı Parametrelerinin Doğrulanması

Yapıcı metotlar, nesnenin geçerli bir durumda olduğundan emin olmak için parametre doğrulaması yapmak için ideal bir yerdir. Bu doğrulama genellikle init bloklarında yapılır.

class Hesap(val hesapNo: String, var bakiye: Double) {
    init {
        require(hesapNo.isNotBlank()) { "Hesap numarası boş olamaz." }
        require(bakiye >= 0) { "Bakiye negatif olamaz." }
    }
}

fun main() {
    val hesap1 = Hesap("TR12345", 100.0)
    // val hesap2 = Hesap("", 50.0) // Hata: Hesap numarası boş olamaz.
    // val hesap3 = Hesap("TR67890", -10.0) // Hata: Bakiye negatif olamaz.
}

require() ve check() gibi standart kütüphane fonksiyonları, koşul yanlışsa IllegalArgumentException veya IllegalStateException fırlatarak bu tür doğrulamaları kolaylaştırır.

Bağımlılık Enjeksiyonu (Dependency Injection)

Yapıcı enjeksiyonu, bağımlılık enjeksiyonu (DI) deseninin en yaygın ve önerilen şeklidir. Kotlin’de yapıcı metotlar, bir sınıfın ihtiyaç duyduğu bağımlılıkları dışarıdan almasını sağlamak için mükemmel bir yerdir. Bu, test edilebilirliği artırır ve kodun daha modüler olmasını sağlar.

interface Logger {
    fun log(message: String)
}

class KonsolLogger : Logger {
    override fun log(message: String) {
        println("LOG: $message")
    }
}

class Servis(private val logger: Logger) { // Bağımlılık yapıcı üzerinden enjekte edildi
    fun islemYap(veri: String) {
        logger.log("İşlem yapılıyor: $veri")
        // ...
    }
}

fun main() {
    val logger = KonsolLogger()
    val servis = Servis(logger) // Bağımlılık sağlanıyor
    servis.islemYap("Örnek Veri")
}

Fabrika Metotları (Factory Methods)

Bazen nesne oluşturma mantığı, basit bir yapıcı çağrısından daha karmaşık olabilir. Örneğin, nesneyi önbellekten almak, farklı alt sınıfların örneklerini döndürmek veya oluşturma sürecinde karmaşık hesaplamalar yapmak gerekebilir. Bu durumlarda, fabrika metotları kullanmak yapıcı metotlara iyi bir alternatif olabilir. Fabrika metotları, genellikle bir companion object içinde veya ayrı bir fabrika sınıfında tanımlanan statik metotlardır.

class Sekil private constructor(val tip: String, val boyut: Double) { // Private yapıcı

    companion object {
        fun kare(kenar: Double): Sekil {
            return Sekil("Kare", kenar * kenar)
        }

        fun daire(yaricap: Double): Sekil {
            return Sekil("Daire", Math.PI  yaricap  yaricap)
        }

        fun dikdortgen(en: Double, boy: Double): Sekil {
            return Sekil("Dikdörtgen", en * boy)
        }
    }

    override fun toString(): String {
        return "$tip (Alan: $boyut)"
    }
}

fun main() {
    val kare = Sekil.kare(5.0)
    val daire = Sekil.daire(3.0)
    val dikdortgen = Sekil.dikdortgen(4.0, 6.0)

    println(kare)
    println(daire)
    println(dikdortgen)
}

Bu örnekte, Sekil sınıfının yapıcı metodu private olarak işaretlenmiştir, bu da doğrudan Sekil() çağrısı ile nesne oluşturmayı engeller. Bunun yerine, companion object içinde tanımlanan fabrika metotları (kare, daire, dikdortgen) kullanılarak nesneler oluşturulur. Bu yaklaşım, nesne oluşturma mantığını merkezi bir yerde tutar ve daha esnek bir arayüz sunar.

Sonuç

Kotlin’in sınıf ve yapıcı metot mekanizmaları, dilin modern ve ifade gücü yüksek yapısının temelini oluşturur. Birincil yapıcıların sınıf başlığında tanımlanması ve val/var ile doğrudan özellik olarak kullanılabilmesi, kodun kısalığını ve okunabilirliğini artırır. init blokları, başlatma mantığını düzenli bir şekilde ele almayı sağlarken, ikincil yapıcılar farklı nesne oluşturma senaryolarına uyum sağlar. Miras alma durumunda temel sınıf yapıcılarını çağırma zorunluluğu, nesne hiyerarşisinin doğru bir şekilde başlatılmasını garanti eder. Data class’lar gibi özel sınıf türleri, yapıcı metotların gücünü kullanarak yaygın boilerplate kodunu ortadan kaldırır.

Bu özelliklerin doğru bir şekilde anlaşılması ve kullanılması, Kotlin geliştiricilerinin daha temiz, daha sürdürülebilir ve daha güvenilir uygulamalar yazmasına olanak tanır. Bağımlılık enjeksiyonu ve fabrika metotları gibi tasarım desenleriyle birleştiğinde, Kotlin’in yapıcı metotları, karmaşık sistemlerin bile kolayca yönetilebilmesini sağlayan güçlü bir araç seti sunar. Kotlin’de ustalaşmak isteyen her geliştirici için sınıflar ve yapıcı metotlar konusuna hakim olmak hayati öneme sahiptir.