Kapsülleme (Encapsulation)

Merhaba Arkadaşlar!

Bugünkü yazımızda nesne yönelimli programlamanın temel ilkelerinden biri olan Kapsülleme (Encapsulation) kavramını inceleyeceğiz. Unity ile oyun geliştirirken, bu kavramı anlamak kod yapınızı daha temiz ve güvenli hale getirmek açısından oldukça önemlidir. Kapsülleme, bir sınıfın verilerini ve fonksiyonlarını dış dünyadan gizlemeyi ve sadece gerekli bilgileri dışa açmayı sağlar.

Kapsülleme Nedir?

Kapsülleme, bir sınıfın iç işleyişini gizleyerek, yalnızca gerekli bilgileri dışarıya açmak anlamına gelir. Bu sayede, sınıf dışındaki kodların o sınıfın iç yapısına müdahale etmesi engellenir. Böylelikle, veri güvenliği ve tutarlılık sağlanmış olur.

Erişim Belirleyicileri: Public, Private, Protected

Kapsüllemeyi sağlamak için erişim belirleyicileri kullanırız. Erişim belirleyicileri, sınıf içindeki değişkenlerin ve fonksiyonların hangi düzeyde erişilebileceğini tanımlar:

1. Public: Her yerden erişilebilir. Genellikle, dış dünya ile etkileşimde olması gereken değişken ve metodlar public olarak tanımlanır.
2. Private: Sadece tanımlandığı sınıf içerisinden erişilebilir. Kapsülleme için en çok kullanılan erişim belirleyicisidir. Verileri dış dünyadan saklamak için kullanılır.
3. Protected: Sadece tanımlandığı sınıf ve o sınıftan türetilen alt sınıflar tarafından erişilebilir. Kalıtım işlemleri sırasında kullanılır.

Örnek: Kapsülleme Uygulaması

Şimdi bir kapsülleme örneği üzerinde çalışalım. Diyelim ki bir karakterin can (health) değeri var ve bu değerin oyun sırasında yalnızca belirli şartlarda değiştirilmesi gerekiyor. Can değerini doğrudan public olarak tanımlamak yerine, private yaparak yalnızca belirli fonksiyonlar aracılığıyla güncelleme yapılmasını sağlayabiliriz.

public class Character
{
    // Can değeri private olarak tanımlanıyor
    private int health = 100;
    // Can değerini dış dünyaya açan public bir metod
    public int GetHealth()
    {
        return health;
    }
    // Can değerini değiştiren metod
    public void TakeDamage(int damage)
    {
        if (damage > 0)
        {
            health -= damage;
            health = Mathf.Clamp(health, 0, 100); // Can değeri 0 ile 100 arasında sınırlandırılıyor
        }
    }
}        

Bu örnekte health değeri, sınıf dışından doğrudan erişilemez çünkü private olarak tanımlanmıştır. Ancak, public olarak tanımlanan GetHealth ve TakeDamage metodları aracılığıyla karakterin can değeri okunabilir ve güncellenebilir. Bu, can değerinin doğrudan ve hatalı bir şekilde değiştirilmesini engeller, dolayısıyla kapsülleme sağlanmış olur.

Protected Erişim Belirleyicisi ve Kalıtım

Eğer bir karakter sınıfımız var ve bu sınıftan türetilen bir “düşman” sınıfı oluşturmak istiyorsak, bazı değişkenlerin alt sınıflar tarafından kullanılmasına izin vermek isteyebiliriz. Bu durumda, protected erişim belirleyicisini kullanabiliriz.

public class Character
{
    // Protected can değeri, alt sınıflar tarafından erişilebilir
    protected int health = 100;
    public virtual void TakeDamage(int damage)
    {
        if (damage > 0)
        {
            health -= damage;
            health = Mathf.Clamp(health, 0, 100);
        }
    }
}
public class Enemy : Character
{
    public override void TakeDamage(int damage)
    {
        // Düşman özelinde farklı bir hesaplama
        base.TakeDamage(damage / 2); // Düşmanlar daha az hasar alır
    }
}
       

Bu örnekte, Enemy sınıfı Character sınıfından türemiştir. health değişkeni protected olduğu için Enemy sınıfı bu değişkene erişebilir ve üzerinde işlem yapabilir.

Kapsülleme, nesne yönelimli programlamanın en temel prensiplerinden biridir ve veri güvenliği ile kod yapısının düzenlenmesinde kritik rol oynar. Public, private ve protected gibi erişim belirleyicilerini doğru kullanarak, sınıflarınızın dış dünyadan nasıl etkilendiğini kontrol edebilir ve kodunuzu daha güvenli hale getirebilirsiniz. Bu prensip, hem küçük hem de büyük projelerde kodun sürdürülebilirliğini artırır.