C# OOP: Kapsülleme, Kalıtım ve Çok Biçimlilik Rehberi

Nesne Yönelimli Programlama (OOP), modern yazılım geliştirmenin temelini oluşturur ve C# dilinde güçlü bir şekilde desteklenir. Bu makalede, OOP'nin üç ana sütunu olan Kapsülleme (Encapsulation), Kalıtım (Inheritance) ve Çok Biçimlilik (Polymorphism) kavramlarını detaylı bir şekilde inceleyeceğiz. Bu C# OOP Temellerini anlamak, Unity projelerinizde daha düzenli, sürdürülebilir ve esnek kod yazmanızı sağlayacaktır.

Kapsülleme (Encapsulation): Veri Saklama Sanatı

Kapsülleme, bir nesnenin verilerini (alanlarını) ve bu veriler üzerinde işlem yapan metotlarını tek bir birimde (sınıfta) bir araya getirme ve dışarıdan doğrudan erişimi kısıtlama prensibidir. Temel amacı, bir nesnenin iç çalışma detaylarını dış dünyadan gizlemek ve böylece veri bütünlüğünü korumaktır.

Kapsülleme sayesinde, bir sınıfın iç yapısında değişiklik yaptığınızda, bu değişikliklerin sınıfın dışındaki kodları etkileme riskini minimize edersiniz. Bu, kodunuzu daha güvenli, bakımı kolay ve esnek hale getirir. C#'da kapsüllemeyi genellikle private erişim belirleyicisi ile alanları gizleyerek ve bu alanlara kontrollü erişim sağlamak için public özellikler (properties) veya metotlar (methods) kullanarak gerçekleştiririz.

Kapsülleme Nasıl Uygulanır?

En yaygın yöntem, alanları private olarak tanımlamak ve bu alanlara değer atamak veya değerlerini okumak için public özellikler kullanmaktır. Özellikler, get ve set erişimcileri ile veri üzerinde ek doğrulama veya işlem yapma imkanı sunar.

public class Oyuncu
{
    private string _ad; // Alan gizli
    private int _can;   // Alan gizli

    public string Ad // Özellik ile kontrollü erişim
    {
        get { return _ad; }
        set
        {
            if (string.IsNullOrWhiteSpace(value))
            {
                throw new ArgumentException("Oyuncu adı boş olamaz!");
            }
            _ad = value;
        }
    }

    public int Can // Özellik ile kontrollü erişim
    {
        get { return _can; }
        set
        {
            if (value < 0)
            {
                _can = 0;
            }
            else if (value > 100)
            {
                _can = 100;
            }
            else
            {
                _can = value;
            }
        }
    }

    public Oyuncu(string ad, int can)
    {
        Ad = ad; // Özellik set edici çağrılır
        Can = can; // Özellik set edici çağrılır
    }

    public void HasarAl(int miktar)
    {
        Can -= miktar; // İçeriden erişim
        Console.WriteLine($"{Ad} {miktar} hasar aldı. Kalan can: {Can}");
    }
}

Yukarıdaki örnekte, _ad ve _can alanları private olduğu için sınıf dışından doğrudan erişilemez. Bunun yerine, Ad ve Can özelliklerini kullanarak bu verilere kontrollü bir şekilde erişim sağlanır. set erişimcisinde yapılan kontroller, verinin her zaman geçerli bir durumda olmasını garanti eder. Bu, C# OOP Temellerinden biridir.

Pratik İpuçları (Kapsülleme)

• 1. Otomatik Özellikler (Auto-Implemented Properties) Kullanın: Eğer bir alan için özel bir get veya set mantığına ihtiyacınız yoksa, public int Can { get; set; } gibi otomatik özellikler kullanarak kodu daha kısa yazabilirsiniz. C# derleyicisi sizin için private bir arka alan oluşturur.
• 2. Sadece Okunur Özellikler: Bir özelliğin dışarıdan sadece okunmasını istiyorsanız, set erişimcisini private yapabilir veya tamamen kaldırabilirsiniz: public string Ad { get; private set; }. Bu, nesnenin oluşturulduktan sonra bazı değerlerinin değiştirilmesini engeller.
• 3. Veri Doğrulama: set erişimcileri içinde veri doğrulama mantığı ekleyerek nesnenizin her zaman geçerli bir durumda kalmasını sağlayın. Bu, hataları erken yakalamanıza yardımcı olur.

Kalıtım (Inheritance): Kod Tekrarını Önleme

Kalıtım, bir sınıfın (türetilmiş sınıf veya alt sınıf) başka bir sınıfın (taban sınıf veya üst sınıf) özelliklerini (alanlarını) ve davranışlarını (metotlarını) miras almasını sağlayan bir OOP prensibidir. Bu, "bir şey bir şeydir" (IS-A) ilişkisini temsil eder. Kalıtım, kod tekrarını azaltarak yeniden kullanılabilirliği artırır ve daha hiyerarşik, düzenli bir kod yapısı oluşturur.

Örneğin, bir Hayvan sınıfınız varsa, Kedi ve Köpek gibi sınıflar Hayvan sınıfından miras alabilir ve Hayvan sınıfının YemekYe() veya SesCikar() gibi metotlarını yeniden kullanabilirler. Bu, C# OOP Temelleri için kritik bir konudur.

Kalıtım Nasıl Uygulanır?

C#'ta kalıtım, türetilmiş sınıf adından sonra iki nokta üst üste : koyarak ve ardından taban sınıfın adını yazarak belirtilir.

public class Canli // Taban Sınıf
{
    public string Tur { get; set; }
    public int Yas { get; set; }

    public Canli(string tur, int yas)
    {
        Tur = tur;
        Yas = yas;
    }

    public virtual void HareketEt() // virtual keyword'ü override edilmeye izin verir
    {
        Console.WriteLine($"{Tur} hareket ediyor.");
    }
}

public class Hayvan : Canli // Hayvan, Canli'dan miras alır
{
    public string Ad { get; set; }

    public Hayvan(string ad, string tur, int yas) : base(tur, yas) // base keyword'ü ile taban sınıfın constructor'ı çağrılır
    {
        Ad = ad;
    }

    public override void HareketEt() // override keyword'ü ile taban sınıf metodu geçersiz kılınır
    {
        Console.WriteLine($"{Ad} adlı {Tur} koşuyor.");
    }

    public void SesCikar()
    {
        Console.WriteLine($"{Ad} ses çıkarıyor.");
    }
}

public class Insan : Canli // Insan da Canli'dan miras alır
{
    public string Isim { get; set; }

    public Insan(string isim, int yas) : base("İnsan", yas)
    {
        Isim = isim;
    }

    public override void HareketEt()
    {
        Console.WriteLine($"{Isim} adlı {Tur} yürüyor.");
    }

    public void Calis()
    {
        Console.WriteLine($"{Isim} çalışıyor.");
    }
}

Canli sınıfı bir taban sınıf olarak tanımlanmıştır. Hayvan ve Insan sınıfları ise Canli sınıfından miras alarak Tur ve Yas özelliklerini edinmişlerdir. virtual ve override anahtar kelimeleri, çok biçimlilik için zemin hazırlar ve bir taban sınıf metodunun türetilmiş sınıflarda farklı şekillerde uygulanmasını sağlar.

Pratik İpuçları (Kalıtım)

• 1. IS-A İlişkisi: Kalıtımı yalnızca "bir şey bir şeydir" ilişkisi mantıklı olduğunda kullanın. Örneğin, bir Araba bir Motor değildir; bir Arabanın bir Motoru vardır (has-a ilişkisi, kompozisyon). Yanlış kalıtım hiyerarşileri kodunuzu karmaşıklaştırır.
• 2. Tek Sorumluluk Prensibi: Taban sınıflarınızın çok fazla sorumluluğu olmamasına dikkat edin. Her sınıfın tek bir sorumluluğu olması, kodun daha anlaşılır ve bakımı kolay olmasını sağlar.
• 3. protected Kullanımı: Taban sınıfta sadece türetilmiş sınıfların erişebileceği, ancak dışarıdan gizli kalması gereken üyeler için protected erişim belirleyicisini kullanın.

Çok Biçimlilik (Polymorphism): Farklı Formlar, Aynı Arayüz

Çok biçimlilik, Yunanca "çok şekilli" anlamına gelir ve bir nesnenin farklı formlarda davranabilme yeteneğini ifade eder. OOP'de bu, farklı nesnelerin aynı mesajı farklı şekillerde yanıtlayabilmesi anlamına gelir. Bu, kodunuzu daha esnek, genişletilebilir ve modüler hale getirir. C#'da çok biçimlilik, genellikle metot geçersiz kılma (method overriding) ve arayüzler (interfaces) aracılığıyla elde edilir. Bu, C# OOP Temelleri arasında en güçlü olanlardan biridir.

Çok Biçimlilik Nasıl Uygulanır?

C#'da çok biçimliliğin en yaygın biçimi, taban sınıfta virtual olarak işaretlenmiş bir metodu türetilmiş sınıfta override anahtar kelimesiyle geçersiz kılmaktır. Bu sayede, taban sınıf referansı üzerinden türetilmiş sınıfın kendine özgü uygulamasını çağırabilirsiniz.

// Canli sınıfı ve HareketEt metodu yukarıda tanımlanmıştı.
// Tekrar yazmıyoruz, varsayalım ki Canli, Hayvan, Insan sınıfları tanımlı.

public class Program
{
    public static void Main(string[] args)
    {
        Canli canli1 = new Canli("Bitki", 5);
        Canli canli2 = new Hayvan("Tekir", "Kedi", 3); // Hayvan nesnesi, Canli referansı ile tutuluyor
        Canli canli3 = new Insan("Ayşe", 25); // Insan nesnesi, Canli referansı ile tutuluyor

        List<Canli> canlilar = new List<Canli> { canli1, canli2, canli3 };

        foreach (var c in canlilar)
        {
            c.HareketEt(); // Her nesne kendi HareketEt metodunu çağırır
        }

        // Çıktı:
        // Bitki hareket ediyor.
        // Tekir adlı Kedi koşuyor.
        // Ayşe adlı İnsan yürüyor.
    }
}

Yukarıdaki örnekte, canlilar listesi Canli tipinde nesneler tutabilmesine rağmen, liste içindeki Hayvan ve Insan nesneleri kendi HareketEt() metotlarını çağırır. Bu, çalışma zamanında hangi metodun çağrılacağına karar verilmesini sağlayan çalışma zamanı çok biçimliliğidir.

Pratik İpuçları (Çok Biçimlilik)

• 1. Arayüzler (Interfaces) Kullanın: Kalıtım hiyerarşisi oluşturmak istemediğiniz ancak farklı sınıfların belirli bir davranışı sergilemesini beklediğiniz durumlarda arayüzleri kullanın. Örneğin, IDamageable arayüzü uygulayan tüm nesneler TakeDamage() metoduna sahip olabilir.
• 2. Metot Aşırı Yükleme (Method Overloading): Aynı isme sahip, ancak farklı parametre listelerine sahip metotlar tanımlayarak da çok biçimlilik sağlayabilirsiniz. Bu, genellikle farklı veri tipleriyle veya farklı sayıda argümanla işlem yapmak için kullanılır (örneğin, Console.WriteLine() metodu).
• 3. Soyut Sınıflar (Abstract Classes): Ortak bir taban sınıf mantığı sağlamak ancak bu sınıfın doğrudan örneğinin oluşturulmasını engellemek istediğinizde soyut sınıfları kullanın. Soyut sınıflar, abstract metotlar içerebilir ve bu metotların türetilmiş sınıflar tarafından uygulanmasını zorunlu kılar.

Yaygın Hatalar ve Çözümleri

1. Kapsüllemeyi İhmal Etmek

Hata: Tüm alanları public yapmak. Bu, nesnenin iç durumunun dışarıdan doğrudan değiştirilmesine olanak tanır ve veri bütünlüğünü bozar.

Çözüm: Alanları private yapın ve erişimi public özellikler veya metotlar aracılığıyla sağlayın. Veri doğrulama mantığını özelliklerin set erişimcilerine ekleyin.

2. Yanlış Kalıtım Hiyerarjileri Oluşturmak

Hata: "IS-A" ilişkisi olmayan sınıflar arasında kalıtım kullanmak. Örneğin, bir Karenin bir Daireden miras alması gibi. Bu, mantıksız ve karmaşık bir yapıya yol açar.

Çözüm: Kalıtımı yalnızca güçlü bir "IS-A" ilişkisi olduğunda kullanın. Diğer durumlarda kompozisyonu (bir sınıfın başka bir sınıfın örneğini içermesi) tercih edin.

3. virtual ve override Anahtar Kelimelerini Unutmak

Hata: Taban sınıftaki bir metodu virtual olarak işaretlemeden türetilmiş sınıfta override etmeye çalışmak veya override etmeyi unutmak. Bu, beklenen çok biçimli davranışı engeller.

Çözüm: Taban sınıfta geçersiz kılınmasını istediğiniz metotları virtual olarak işaretleyin. Türetilmiş sınıfta bu metotları geçersiz kılarken override anahtar kelimesini kullanın.

Performans ve Optimizasyon Notları

OOP prensiplerinin kendisi genellikle önemli bir performans maliyeti getirmez. Ancak, bazı durumlar göz önünde bulundurulmalıdır:

• Sanal Metot Çağrıları (virtual/override): Sanal metot çağrıları, doğrudan metot çağrılarına göre çok küçük bir ek maliyete sahip olabilir (bir v-tablo araması). Çoğu uygulama için bu fark ihmal edilebilir düzeydedir. Ancak, performansın kritik olduğu ve binlerce kez tekrarlanan döngülerde bu durum göz önünde bulundurulabilir.
• Aşırı Derin Kalıtım Hiyerarşileri: Çok derin kalıtım zincirleri, kodun okunabilirliğini ve bakımını zorlaştırmanın yanı sıra, bazen nesne başlatma sürelerini hafifçe artırabilir. Genellikle 2-3 seviyeden fazla derinliğe sahip hiyerarşilerden kaçınmak iyi bir uygulamadır.

Genel olarak, kodun okunabilirliği, sürdürülebilirliği ve esnekliği, performans üzerindeki potansiyel küçük etkilerden daha önemlidir. Performans sorunları ortaya çıktığında optimize etmek, baştan karmaşık optimizasyonlar yapmaktan daha iyi bir yaklaşımdır. İyi tasarlanmış C# OOP Temellerine sahip bir sistem, genellikle optimize etmesi daha kolay olacaktır.

Sonuç

Kapsülleme, Kalıtım ve Çok Biçimlilik, C# ile nesne yönelimli programlama yaparken ustalaşmanız gereken temel kavramlardır. Bu prensipleri doğru bir şekilde uygulayarak, daha düzenli, bakımı kolay, esnek ve genişletilebilir Unity projeleri geliştirebilirsiniz. Bu C# OOP Temellerini anlamak, sizi daha yetkin bir yazılımcı yapacak ve kod kalitenizi önemli ölçüde artıracaktır.