Nesne Yönelimli Programlama (OOP): Modern Yazılımın Temeli

Bir sınıf, belirli bir türdeki nesnelerin ortak özelliklerini (nitelikler - attributes) ve davranışlarını (metotlar - methods) tanımlayan bir plan, şablon veya kalıptır. Soyut bir kavramdır ve kendi başına bellekte yer kaplamaz. Tıpkı bir araba tasarımı veya bir ev planı gibi düşünülebilir; gerçek arabayı veya evi değil, onların nasıl olacağını tanımlar.

Sınıf tanımı şunları içerir:

• Sınıf Adı: Sınıfı tanımlayan isim (genellikle büyük harfle başlar ve CamelCase kullanılır).
• Nitelikler (Attributes/Fields/Properties): Sınıftan türetilecek nesnelerin sahip olacağı veriler veya özelliklerdir. Örneğin, bir Araba sınıfı için renk, model, hiz gibi nitelikler tanımlanabilir.
• Metotlar (Methods/Behaviors): Sınıftan türetilecek nesnelerin gerçekleştirebileceği eylemler veya davranışlardır. Nitelikler üzerinde işlem yapabilirler. Örneğin, bir Araba sınıfı için hizlan(), yavasla(), bilgiGoster() gibi metotlar tanımlanabilir.
• Yapıcı Metot (Constructor): Sınıftan yeni bir nesne oluşturulduğunda otomatik olarak çağrılan özel bir metottur. Genellikle nesnenin başlangıç niteliklerini ayarlamak için kullanılır.

Örnek (Python):

class Kopek:
    # Yapıcı Metot (__init__)
    def __init__(self, isim, cins):
        # Nitelikler (instance attributes)
        self.ad = isim
        self.cins = cins
        self.enerji = 100 # Başlangıç enerjisi
        print(f"{self.ad} ({self.cins}) dünyaya geldi!")

    # Metotlar (instance methods)
    def havla(self):
        if self.enerji > 10:
            print(f"{self.ad}: Hav hav!")
            self.enerji -= 10
        else:
            print(f"{self.ad} havlamak için çok yorgun.")

    def kos(self, mesafe):
        tukenen_enerji = mesafe * 5
        if self.enerji >= tukenen_enerji:
            print(f"{self.ad} {mesafe} metre koştu.")
            self.enerji -= tukenen_enerji
        else:
            print(f"{self.ad} koşmak için yeterli enerjisi yok.")

    def dinlen(self):
        print(f"{self.ad} dinleniyor...")
        self.enerji = 100 # Enerjiyi doldur
                     

Bir nesne, bir sınıfın bellekte oluşturulmuş somut bir örneğidir. Sınıf, planı temsil ederken, nesne o plana göre inşa edilmiş gerçek varlıktır. Her nesne, sınıf tanımında belirtilen niteliklerin kendi kopyalarına ve metotlara erişime sahiptir. Aynı sınıftan birden fazla nesne oluşturulabilir ve her nesnenin nitelikleri birbirinden bağımsız değerlere sahip olabilir.

Nesneler genellikle new anahtar kelimesi (C#, Java gibi dillerde) veya sınıf adını fonksiyon gibi çağırarak (Python'da) oluşturulur. Bu işlem "örnekleme" (instantiation) olarak adlandırılır ve sınıfın yapıcı metodunu (constructor) çağırır.

Örnek (Python - önceki Kopek sınıfını kullanarak):

# Kopek sınıfından nesneler oluşturma
kopek1 = Kopek("Karabaş", "Sivas Kangalı") # __init__ çağrılır
kopek2 = Kopek("Fındık", "Terrier")     # __init__ çağrılır

# Nesnelerin nitelikleri farklı olabilir
print(f"{kopek1.ad}'ın cinsi: {kopek1.cins}") # Sivas Kangalı
print(f"{kopek2.ad}'ın cinsi: {kopek2.cins}") # Terrier

# Nesneler üzerinden metotları çağırma
kopek1.havla()
kopek2.kos(15)
kopek1.dinlen()
kopek2.havla()

print(f"{kopek1.ad} Enerji: {kopek1.enerji}") # 100 (dinlendi)
print(f"{kopek2.ad} Enerji: {kopek2.enerji}") # 100 - 15*5 = 25
                    

Örnek (C#):

public class Kopek
{
    public string Ad { get; set; }
    public string Cins { get; set; }
    public int Enerji { get; private set; } // Dışarıdan sadece okunabilir

    public Kopek(string isim, string cins) // Constructor
    {
        this.Ad = isim;
        this.Cins = cins;
        this.Enerji = 100;
        Console.WriteLine($"{this.Ad} ({this.Cins}) dünyaya geldi!");
    }

    public void Havla() { /* ... */ }
    public void Kos(int mesafe) { /* ... */ }
    public void Dinlen() { this.Enerji = 100; /* ... */ }
}

// Nesne Oluşturma
Kopek kopek1 = new Kopek("Karabaş", "Sivas Kangalı");
Kopek kopek2 = new Kopek("Fındık", "Terrier");

kopek1.Havla();
Console.WriteLine($"{kopek2.Ad} Enerji: {kopek2.Enerji}");
                    

Sınıf ve nesne kavramları, veriyi ve o veri üzerinde çalışan fonksiyonları mantıksal birimler halinde bir araya getirerek OOP'nin temelini oluşturur.

OOP dillerinde, bir sınıfın metotları içinde, o an üzerinde işlem yapılan nesnenin kendisine referans vermek için özel bir anahtar kelime kullanılır.

• Python'da self: Sınıf içindeki metotların ilk parametresi olarak açıkça yazılır (geleneksel olarak self adı verilir). Python, metot çağrıldığında bu ilk parametreye otomatik olarak nesne referansını atar. Nesnenin niteliklerine (self.nitelik_adi) ve diğer metotlarına (self.metot_adi()) erişmek için kullanılır.
• C#, Java, JavaScript'te this: Metot içinde örtük (implicit) olarak bulunur, parametre olarak yazılmaz. Nesnenin kendi üyelerine (alanlar, özellikler, metotlar) erişmek için kullanılır (this.nitelikAdi, this.metotAdi()). Bazen isim çakışmalarını çözmek (parametre adı ile nitelik adı aynıysa) veya bir yapıcı metottan başka bir yapıcı metodu çağırmak için açıkça kullanılması gerekebilir.

Her iki anahtar kelime de temelde aynı amaca hizmet eder: Metotun hangi nesne üzerinde çalıştığını belirtmek ve o nesnenin üyelerine erişimi sağlamak.

# Python örneği (yukarıdaki Kopek sınıfından)
class Kopek:
    def __init__(self, isim, cins):
        self.ad = isim # 'self' ile nesnenin 'ad' niteliğine erişiliyor
        self.cins = cins

    def bilgi_ver(self):
        # 'self' ile aynı nesnenin 'ad' ve 'cins' niteliklerine erişiliyor
        print(f"Benim adım {self.ad}, cinsim {self.cins}.")
                     

// C# örneği
public class Kopek
{
    public string Ad { get; set; }
    public string Cins { get; set; }

    public Kopek(string Ad, string Cins) // Parametre isimleri özellik isimleri ile aynı
    {
        // 'this' kullanarak sınıf üyesi olan Ad/Cins ile parametre olan Ad/Cins'i ayır
        this.Ad = Ad;
        this.Cins = Cins;
    }

    public void BilgiVer()
    {
        // 'this' burada zorunlu değil ama kullanılabilir
        Console.WriteLine($"Benim adım {this.Ad}, cinsim {this.Cins}.");
    }
}
                     

Kapsüllemenin önemli bir yönü veri gizlemedir. Bu, bir nesnenin niteliklerine (alanlarına) dışarıdan doğrudan erişimi kısıtlamak anlamına gelir. Neden önemlidir?

• Veri Bütünlüğü: Niteliklere doğrudan erişim, geçersiz veya anlamsız değerlerin atanmasına yol açabilir. Örneğin, bir yas niteliğine negatif bir değer atanması veya bir email niteliğine geçersiz formatta bir string atanması engellenebilir.
• Esneklik ve Bakım Kolaylığı: Nesnenin iç veri yapısı veya implementasyon detayları değiştirildiğinde (refactoring), bu değişikliğin nesneyi kullanan dış kodu etkileme olasılığı azalır. Dış kod, nesnenin public arayüzüne (metotlar, özellikler) bağımlı kalır.
• Karmaşıklığın Azaltılması: Nesneyi kullanan geliştiricinin, nesnenin iç işleyişinin tüm detaylarını bilmesi gerekmez. Sadece public arayüzü kullanarak nesneyle etkileşim kurabilir.

Veri gizleme, erişim belirleyiciler (access modifiers) veya isimlendirme kuralları (Python'da olduğu gibi) ile sağlanır.

C#, Java gibi dillerde, sınıf üyelerinin (alanlar, özellikler, metotlar, sınıflar) nereden erişilebileceğini kontrol etmek için erişim belirleyici anahtar kelimeler kullanılır:

• public: Üyeye her yerden (aynı sınıf, alt sınıflar, farklı paketler/assembly'ler) erişilebilir. En az kısıtlayıcı seviyedir.
• private: Üyeye sadece tanımlandığı sınıfın içinden erişilebilir. Alt sınıflardan veya dışarıdan erişilemez. En kısıtlayıcı seviyedir ve veri gizleme için varsayılan tercihtir.
• protected: Üyeye tanımlandığı sınıfın içinden ve o sınıftan türetilmiş alt sınıflardan erişilebilir. Dışarıdan erişilemez. Kalıtım hiyerarşisi içinde paylaşım için kullanılır.
• internal (C#): Üyeye sadece tanımlandığı aynı assembly (proje veya kütüphane) içinden erişilebilir. Farklı assembly'lerden erişilemez.
• protected internal (C#): Hem protected hem de internal erişimine izin verir (aynı assembly içinden veya farklı assembly'deki alt sınıflardan).
• Python'da Durum: Python'da C# veya Java'daki gibi katı erişim belirleyiciler yoktur. Erişimi kontrol etmek için isimlendirme kuralları kullanılır:
  • Normal İsim (nitelik): Public kabul edilir.
  • Tek Alt Çizgi (_nitelik): "Internal use only" veya "protected" anlamına gelen bir konvansiyondur (kuraldır). Geliştiriciye bu üyeye dışarıdan doğrudan erişmemesi gerektiğini belirtir, ancak Python bunu teknik olarak engellemez.
  • Çift Alt Çizgi (__nitelik): "Private" anlamına gelir. Python, isim mangling (_SinifAdi__nitelik) uygulayarak dışarıdan ve alt sınıflardan doğrudan erişimi zorlaştırır, ancak tamamen engellemez.

Örnek (C#):

public class BankaHesabi
{
    private string hesapSahibi; // Sadece sınıf içinden erişilebilir
    private decimal bakiye;    // Sadece sınıf içinden erişilebilir
    public string HesapNo { get; private set; } // Dışarıdan okunabilir, sadece içeriden atanabilir

    public BankaHesabi(string sahip, string hesapNo, decimal ilkBakiye = 0)
    {
        this.hesapSahibi = sahip;
        this.HesapNo = hesapNo; // Public property'ye atama
        if (ilkBakiye >= 0)
        {
            this.bakiye = ilkBakiye;
        } else {
            this.bakiye = 0;
        }
    }

    public decimal BakiyeSorgula() // Public metot
    {
        // 'bakiye' private alana erişim
        return this.bakiye;
    }

    public bool ParaYatir(decimal miktar) // Public metot
    {
        if (miktar <= 0) return false;
        this.bakiye += miktar; // private alanı değiştirme
        return true;
    }

    public bool ParaCek(decimal miktar) // Public metot
    {
        if (miktar <= 0 || miktar > this.bakiye) return false;
        this.bakiye -= miktar; // private alanı değiştirme
        return true;
    }

    // Bu metoda dışarıdan erişilemez
    private void Logla(string mesaj)
    {
        Console.WriteLine($"LOG [{DateTime.Now}]: {mesaj}");
    }
}

// Kullanım:
BankaHesabi hesap = new BankaHesabi("Ali Veli", "12345", 500m);
// hesap.bakiye = 1000000; // Hata! 'bakiye' private olduğu için erişilemez.
// hesap.hesapSahibi = "Başka Biri"; // Hata! 'hesapSahibi' private.
// hesap.HesapNo = "9876"; // Hata! set'i private.

Console.WriteLine($"Hesap No: {hesap.HesapNo}"); // Okunabilir
decimal mevcutBakiye = hesap.BakiyeSorgula(); // Public metotla erişim
Console.WriteLine($"Mevcut Bakiye: {mevcutBakiye:C}");
hesap.ParaYatir(200m);
hesap.ParaCek(150m);
Console.WriteLine($"Yeni Bakiye: {hesap.BakiyeSorgula():C}");
                     

Private alanlara kontrollü erişim sağlamak için public metotlar veya özellikler kullanılır:

• Getter Metotları: Private bir alanın değerini okuyup döndüren public metotlardır (örn: GetBakiye()).
• Setter Metotları: Private bir alana değer atayan public metotlardır. Bu metotlar içinde genellikle gelen değerin geçerliliği kontrol edilir (örn: SetYas(int yeniYas)).
• Özellikler (Properties - C#, Python): Getter ve setter metotlarının daha zarif ve okunabilir bir şekilde uygulanmasını sağlayan dil özellikleridir. Dışarıdan normal bir alana erişir gibi görünürler (nesne.OzellikAdi) ancak arka planda getter (değer okunduğunda) ve setter (değer atandığında) metotları çalışır.
  • C#'ta Properties: get ve set blokları ile tanımlanır. Erişim belirleyicileri (private set gibi) ile kontrol daha da artırılabilir. Otomatik uygulanan özellikler (public string Ad { get; set; }) arka planda private bir alan ve basit getter/setter oluşturur.
  • Python'da Properties: @property, @*.setter, @*.deleter decorator'ları ile tanımlanır.

Özellikler, kapsülleme ilkesini uygularken kodun daha temiz ve doğal görünmesini sağlar.

Yukarıdaki C# BankaHesabi örneğinde HesapNo ve Python Calisan örneğinde maas ve departman özellikleri (property) kullanılarak kapsülleme sağlanmıştır.

• Üst Sınıf (Superclass / Base Class / Parent Class): Özellikleri ve davranışları miras alınan sınıftır. Daha genel bir kavramı temsil eder.
• Alt Sınıf (Subclass / Derived Class / Child Class): Üst sınıftan miras alan sınıftır. Üst sınıfın özelliklerini devralır ve kendi özel özelliklerini veya davranışlarını ekleyebilir veya miras aldığı bazı davranışları değiştirebilir (override). Daha özel bir kavramı temsil eder.

Örneğin:

• Hayvan (Üst Sınıf) -> Kedi (Alt Sınıf), Kopek (Alt Sınıf)
• Tasit (Üst Sınıf) -> Araba (Alt Sınıf), Motosiklet (Alt Sınıf)
• Sekil (Üst Sınıf) -> Daire (Alt Sınıf), Kare (Alt Sınıf)

Alt sınıf, üst sınıfın bir türüdür ("Kedi bir Hayvan'dır"). Bu sayede, üst sınıf türünden bir değişken, alt sınıf türünden bir nesneyi referans edebilir (bu, çok biçimliliğin temelidir).

Farklı dillerde kalıtım farklı anahtar kelimelerle ifade edilir:

• Java, JavaScript (ES6 Classes): class AltSinif extends UstSinif { ... }
• C#: class AltSinif : UstSinif { ... }
• Python: class AltSinif(UstSinif): ...

Alt sınıfın yapıcı metodunda (constructor), genellikle üst sınıfın yapıcı metodunu çağırarak miras alınan özelliklerin başlatılması gerekir:

• Java, JavaScript: super(ust_sinif_argumanlari);
• C#: public AltSinif(...) : base(ust_sinif_argumanlari) { ... }
• Python: super().__init__(ust_sinif_argumanlari) veya UstSinif.__init__(self, ust_sinif_argumanlari)

Örnek (Python):

class Calisan:
    def __init__(self, ad, maas):
        self.ad = ad
        self.maas = maas
        print(f"Çalışan {self.ad} oluşturuldu.")

    def bilgileri_goster(self):
        print(f"Ad: {self.ad}, Maaş: {self.maas}")

class Yonetici(Calisan): # Calisan'dan miras al
    def __init__(self, ad, maas, departman):
        super().__init__(ad, maas) # Üst sınıfın __init__'ini çağır
        self.departman = departman # Yeni özellik ekle
        print(f"Yönetici {self.ad} oluşturuldu.")

    # Miras alınan metodu override etme
    def bilgileri_goster(self):
        super().bilgileri_goster() # Üst sınıfın metodunu çağır
        print(f"Departman: {self.departman}") # Ek bilgi yazdır

    # Yeni metot
    def toplanti_yap(self):
        print(f"{self.ad} ({self.departman}) toplantı yapıyor.")

calisan1 = Calisan("Ali", 5000)
yonetici1 = Yonetici("Ayşe", 8000, "İK")

calisan1.bilgileri_goster()
print("-" * 10)
yonetici1.bilgileri_goster() # Override edilmiş metot çalışır
yonetici1.toplanti_yap()   # Sadece Yonetici'ye özgü metot
# calisan1.toplanti_yap() # Hata! Calisan sınıfında bu metot yok
                      

Bir alt sınıfın, üst sınıftan miras aldığı bir metodun implementasyonunu kendi ihtiyacına göre değiştirmesidir. Alt sınıfta, üst sınıftaki metotla aynı isimde, aynı parametre listesine (ve genellikle aynı dönüş tipine) sahip yeni bir metot tanımlanır.

• C#'ta: Üst sınıftaki metodun virtual veya abstract olarak işaretlenmesi, alt sınıftaki metodun ise override anahtar kelimesi ile işaretlenmesi gerekir.
• Java'da: Alt sınıftaki metot aynı imzaya sahipse otomatik olarak override eder. @Override anotasyonu kullanmak, derleyiciye niyetinizi belirtmek ve hataları önlemek için iyi bir pratiktir.
• Python'da: Özel bir anahtar kelime gerekmez. Alt sınıfta aynı isimde bir metot tanımlamak yeterlidir.

Override etme, çok biçimliliğin (polymorphism) temelini oluşturur. Üst sınıf türünden bir referans, alt sınıf nesnesini tuttuğunda ve override edilmiş bir metot çağrıldığında, alt sınıftaki metot çalıştırılır.

Yukarıdaki Python Yonetici sınıfı örneğinde bilgileri_goster metodu override edilmiştir.

Avantajları:

• Kod Yeniden Kullanımı: Ortak özellikler ve davranışlar üst sınıfta bir kez tanımlanır ve alt sınıflar tarafından tekrar kullanılır.
• Genişletilebilirlik: Mevcut bir sınıfı değiştirmeden yeni alt sınıflar oluşturarak sisteme yeni işlevsellikler eklenebilir (Açık/Kapalı Prensibi'ne yardımcı olur).
• Hiyerarşik Yapı: Gerçek dünyadaki ilişkileri modelleyerek kodun daha organize ve anlaşılır olmasını sağlar.
• Çok Biçimlilik Desteği: Farklı alt sınıfların aynı metot çağrısına farklı şekillerde yanıt vermesini sağlar.

Dezavantajları ve Dikkat Edilmesi Gerekenler:

• Sıkı Bağlılık (Tight Coupling): Alt sınıf, üst sınıfın implementasyon detaylarına (özellikle protected üyelere) bağımlı hale gelebilir. Üst sınıfta yapılan bir değişiklik, tüm alt sınıfları etkileyebilir ("Fragile Base Class" problemi).
• Yanlış Kullanım: Kalıtım sadece "is-a" ilişkisi mantıklı olduğunda kullanılmalıdır. "Has-a" (sahip olma) ilişkisi için kalıtım yerine Kompozisyon (Composition) veya Agregasyon (Aggregation) tercih edilmelidir.
• Çoklu Kalıtım Sorunları: Bazı dillerde (C++, Python) desteklenen çoklu kalıtım (bir sınıfın birden fazla sınıftan miras alması), "Diamond Problem" gibi karmaşıklıklara yol açabilir. C# ve Java gibi diller bu nedenle doğrudan çoklu sınıf kalıtımına izin vermez (ancak çoklu arayüz implementasyonuna izin verir).

Kalıtım güçlü bir araçtır ancak dikkatli kullanılmalıdır. Alternatif olarak Kompozisyon (nesneleri başka nesnelerin içinde kullanma) genellikle daha esnek ve daha az kırılgan tasarımlar sunar ("Favor Composition Over Inheritance" prensibi).

En yaygın ve güçlü çok biçimlilik türüdür. Kalıtım hiyerarşisi içinde, bir üst sınıf referans değişkeninin, çalışma zamanında farklı alt sınıf nesnelerini işaret edebilmesi ve çağrılan metodun, referansın türüne değil, nesnenin gerçek türüne göre belirlenmesi prensibine dayanır. Bu, metot geçersiz kılma (method overriding) ile sağlanır.

Özellikleri:

• Üst sınıfta bir metot virtual (C#) veya normal (Java, Python - override edilebilir olmalı) olarak tanımlanır.
• Alt sınıflar bu metodu kendi ihtiyaçlarına göre override ederler.
• Üst sınıf türünden bir referans veya koleksiyon (örn: List) farklı alt sınıf nesnelerini (Kedi, Kopek) tutabilir.
• Bu referans üzerinden override edilmiş metot çağrıldığında, hangi alt sınıfın metodunun çalışacağı çalışma zamanında belirlenir (geç bağlama - late binding).

Örnek (Python):

class Hayvan:
    def __init__(self, ad):
        self.ad = ad
    def ses_cikar(self): # Override edilecek metot
        print("Hayvan sesi...")

class Kedi(Hayvan):
    def ses_cikar(self): # Override etme
        print(f"{self.ad}: Miyav!")

class Kopek(Hayvan):
    def ses_cikar(self): # Override etme
        print(f"{self.ad}: Hav hav!")

# Üst sınıf türünden referanslar farklı alt sınıf nesnelerini tutuyor
hayvanlar = [
    Kedi("Tekir"),
    Kopek("Karabaş"),
    Hayvan("Genel Hayvan"), # Üst sınıf nesnesi
    Kedi("Pamuk")
]

# Tüm hayvanların ses çıkarmasını isteyelim
print("Hayvan sesleri:")
for hayvan in hayvanlar:
    # Hangi ses_cikar metodunun çağrılacağı çalışma zamanında belirlenir
    hayvan.ses_cikar()

# Çıktı:
# Hayvan sesleri:
# Tekir: Miyav!
# Karabaş: Hav hav!
# Hayvan sesi...
# Pamuk: Miyav!
                     

Örnek (C#):

public class Hayvan
{
    public string Ad { get; set; }
    public virtual void SesCikar() // virtual olmalı
    {
        Console.WriteLine("Hayvan sesi...");
    }
}
public class Kedi : Hayvan
{
    public override void SesCikar() // override edilmeli
    {
        Console.WriteLine($"{Ad}: Miyav!");
    }
}
public class Kopek : Hayvan
{
    public override void SesCikar() // override edilmeli
    {
         Console.WriteLine($"{Ad}: Hav hav!");
    }
}

// Kullanım
List hayvanlar = new List
{
    new Kedi { Ad = "Tekir" },
    new Kopek { Ad = "Karabaş" },
    new Hayvan { Ad = "Genel" },
    new Kedi { Ad = "Pamuk" }
};

Console.WriteLine("Hayvan sesleri:");
foreach (Hayvan h in hayvanlar)
{
    h.SesCikar(); // Çalışma zamanında doğru metot çağrılır
}
                     

Çalışma zamanı çok biçimliliği, kodun yeni hayvan türleri eklendiğinde bile ana döngüyü değiştirmeden çalışmasını sağlar (Genişletilebilirlik).

Aynı isimde ancak farklı parametre listelerine (parametre sayısı, türü veya sırası farklı) sahip birden fazla metodun aynı sınıf içinde tanımlanmasıdır. Hangi metodun çağrılacağına, fonksiyona geçirilen argümanların türüne ve sayısına göre derleme zamanında karar verilir (erken bağlama - early binding).

Bu, aynı temel işlemi farklı veri tipleri veya farklı sayıda girdi ile yapabilen metotlar oluşturmayı sağlar.

Örnek (C#):

public class Hesaplayici
{
    public int Topla(int a, int b)
    {
        Console.WriteLine("İki int toplandı.");
        return a + b;
    }

    // Aynı isim, farklı parametre türleri
    public double Topla(double a, double b)
    {
        Console.WriteLine("İki double toplandı.");
        return a + b;
    }

    // Aynı isim, farklı parametre sayısı
     public int Topla(int a, int b, int c)
    {
        Console.WriteLine("Üç int toplandı.");
        return a + b + c;
    }
}

// Kullanım
Hesaplayici calc = new Hesaplayici();
calc.Topla(5, 3);      // İlk metot çağrılır
calc.Topla(2.5, 3.7);  // İkinci metot çağrılır
calc.Topla(1, 2, 3);   // Üçüncü metot çağrılır
                    

Python, doğrudan metot overloading'i C# veya Java gibi desteklemez. Aynı isimde birden fazla metot tanımlarsanız, son tanımlanan önceki tanımları geçersiz kılar. Python'da benzer davranışlar genellikle varsayılan parametre değerleri, *args, **kwargs veya tip kontrolü (isinstance) ile elde edilir.

Python gibi dinamik tipli dillerde yaygın olan bir çok biçimlilik anlayışıdır. Bir nesnenin tipinden ziyade, sahip olduğu metotlara ve özelliklere odaklanır. "Eğer ördek gibi yürüyorsa ve ördek gibi vaklıyorsa, o bir ördektir" sözü bu yaklaşımı özetler.

Bir fonksiyon veya metot, kendisine geçirilen nesnenin belirli bir sınıftan miras alıp almadığına bakmaksızın, ihtiyaç duyduğu metotlara (örneğin konus() veya __len__()) sahip olup olmadığını kontrol eder. Eğer nesne beklenen davranışları sergileyebiliyorsa (gerekli metotlara sahipse), fonksiyon o nesne ile çalışabilir.

class Kedi:
    def konus(self): return "Miyav"
class Kopek:
    def konus(self): return "Hav hav"
class Araba:
    def korna_cal(self): return "Düt düt" # Farklı metot adı
class Insan:
     def konus(self): return "Merhaba"

def konustur(nesne):
    # Nesnenin tipine bakmadan 'konus' metodu var mı diye kontrol et
    if hasattr(nesne, 'konus') and callable(getattr(nesne, 'konus')):
        print(nesne.konus())
    else:
        print("Bu nesne konuşamıyor.")

konustur(Kedi())   # Miyav
konustur(Kopek())  # Hav hav
konustur(Araba())  # Bu nesne konuşamıyor.
konustur(Insan())  # Merhaba
                     

Duck Typing, kodu daha esnek hale getirir ancak tip güvenliğini azaltabilir. Dikkatli kullanılmalı ve nesnelerin beklenen arayüze uyup uymadığı kontrol edilmelidir.

Soyut sınıflar, hem soyut (implementasyonu olmayan, abstract anahtar kelimesiyle işaretlenmiş) hem de somut (implementasyonu olan) üyeler (metotlar, özellikler) içerebilen sınıflardır. Temel özellikleri:

• Doğrudan nesnesi oluşturulamaz (new ile örneklenemez).
• Sadece başka sınıflar tarafından kalıtım alınmak (türetilmek) için tasarlanmışlardır.
• Alt sınıflar, üst sınıftaki tüm soyut üyeleri (metotları) override etmek zorundadır.
• Somut metotları sayesinde alt sınıflara ortak bir implementasyon sağlayabilirler.
• Bir sınıf, C# ve Java'da sadece tek bir soyut sınıftan kalıtım alabilir. Python'da abc (Abstract Base Classes) modülü ile benzer bir yapı kurulur.

Soyut sınıflar, bir grup ilişkili sınıf için ortak bir temel ve bir "şablon" sağlamak istendiğinde, ancak bazı davranışların alt sınıflara bırakılması gerektiğinde kullanılır.

Örnek (C#):

// Soyut Sınıf
public abstract class Sekil
{
    public string Renk { get; set; }

    // Soyut Metot (Gövdesi yok, alt sınıflar implemente etmek zorunda)
    public abstract double AlanHesapla();

    // Soyut Özellik (Alt sınıflar implemente etmek zorunda)
    public abstract double CevreHesapla();

    // Somut Metot (Ortak davranış)
    public virtual void BilgiYazdir() // virtual: override edilebilir ama zorunlu değil
    {
        Console.WriteLine($"Renk: {Renk}, Alan: {AlanHesapla():F2}, Çevre: {CevreHesapla():F2}");
    }
}

// Alt Sınıf 1
public class Daire : Sekil
{
    public double YariCap { get; set; }

    public Daire(double r, string renk) { this.YariCap = r; this.Renk = renk; }

    public override double AlanHesapla() // Zorunlu override
    {
        return Math.PI * YariCap * YariCap;
    }

    public override double CevreHesapla() // Zorunlu override
    {
        return 2 * Math.PI * YariCap;
    }
}

// Alt Sınıf 2
public class Dikdortgen : Sekil
{
    public double Genislik { get; set; }
    public double Yukseklik { get; set; }

     public Dikdortgen(double g, double y, string renk) { this.Genislik = g; this.Yukseklik = y; this.Renk = renk; }

    public override double AlanHesapla() // Zorunlu override
    {
        return Genislik * Yukseklik;
    }
     public override double CevreHesapla() // Zorunlu override
    {
        return 2 * (Genislik + Yukseklik);
    }

    // Üst sınıfın virtual metodunu override etme
    public override void BilgiYazdir()
    {
        Console.WriteLine($"Dikdörtgen - Renk: {Renk}, Alan: {AlanHesapla()}, Çevre: {CevreHesapla()}");
    }
}

// Kullanım
// Sekil s = new Sekil(); // Hata! Soyut sınıftan nesne oluşturulamaz.

Sekil daire = new Daire(5, "Mavi");
Sekil dikdortgen = new Dikdortgen(4, 6, "Kırmızı");

daire.BilgiYazdir();
dikdortgen.BilgiYazdir(); // Dikdörtgenin override ettiği metot çalışır
                    

Arayüzler, bir sınıfın sahip olması gereken public üyelerin (metotlar, özellikler, olaylar, indexer'lar) imzalarını tanımlayan bir sözleşmedir (contract). Hiçbir implementasyon içermezler (C# 8.0+ ve Java 8+ ile varsayılan metot implementasyonları mümkün olsa da, temel amaç sözleşmedir).

• Bir sınıf, bir veya birden fazla arayüzü uygulayabilir (implement edebilir). Bu, çoklu kalıtımın getirebileceği sorunlar olmadan, bir sınıfın birden fazla "rol" veya "yeteneğe" sahip olmasını sağlar.
• Arayüzü uygulayan sınıf, arayüzdeki tüm üyeleri (metotları, özellikleri vb.) implemente etmek (gövdesini yazmak) zorundadır.
• Arayüzler, farklı sınıflar arasında gevşek bağlılık (loose coupling) oluşturmak için kullanılır. Kod, belirli bir sınıf implementasyonuna değil, arayüz sözleşmesine bağımlı hale gelir. Bu, sistemin daha esnek ve değiştirilebilir olmasını sağlar.
• Arayüz isimleri genellikle 'I' harfi ile başlar (C# konvansiyonu).

Örnek (C#):

// Arayüz Tanımı
public interface IYazdirilabilir
{
    void Yazdir(); // Metot imzası
    string Baslik { get; } // Sadece okunabilir özellik imzası
}

public interface ISifrelenebilir
{
    string Sifrele(string veri);
    string SifreCoz(string sifreliVeri);
}

// Arayüzleri Uygulayan Sınıf
public class Rapor : IYazdirilabilir, ISifrelenebilir // Birden fazla arayüz
{
    public string RaporAdi { get; set; }
    private string icerik;

    public Rapor(string ad, string icerik)
    {
        this.RaporAdi = ad;
        this.icerik = icerik;
    }

    // IYazdirilabilir implementasyonu
    public string Baslik => $"Rapor: {RaporAdi}"; // Özellik implementasyonu

    public void Yazdir()
    {
        Console.WriteLine($"--- {Baslik} ---");
        Console.WriteLine(icerik);
        Console.WriteLine("--- Rapor Sonu ---");
    }

    // ISifrelenebilir implementasyonu
    public string Sifrele(string veri)
    {
        Console.WriteLine("Veri basitçe şifreleniyor...");
        return Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes(veri));
    }

     public string SifreCoz(string sifreliVeri)
    {
        Console.WriteLine("Şifre çözülüyor...");
         try {
            return System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(sifreliVeri));
         } catch { return "Çözme Başarısız!"; }
    }
}

// Başka bir sınıf
public class Eposta : IYazdirilabilir
{
     public string Konu { get; set; }
     public string Alici { get; set; }
     public string Govde { get; set; }

     public string Baslik => $"E-posta: {Konu}";

     public void Yazdir()
     {
         Console.WriteLine($"Kime: {Alici}\nKonu: {Konu}\n{Govde}");
     }
}


// Kullanım
public class Yazdirici
{
    // Metot, belirli bir sınıf yerine arayüzü kabul ediyor (Gevşek Bağlılık)
    public void BelgeYazdir(IYazdirilabilir belge)
    {
        Console.WriteLine($"\n'{belge.Baslik}' yazdırılıyor...");
        belge.Yazdir();
    }
}

Rapor rapor1 = new Rapor("Aylık Satış", "Satışlar iyi durumda...");
Eposta eposta1 = new Eposta { Konu="Toplantı", Alici="ekip@mail.com", Govde="Yarın..."};

Yazdirici yaz = new Yazdirici();
yaz.BelgeYazdir(rapor1); // Rapor nesnesi gönderiliyor
yaz.BelgeYazdir(eposta1); // Eposta nesnesi gönderiliyor

// ISifrelenebilir kullanımı
ISifrelenebilir sifreleyici = rapor1; // Arayüz üzerinden erişim
string sifreli = sifreleyici.Sifrele("Gizli Bilgi");
Console.WriteLine($"Şifreli: {sifreli}");
Console.WriteLine($"Çözülmüş: {sifreleyici.SifreCoz(sifreli)}");
                     

Her ikisi de soyutlama sağlasa da, kullanım amaçları ve yetenekleri farklıdır:

Soyut Sınıf (Abstract Class) Kullanın:

• İlişkili sınıflar arasında ortak bir temel implementasyon (somut metotlar) veya ortak durum (alanlar) paylaşmak istediğinizde.
• Alt sınıfların aynı temel türden olmasını ve ortak bir şablona uymasını istediğinizde ("is-a" ilişkisi güçlü olduğunda).
• public olmayan (protected, internal) üyeler tanımlamak istediğinizde (arayüz üyeleri genellikle public'tir).
• Gelecekte sınıfa yeni somut metotlar eklemeniz gerektiğinde ve mevcut tüm alt sınıfları kırmak istemediğinizde.

Arayüz (Interface) Kullanın:

• Birbirleriyle doğrudan ilişkili olmayan sınıflara ortak bir yetenek veya rol kazandırmak istediğinizde (örn: IYazdirilabilir, ISerializable, IComparable).
• Bir sınıfın birden fazla sözleşmeyi uygulamasını istediğinizde (çoklu kalıtım benzeri yapı).
• Sınıflar arasında tamamen gevşek bağlılık oluşturmak istediğinizde (sadece sözleşmeye bağımlılık).
• Bir API'nin veya kütüphanenin public sözleşmesini tanımlamak istediğinizde.

Genel bir kural olarak, bir "şeyin ne olduğu" (is-a) ilişkisi için soyut sınıflar, bir "şeyin ne yapabildiği" (can-do) ilişkisi veya bir sözleşme tanımlamak için arayüzler daha uygundur. Modern tasarım desenlerinde genellikle arayüzler daha fazla tercih edilir.