Nesne Tabanlı Programlama’nın Temelleri

0
744

Asıl adı Object Oriented Programming (OOP) olan Nesne Tabanlı Programlama; yazılımda devrim yaratmış, acemi ya da uzman bu işle meşgul olan herkesin alışkanlıkları arasına girmiş bir programlama yapısıdır. Nesne Tabanlı Programlama’yı bu kadar cazip kılan en önemli şey ise yazılım geliştirme esnasında aynı şeyleri her seferinde tekrar yazmak yerine tek sefere mahsus yazıp daha sonra tekrar tekrar kullanabilmemiz, yani yazılım diliyle konuşmak gerekirse kodlarımızın reusable olmasıdır. Ayrıca kodlarımızı kendi yazdığımız sınıflarda tuttuğumuz için o sınıftan temeli aynı olan birçok yeni sınıf türetebiliriz.

Tabii OOP denildiğinde adından ve işlevinden mutlaka söz etmemiz gereken kavramlar da var. Bunlardan ilki yukarıda da bahsettiğim class kavramı.

Classlar, OOP tabanlı dillerde nesnelerin başlangıç durumlarını, özelliklerini ve davranış biçimlerini tanımlamak amacıyla kullanılan yapılardır. Bu sayede iş bölümü daha kolay sağlanabilir ve ayrıca bir class başka bir programa import edilerek orada da kullanımını sürdürebilir. Bunu C#’ta bir örnek ile açıklayacak olursak öncelikle programımıza bir class ekleyelim ve ardından classımıza ve formumuzun içine şu kodları yazalım;

[java]
class Example
{
public string Hosgeldiniz(string Adi, string Soyadi)
//Burada public bir erişim belirleyici kullanarak classımızda oluşturduğumuz metodun
//formda çağırılabilmesini sağladık. Daha sonra parantez içerisinde parametrelerimizi girerek
//neleri geri çarıcağımızı belirttik.
{
return Adi + " " + Soyadi;
//Burada geri döndüreceğimiz parametreleri girdik.

}

}

private void Form1_Load(object sender, EventArgs e)
{
ClassDeneme Deneme1 = new ClassDeneme();
//Burada classımızdan Deneme1 adında yeni bir nesne oluşturduk ve bu sayede classımızda tanımladığımız tüm metodlarımızı
//çağırabilir duruma getirmiş olduk.
string sonuc = Deneme1.Hosgeldiniz("Çağrı", "Aldemir");
//Çıktımız string türünde olacağı için sonuc adında bir string ifade oluşturduk ve daha sonra Deneme1 nesnemizi çağırıp
//Hoşgeldiniz metodunu çağırdık. Geri döndüreceğimiz parametrelerin string türündeki karşılıklarını girdik ve
//son olarak messageboxa sonuc isimli string ifademizi yazdırdık.
MessageBox.Show(sonuc);
}

[/java]

Bu kodlar ışığında programımızı çalıştırdığımızda şöyle bir sonuç alırız;
cikti

OOP’nin içerdiği bir diğer kavram ise Inheritance kavramı. Türkçe’de miras olarak geçen bu kavram classlar arasındaki aktarma (extend) olayını sağlar. Bu miras sisteminde temel olan classın içerisindeki her şey türetilen classa istisnasız geçer. Bu kavram sayesinde ortak özelliği olan birçok classın temelini tek sefere mahsus olmak üzere yazıp daha sonra bütün classları ondan türeterek üst düzey bir vakit ve kod kazancı sağlarız. Ancak bir sınıf farklı iki sınıftan türeyemez. Bu nedenle classları tek bir temel (base) classtan türetebiliriz. Inheritance kavramına bir örnek vermek gerekirse ebeveynlerimizden bizlere aktarılan genleri ele alabiliriz. Burada önemli olan bir nokta ise iki kademe üstteki classın kodlarını da çekebilmemizdir. Normal koşullarda B sınıfı A sınıfından türemiş, C sınıfı ise B sınıfından türemiş (A>B / B>C) olduğunda A, C’nin base classıdır diyemeyiz. Çünkü her class kendinden türeyenin base classıdır. Ancak yine gen örneğine dönecek olursak bizlere ulaşan genler sadece ebeveynlerimizin değil, aynı zamanda atalarımızın genleridir. Buradan ulaşacağımız sonuç ise her ne kadar iki üst class bizim base classımız olmasa da oradaki metod, değer vb. şeyleri kendi classımızda kullanabiliriz. Aşağıda bu konuyla ilgili örnek bir resim bulabilirsiniz.

inheritance_ornek

Şimdi de biz bir örnek yazalım.

[java]
class BaseClass
{
public string adi { get; set; }
public string soyadi { get; set; }
public int yasi { get; set; }
//BaseClass’a üç adet metod tanımladık.
//Parantezler içerisinde get; ve set; kullanmamızın sebebi ise değeri geri döndürebilmemiz ve onu değiştirebilmemizdir.

}
class DerivedClass:BaseClass
{
public string departmani { get; set; }
public int maasi { get; set; }
//DerivedClass’a iki tane metod tanımladık ve BaseClass’tan miras aldık.
}
private void button1_Click(object sender, EventArgs e)
{
DerivedClass dc = new DerivedClass();
listBox1.Items.Add(dc.adi = "Çağrı");
listBox1.Items.Add(dc.soyadi = "Aldemir");
listBox1.Items.Add(dc.yasi = 20);
listBox1.Items.Add(dc.maasi = 500);
listBox1.Items.Add(dc.departmani = "Software Solutions");
//Formumuza bir adet listbox ekledik ve yukarıdaki kodlarla birlikte her metodun değeri listboxa eklendi.
}

[/java]

OOP’nin kavramlarından biri de Interface kavramı. Bu kavram aynı zamanda biraz önce classlar başlığında bahsettiğim bir classı yalnızca tek bir classtan türetebilme sorununa nispeten çözüm bulan kavramdır.
Interface kavramı sayesinde bir classı istediğimiz sayıda interfaceden türetebilir ve onların tüm özelliklerini tek bir classta kullanabiliriz. Eğer bir classı başka bir classtan extend edersek bu inheritance kavramına girer. Ancak eğer bir classa bir interfaceyi implement edersek birnevi interfaceden class türetmiş oluruz. Yani implement etmenin anlamı aslında interface bir classtan başka bir class türetmeye benzer diyebiliriz. Bir interfaceyi başka bir classa implement ettikten sonra o interfacenin içinde daha önceden oluşturduğumuz bütün metodları kullanmamız gerekmektedir. Aksi halde program hata verir. Ayrıca interface isimlerini tanımlarken evrensel olarak kullanılan yapı asıl ismin başına büyük “I” harfi koymaktır. Kullanılmak zorunda değildir ancak kullanılırsa kodun okunabilir olmasını sağlar.
Interface ile ilgili birkaç şey söylemek gerekirse interfacelerin içine yazdığımız metodların gövdesi olmaz. Gövde bölümünü implement ettiğimiz class içerisinde tanımlarız. Ayrıca interface içerisinde sadece metod, property, indexer ve event olabilir. Interface’in kendisi erişim belirleyicilerden public, internal, protected veya private olabilirken üyeleri sadece “public” olarak tanımlanabilir.
Şimdi de interface kavramıyla ilgili bir örnek verelim.

[java]
namespace InterfaceExample
{
public interface IEkleSil
{
public string ekle();
public string sil();
}
//IEkleSil adında bir interface oluşturdum ve içine iki metod yazdım.
public interface IKaydet
{
public string kaydet();
}
//IKaydet adında bir interface oluşturdum ve içine bir metod yazdım.

namespace InterfaceExample
{
class ÇalısanOzellikleri:IEkleSil,IKaydet
{
//*****
public string ad();
public string soyad();
public int yas();
public int maas();
//*****
//Yıldızlar ile belirtilen bölüm classın içine yazmak istediğimiz şeyleri yazacağımız bölüm.
//Yani sadece classı ilgilendiren bölüm.

//#####
public string ekle()
{
throw new NotImplementedException();
}

public string sil()
{
throw new NotImplementedException();
}
public string kaydet()
{
throw new NotImplementedException();
}
//#####
//Karelerle belirtilen bölüm ise benim daha önceden yazdığım interfaceleri : ile classa ekleyip
//sağ tıklayarak implement ettiğimde IDE’nin otomatik olarak kullanma kolaylığı sağlayarak kendi eklediği bölümler.
//İçlerinde yazan "throw new NotImplementedException();" bölümü biz şu anda içine bir şey yazmadığımız için otomatik olarak yazıldı.
//Biz içini dolduracağımız zaman o satırları silmeliyiz, aksi takdirde program hata verir.
}
}
[/java]

Encapsulation, yani kapsüllemek başlığına gelecek olursak kapsülleme; değişkenleri ve verileri hatalı kullanım ve dış etkenlerden korur. Yani normal koşullarda bir sınıftaki fonksiyonları public olarak yazarsak başka bir sınıftan o metoda ulaşıp değerini değiştirebiliriz. Ancak private olarak tanımlarsak da dışarıdan hiçbir şekilde erişim sağlayamayız. İşte tam da burada kapsülleme kavramı ortaya çıkıyor. Aynı fonksiyonu kapsülleyip getter (okuma) ve setterlerini (değiştirme) ayarlayarak hem dışarıdan erişilecek yanlış değişimler engellenir hem de hatalı kullanım oranı sıfıra indirilir. Burada kullanmış olduğumuz get kavramı programın değerinin geri döndürülmesini, set kavramı ise değerin yeniden ayarlanabilir olmasını sağlar.
Şimdi ise kapsülleme kavramına bir örnek verelim:

[java]
class Emlak
//Öncelikle classımızda dört adet değişken tanımlıyoruz.
//Daha sonra string ifadeleri büyük harfle hafızaya almak için ToUpper komutunu kullanıyoruz.
//Integer ifadeler için de pozitif sonuç almak için Math.Abs metodunu kullanıyoruz.
//Bunları yaparken de kapsülleme yaptığımız için değişkenlerin üstünü örtmüş ve onları korumaya almış oluyoruz.
//Buton bölümünde de gerekli kodları yazarak girdilerimizi listviewe ekliyoruz.
{
private string semt;

public string Semt
{
get { return semt; }
set { semt = value.ToUpper(); }
}
private int odaSayisi;

public int OdaSayisi
{
get { return odaSayisi; }
set { odaSayisi = Math.Abs(value); }
}
private int katNo;

public int KatNo
{
get { return katNo; }
set { katNo = Math.Abs(value); }
}
private int alan;

public int Alan
{
get { return alan; }
set { alan = Math.Abs(value); }
}
}

private void button1_Click(object sender, EventArgs e)
{
Emlak emlak = new Emlak();
emlak.Semt = textBox1.Text;
emlak.OdaSayisi = Convert.ToInt32(textBox2.Text);
emlak.KatNo = Convert.ToInt32(textBox3.Text);
emlak.Alan = Convert.ToInt32(textBox4.Text);

ListViewItem kayit = new ListViewItem();
kayit.Text = emlak.Semt;
kayit.SubItems.Add (emlak.OdaSayisi.ToString());
kayit.SubItems.Add (emlak.KatNo.ToString());
kayit.SubItems.Add (emlak.Alan.ToString());

listView1.Items.Add(kayit);
textBox1.Clear();
textBox2.Clear();
textBox3.Clear();
textBox4.Clear();
textBox1.Focus();
}

[/java]

Object Oriented Programming, yani Türkçe adıyla Nesne Tabanlı Programlama’nın temel başlıkları bu kadar.
Örneklerin hepsi C# kodlarından verilmiştir, farklı OOP tabanlı yazılım dillerinde temel aynı olsa da kodlar farklılık gösterebilir.
Bir sonraki yazıda görüşmek dileğiyle, kendinize iyi davranın…

CEVAP VER

Please enter your comment!
Please enter your name here