• Kapsülleme (Encapsulation): Veriyi ve bu veri üzerinde çalışan metotları tek bir birim altında bir araya getirme ve dış dünyadan saklama prensibidir. Bu sayede nesnenin iç işleyişi dışarıdan doğrudan erişilemez hale gelir, sadece tanımlanmış arayüzler (public metotlar) aracılığıyla etkileşim kurulabilir. Bu, veri bütünlüğünü korur ve kodun daha az bağımlı olmasını sağlar. Örneğin, bir "Araba" nesnesinin "motorHacmi" özelliğine doğrudan erişim yerine, "motorHacminiGetir()" gibi bir metot üzerinden erişim sağlanır. Bu, aynı zamanda bir nesnenin içindeki detayların dış dünyadan gizlenerek, dışarıdaki kodun bu detaylara bağımlı olmamasını sağlar. Eğer bir sınıfın iç yapısında değişiklik yaparsanız, bu değişiklik dışarıdaki kodu etkilemez, çünkü dışarıdaki kod sadece tanımlanmış genel arayüzü kullanır.
• Miras (Inheritance): Bir sınıfın başka bir sınıftan özelliklerini ve metotlarını miras alabilmesidir. Bu, kod tekrarını azaltır ve hiyerarşik bir yapı oluşturulmasına olanak tanır. "Hayvan" sınıfından "Köpek" ve "Kedi" sınıflarının miras alması gibi düşünebiliriz. Miras, "bir ... dır" (is-a) ilişkisini temsil eder. Bu prensip, ortak özelliklerin ve davranışların üst sınıfta tanımlanmasına izin vererek, alt sınıfların bu özellikleri yeniden yazmak zorunda kalmadan kullanmasını sağlar. Ancak, aşırı miras kullanımı katı ve esnek olmayan hiyerarşiler yaratabilir, bu yüzden dikkatli kullanılmalıdır.
• Çok Biçimlilik (Polymorphism): Farklı sınıflardaki nesnelerin aynı arayüze sahip olabilmesi, ancak bu arayüzü farklı şekillerde uygulamasıdır. Yani, aynı metot çağrısı, çağrıldığı nesnenin türüne göre farklı davranışlar sergileyebilir. Bu, esneklik ve genişletilebilirlik sağlar. Örneğin, "Hayvan" sınıfında "sesCikar()" metodu varsa, "Köpek" bu metodu "havhav" olarak, "Kedi" ise "miyav" olarak uygulayabilir. Bu, genel bir arayüz üzerinden farklı nesnelerle etkileşim kurma yeteneği sağlar ve kodu daha dinamik hale getirir. Bir koleksiyonda farklı türde hayvan nesneleri tutabilir ve hepsine "sesCikar()" çağrısı yaparak kendi türlerine özgü sesleri çıkarmalarını sağlayabilirsiniz.
• Soyutlama (Abstraction): Karmaşık detayları gizleyerek sadece gerekli bilgileri ortaya çıkarma prensibidir. Bir nesnenin dış dünya ile etkileşim kurması için gerekli olan arayüzü sunarken, iç detayları kullanıcıdan gizler. Arayüzler (interface) ve soyut sınıflar (abstract class) soyutlamanın temel araçlarıdır. Bir "Uzaktan Kumanda" örneğinde, tuşlara basarak televizyonu kontrol ederiz ama içindeki elektronik devrelerin nasıl çalıştığını bilmemize gerek yoktur. Bu, kullanıcıların veya diğer geliştiricilerin, bir bileşenin nasıl çalıştığına dair tüm ayrıntılara boğulmadan sadece nasıl kullanılacağını bilmelerini sağlar. Bu prensip, karmaşıklığı yönetmek için temel bir mekanizmadır.

• Tek Sorumluluk Prensibi (Single Responsibility Principle - SRP): Bir sınıfın yalnızca bir nedenle değişmesi gerektiğini söyler. Yani, her sınıfın veya modülün sadece tek bir sorumluluğu olmalıdır. Bir sınıfın birden fazla sorumluluğu varsa, bu sorumluluklardan herhangi birindeki değişiklik, sınıfın değişmesine yol açabilir ve potansiyel olarak diğer sorumlulukları etkileyebilir.
• Açık/Kapalı Prensibi (Open/Closed Principle - OCP): Yazılım varlıkları (sınıflar, modüller, fonksiyonlar vb.) geliştirmeye açık, ancak değiştirmeye kapalı olmalıdır. Yeni özellikler eklemek, mevcut kodu değiştirmeyi gerektirmemelidir. Bu genellikle soyutlamalar ve polimorfizm kullanılarak başarılır, böylece yeni davranışlar mevcut sistemi değiştirmeden eklenebilir.
• Liskov Yerine Koyma Prensibi (Liskov Substitution Principle - LSP): Alt sınıflar, temel sınıflarının yerini alabilmelidir. Yani, bir temel sınıfın nesnesi yerine, o temel sınıftan türetilmiş bir alt sınıfın nesnesi kullanıldığında programın doğruluğu bozulmamalıdır. Bu, mirasın doğru kullanılmasının bir garantisidir ve polimorfizmin gücünü en üst düzeye çıkarır.
• Arayüz Ayırma Prensibi (Interface Segregation Principle - ISP): Büyük, genel amaçlı arayüzler yerine, daha küçük ve amaca özel arayüzler kullanılmalıdır. Müşteriler (client) kullanmadıkları metotlara bağımlı olmamalıdır. Bu, "yağlı" arayüzlerin (yani çok fazla metot içeren arayüzler) önlenmesine yardımcı olur ve kodun daha esnek olmasını sağlar.
• Bağımlılık Ters Çevirme Prensibi (Dependency Inversion Principle - DIP): Üst seviye modüller, alt seviye modüllere doğrudan bağlı olmamalıdır; her ikisi de soyutlamalara bağlı olmalıdır. Soyutlamalar detaylara bağlı olmamalıdır; detaylar soyutlamalara bağlı olmalıdır. Bu prensip, bir sistemdeki bağımlılıkları azaltır ve modüllerin daha bağımsız ve test edilebilir olmasını sağlar, genellikle Bağımlılık Enjeksiyonu (Dependency Injection) ile uygulanır.

• Yeniden Kullanılabilirlik: Mevcut nesneler ve sınıflar, yeni projelerde veya projenin farklı alanlarında tekrar kullanılabilir, bu da geliştirme süresini kısaltır ve maliyetleri düşürür. Bir kez yazılan kodun defalarca kullanılması, tutarlılığı artırır.
• Modülerlik: Her nesne bağımsız bir birim olarak çalışır, bu da yazılımın farklı bölümlerinin ayrı ayrı geliştirilip test edilmesine olanak tanır. Modüler yapı, büyük projelerde ekip çalışmasını kolaylaştırır.
• Bakım Kolaylığı: Kodun daha düzenli ve anlaşılır olması, hataların tespitini ve düzeltilmesini kolaylaştırır. Bir değişiklik yapıldığında, bu değişikliğin tüm sisteme yayılma olasılığı azalır, çünkü etkilenen alan daha küçük ve izole edilmiştir.
• Esneklik ve Genişletilebilirlik: Yeni özellikler eklemek veya mevcut olanları değiştirmek, mevcut kod tabanını önemli ölçüde etkilemeden daha kolaydır. Polimorfizm ve soyutlama sayesinde sistemin gelecekteki gereksinimlere adaptasyonu kolaylaşır.
• Karmaşıklık Yönetimi: Büyük ve karmaşık sistemler, daha küçük, yönetilebilir nesnelere ayrılarak daha kolay ele alınır. Gerçek dünya varlıklarını yansıtan nesnelerle çalışmak, problem alanını daha iyi anlamayı sağlar.

class Cihaz {
    public function ac() {
        // Cihazı açma mantığı
        echo "Cihaz açılıyor...
";
    }

    public function kapat() {
        // Cihazı kapatma mantığı
        echo "Cihaz kapanıyor...
";
    }
}

class Televizyon extends Cihaz {
    private $kanal;

    public function kanalDegistir($yeniKanal) {
        $this->kanal = $yeniKanal;
        echo "Kanal " . $yeniKanal . " olarak ayarlandı.\n";
    }

    public function ac() {
        parent::ac(); // Üst sınıfın ac metodunu çağır
        echo "Televizyon açıldı ve son kanalda.\n";
    }

    public function bilgiGoster() {
        echo "Şu anki kanal: " . $this->kanal . "\n";
    }
}

$tv = new Televizyon();
$tv->ac(); // Cihaz ve Televizyon ac metodları çağrılır
$tv->kanalDegistir(5); // Kanal değiştirilir
$tv->bilgiGoster(); // Kanal bilgisi gösterilir

// Polymorphism örneği:
// function cihazCalistir(Cihaz $c) {
//     $c->ac();
// }
// cihazCalistir($tv); // Bu, $tv'nin bir Cihaz olarak ele alındığını gösterir

"Nesne tabanlı programlama, yazılım tasarımını, verileri ve ilgili davranışları tek bir birimde birleştirerek basitleştirmeye yardımcı olan bir programlama paradigmasıdır. Kapsülleme, miras, polimorfizm ve soyutlama gibi temel kavramları aracılığıyla, kodun modülerliğini ve yeniden kullanılabilirliğini artırır." - Yazılım Mühendisliği Uzmanı

Genişletmek için tıkla ...