Merhaba değerli Webkolog.net takipçileri, bugünkü yazımızda modern yazılım geliştirmenin temelini oluşturan Nesne Yönelimli Programlama (OOP) prensiplerini C# .NET Framework 4 özelinde derinlemesine inceleyeceğiz. OOP, gerçek dünyadaki nesneleri ve onların etkileşimlerini modelleyerek daha düzenli, anlaşılır, tekrar kullanılabilir ve sürdürülebilir yazılımlar geliştirmemize olanak tanır. Gelin, OOP'nin temel avantajlarına, prensiplerine ve C#'taki uygulamalarına yakından bakalım.
OOP'nin Sunduğu Avantajlar
OOP'nin yazılım geliştirme sürecine getirdiği pek çok önemli avantaj bulunmaktadır:
- Tek Sorumluluk (Single Responsibility): Her sınıfın ve metotun yalnızca bir sorumluluğu olması, kodun daha anlaşılır ve bakımı kolay olmasını sağlar.
- Okunabilirlik (Readability): Gerçek dünya nesnelerini modelleyen yapılar sayesinde kodun anlaşılması kolaylaşır.
- Tekrar Kullanılabilirlik (Reusability): Oluşturulan sınıflar ve metotlar farklı projelerde veya uygulamanın farklı bölümlerinde tekrar kullanılabilir, bu da geliştirme süresini kısaltır.
- Genişletilebilirlik (Extensibility): Mevcut kodun davranışını değiştirmeden yeni özellikler eklemek OOP prensipleri sayesinde kolaylaşır.
- Modülerlik (Modularity): Uygulama, birbirinden bağımsız ve iyi tanımlanmış modüllerden oluşur, bu da geliştirme ve test süreçlerini kolaylaştırır.
- Üretkenlik (Productivity): Tekrar kullanılabilir kod ve modüler yapı sayesinde geliştirme süreci hızlanır.
- Esneklik (Flexibility) - Polimorfizm: Farklı sınıfların ortak bir arayüz üzerinden farklı şekillerde davranabilmesi, kodun daha esnek olmasını sağlar.
- Güvenlik (Security) - Kapsülleme ve Soyutlama: Verilerin ve metotların erişimini kısıtlayarak (kapsülleme) ve karmaşık detayları gizleyerek (soyutlama) daha güvenli uygulamalar geliştirilebilir.
- Kolay Yükseltilebilir ve Ölçeklenebilir (Easy Upgradable & Scalable): Modüler yapı ve iyi tanımlanmış arayüzler sayesinde uygulamaların güncellenmesi ve ölçeklendirilmesi kolaylaşır.
- Arayüz Tanımlama (Interface Descriptions): Arayüzler aracılığıyla farklı sınıfların uyması gereken sözleşmeler tanımlanabilir.
- Bakım (Maintenance): Modüler ve okunabilir kod, hataların bulunmasını ve düzeltilmesini kolaylaştırır. Namespace'ler ise sınıfları mantıksal olarak bir araya getirerek organizasyonu artırır.
OOP'nin Temel İlkeleri
OOP'nin temelini oluşturan dört ana ilke şunlardır:
- Kapsülleme (Encapsulation): Bir sınıfın metotlarını ve özelliklerini bir arada tutarak, verilere doğrudan dışarıdan erişimi kısıtlamayı ve kontrollü erişim sağlamayı amaçlar. Erişim belirleyiciler (access modifiers) kullanılarak sağlanır.
class KlasAdi
{
private string _yazi; // Özel alan (field)
public string Yazi // Özellik (Property) - Kapsülleme örneği
{
get { return _yazi; }
set
{
if (!string.IsNullOrEmpty(value))
{
_yazi = value;
}
else
{
throw new ArgumentException("Yazı boş olamaz.");
}
}
}
public void Yazdir() // Metot
{
System.Console.WriteLine(_yazi);
}
}
- Miras/Kalıtım (Inheritance): Mevcut bir sınıftan (base class veya parent class) yeni sınıflar (derived class veya child class) türetme mekanizmasıdır. Türetilen sınıflar, temel sınıfın tüm public, protected ve internal üyelerini otomatik olarak devralır ve kendi özel üyelerini ekleyebilir veya devraldığı üyelerin davranışını değiştirebilir (override). C#'ta tekli kalıtım desteklenir (bir sınıf yalnızca bir temel sınıftan türeyebilir).
class Canli
{
public string Ad { get; set; }
public virtual void SesCikar()
{
System.Console.WriteLine("Bir ses.");
}
}
class Kedi : Canli
{
public override void SesCikar()
{
System.Console.WriteLine("Miyav!");
}
}
- Çok Biçimlilik (Polymorphism): Bir nesnenin farklı türlerinmiş gibi davranabilme yeteneğidir. Temelde iki tür polimorfizm bulunur:
- Derleme Zamanı Polimorfizmi (Metot Aşırı Yükleme - Method Overloading): Aynı isimde ancak farklı parametre listelerine sahip metotların tanımlanabilmesidir.
- Çalışma Zamanı Polimorfizmi (Metot Ezme - Method Overriding): Temel sınıfta
virtualolarak işaretlenmiş bir metotun, türetilen sınıftaoverrideanahtar kelimesiyle farklı bir şekilde uygulanabilmesidir.
class Hesaplayici
{
public int Topla(int a, int b) { return a + b; } // Aşırı yüklenmiş metot
public double Topla(double a, double b) { return a + b; } // Aşırı yüklenmiş metot
}
// Çalışma zamanı polimorfizmi örneği (yukarıdaki Kedi sınıfı da bir örnektir)
Canli hayvan1 = new Canli();
Canli hayvan2 = new Kedi();
hayvan1.SesCikar(); // "Bir ses." çıktısı
hayvan2.SesCikar(); // "Miyav!" çıktısı (polimorfizm sayesinde Kedi'nin davranışı sergilenir)
- Soyutlama (Abstraction): Bir nesnenin karmaşık iç yapısını gizleyerek yalnızca gerekli ve ilgili bilgilerin dış dünyaya sunulmasıdır.
abstractsınıflar veinterface'ler aracılığıyla sağlanır.abstractsınıflardan nesne oluşturulamaz ve soyut metotlar gövdesizdir, türetilen sınıflar tarafından uygulanmak zorundadır.interface'ler ise sınıfların uygulaması gereken bir sözleşmeyi tanımlar.
abstract class Sekil
{
public abstract double AlanHesapla();
public virtual void Ciz()
{
System.Console.WriteLine("Şekil çiziliyor.");
}
}
class Daire : Sekil
{
public double Yaricap { get; set; }
public override double AlanHesapla()
{
return Math.PI * Yaricap * Yaricap;
}
public override void Ciz()
{
System.Console.WriteLine("Daire çiziliyor.");
}
}
interface ILoglayici
{
void Log(string mesaj);
}
class DosyaLoglayici : ILoglayici
{
public void Log(string mesaj)
{
System.IO.File.AppendAllText("log.txt", mesaj + Environment.NewLine);
}
}
Erişim Belirleyiciler (Access Modifiers)
Sınıf üyelerinin (alanlar, özellikler, metotlar) erişilebilirliğini kontrol etmek için kullanılan anahtar kelimelerdir:
public(Genel): Her yerden erişilebilir.private(Özel): Yalnızca tanımlandığı sınıf içinden erişilebilir (varsayılan erişim belirleyicidir).protected(Korumalı): Tanımlandığı sınıf ve ondan türeyen sınıflar içinden erişilebilir.internal(İçsel/Dahili): Aynı proje (assembly) içinden erişilebilir.protected internal(Korumalı İçsel/Dahili): Aynı proje içinden veya farklı bir projede türetilmiş sınıflar içinden erişilebilir (protectedORinternal).
Niteleyiciler (Modifiers)
Sınıfların ve üyelerinin davranışlarını değiştiren anahtar kelimelerdir:
static(Statik): Sınıfın bir örneği oluşturulmadan erişilebilen üyeleri tanımlar. Statik sınıflardan nesne oluşturulamaz ve tüm üyeleri statik olmalıdır.abstract(Soyut): Nesne oluşturulamayan ve soyut metotlar içerebilen sınıfları tanımlar. Türetilen sınıflar soyut metotları uygulamak zorundadır.virtual(Sanal): Temel sınıfta tanımlanan ve türetilen sınıflardaoverrideile yeniden uygulanabilen metotları tanımlar.sealed(Mühürlü): Kalıtımı engelleyen sınıfları tanımlar. Mühürlü sınıflardan başka sınıf türetilemez.partial(Kısmi/Bölünmüş): Bir sınıfın tanımının birden fazla dosyaya yayılmasına olanak tanır.
Sınıflar ve Nesneler
- Sınıf (Class): Gerçek dünyadaki nesnelerin soyut bir tanımıdır. Nesnelerin özelliklerini (alanlar, özellikler) ve davranışlarını (metotlar) tanımlar.
- Nesne (Object): Bir sınıfın somut bir örneğidir. Bellekte yer kaplar ve sınıfın tanımladığı özelliklere ve davranışlara sahiptir. Nesneler,
newanahtar kelimesi kullanılarak sınıflardan oluşturulur (instance almak).
// Basit bir sınıf ve metot (constructor ve destructor)
class KlasAdi
{
public KlasAdi()
{
// Constructor (Yapıcı Metot)
}
~KlasAdi() // Destructor (Yıkıcı Metot)
{
// Yıkıcı metot
}
public string MetotAdi(int sayi, string yazi)
{
return "Yazı: " + yazi + " - " + sayi.ToString();
}
}
// Class'ı çağırmak ve nesne oluşturmak:
KlasAdi klass = new KlasAdi(); // Varsayılan yapıcı metot çağrılır
// Eğer yapıcı metot parametre alıyorsa:
// KlasAdi klass = new KlasAdi(37, "Ali"); // Örnek parametreli yapıcı çağrısı
string sonuc = klass.MetotAdi(10, "Merhaba"); // Metot çağrısı
// Nesne başlatıcıları ile sınıf kullanımı:
class Klass
{
public string isim { get; set; }
public string soyad { get; set; }
}
Klass klas = new Klass() { isim = "Ali", soyad = "Mantar" };
// Genel bakış: Alan, Özellik, Metot
class klasAdli
{
private string _yazi; // Field (Alan)
public string Yazi { get; set; } // Property (Özellik)
public void Yazdir() { } // Method (Metot)
}
Yapıcı Metotlar (Constructors) ve Yıkıcı Metotlar (Destructors)
- Yapıcı Metotlar (Constructors): Bir sınıftan nesne oluşturulduğunda otomatik olarak çağrılan özel metotlardır. Nesnenin başlangıç değerlerini ayarlamak veya gerekli ilk işlemleri yapmak için kullanılırlar. Geri dönüş tipleri yoktur ve sınıf adıyla aynı isme sahiptirler. Aşırı yüklenebilirler (overloading).
- Yıkıcı Metotlar (Destructors): Bir nesnenin bellekten silinmeden önce (garbage collection tarafından) otomatik olarak çağrılan özel metotlardır. Genellikle kullanılan kaynakları serbest bırakmak için kullanılırlar. C# .NET'te yıkıcı metotların kullanımı diğer dillere göre daha az yaygındır çünkü bellek yönetimi otomatik olarak yapılır.
Arabirimler (Interfaces)
Arabirimler, sınıfların uygulaması gereken bir sözleşmeyi tanımlar. İçlerinde yalnızca metot ve özellik bildirimleri (imzaları) bulunur, uygulama detayları yer almaz. Bir sınıf birden fazla arabirimi uygulayabilir (çoklu kalıtım benzeri bir yapı sağlar). Arabirim isimleri genellikle I harfi ile başlar (bir konvansiyondur).
public interface IHavaYetenegi
{
void Uc();
}
public interface ISuYetengi
{
void Yuz();
}
public class Ordek : IHavaYetenegi, ISuYetengi // interfaceler implemente edilmek zorunda
{
public void Uc() { /* Uygulama kodu */ } // implement ediliyor
public void Yuz() { /* Uygulama kodu */ } // implement ediliyor
}
Enumlar (Numaralandırmalar)
Enumlar, adlandırılmış sabit değerler kümesini tanımlamak için kullanılır. Kodun okunabilirliğini artırır ve belirli bir değer aralığını temsil etmek için kullanışlıdırlar.
enum Markalar
{
Samsung,
Apple
}
class SmartPhones
{
private Markalar _Uretici;
public Markalar Uretici
{
get { return _Uretici; }
set { _Uretici = value; }
}
}
// Kullanımı
SmartPhones phones = new SmartPhones();
phones.Uretici = Markalar.Samsung;
Birden fazla enum değeri atamak için bitsel operatörler kullanılabilir (enum tanımında [Flags] özniteliği ile):
/*
[Flags] // Bu öznitelik, enum'ın bitsel işlemler için uygun olduğunu belirtir
enum Ozellikler
{
None = 0,
Hizli = 1,
Guclu = 2,
Dayanikli = 4
}
// Kullanımı:
Ozellikler telefonOzellikleri = Ozellikler.Hizli | Ozellikler.Dayanikli;
telefonOzellikleri = telefonOzellikleri | Ozellikler.Guclu; // Yeni özellik ekleme
telefonOzellikleri = telefonOzellikleri & (~Ozellikler.Hizli); // Özellik silme
*/
Listeler ve Anonim Tipler
- Listeler (
List<T>): Dinamik boyutlu, aynı türden nesnelerin koleksiyonlarını temsil eder.
class ClassAdi
{
public string isim { get; set; }
}
List<ClassAdi> liste = new List<ClassAdi>
{
new ClassAdi() {isim="Ali"},
new ClassAdi() {isim="Veli"}
};
- Anonim Tipler: Derleme zamanında türü belli olmayan, geçici nesneler oluşturmak için kullanılır (
varanahtar kelimesi ve nesne başlatıcısı ile).
var a = new { Adi = "Ali", Soyadi = "Mantar" };
// a.Adi; // "Ali"
Operatör Aşırı Yüklemesi (Operator Overloading)
Bazı durumlarda, sınıflarımızın nesneleri üzerinde standart operatörlerin (+, -, == vb.) farklı anlamlar taşımasını isteyebiliriz. Operatör aşırı yüklemesi ile bu operatörlerin sınıflarımız için özel davranışlar sergilemesini sağlayabiliriz.
class Kisiler
{
public string isim;
public int yas;
public Kisiler(string isim, int yas) // Constructor
{
this.isim = isim;
this.yas = yas;
}
// + operatörünü aşırı yükleme
public static Kisiler operator+ (Kisiler a, Kisiler b)
{
string isimler = a.isim + " " + b.isim; // İsimleri birleştir
int yasOrtalama = (a.yas + b.yas) / 2; // Yaşları ortala
Kisiler birlesikKisi = new Kisiler(isimler, yasOrtalama);
return birlesikKisi;
}
}
// Kullanımı
Kisiler kisi1 = new Kisiler("Ali", 35);
Kisiler kisi2 = new Kisiler("Veli", 25);
Kisiler birlesikKisi = kisi1 + kisi2; // + operatörü kullanımı
// Console.WriteLine(birlesikKisi.isim); // Çıktı: Ali Veli
// Console.WriteLine(birlesikKisi.yas); // Çıktı: 30
Kısmi Sınıflar (Partial Classes)
Kısmi sınıflar, bir sınıfın tanımının birden fazla .cs dosyasına bölünmesine olanak tanır. Özellikle büyük projelerde veya otomatik kod üretimi senaryolarında kullanışlıdır.
public partial class A
{
partial void M(); // Bildirim (metot gövdesi yok)
}
public partial class A
{
partial void M() { /* Uygulama kodu */ } // Uygulama (metot gövdesi burada)
}
Evet sevgili Webkolog.net okurları, bu yazımızda C# .NET Framework 4 ile Nesne Yönelimli Programlama'nın temel prensiplerini, avantajlarını ve C#'taki temel yapı taşlarını kapsamlı bir şekilde inceledik. OOP, modern yazılım geliştirmenin vazgeçilmez bir parçasıdır ve sağlam, esnek ve sürdürülebilir uygulamalar inşa etmek için güçlü bir araç setidir. Umarım bu detaylı rehber, OOP'nin mantığını anlamanıza ve C# projelerinizde etkin bir şekilde uygulamanıza yardımcı olur. Bir sonraki yazımda, C# dilinin diğer önemli yapı taşlarını keşfetmeye devam edeceğiz. Webkolog.net'i takipte kalın!
Hepinize nesne yönelimli ve başarılı kodlama deneyimleri dilerim!
0 yorum:
Yorum Gönder