Mustafa Çağatay KIZILTAN

12. Nesne Tabanlı Programlama Mantığı

  C# nesne tabanlı (object oriented) bir programlama dilidir. Nesne tabanlı programlama dili denildiği zaman anlamamız gereken şey, etrafınızda baktığınızda gördüğünüz her nesneyi etrafındaki nesnelerle olan ilişkisiyle olduğu gibi yazılıma dökebilmeniz demektir. Basit bir örnek vermek gerekirse.

     *  Hayvan genel bir konsepttir ve her hayvanın kendine has özellikleri vardır.
     *  Köpek de bir hayvan türdür. Doğal olarak hayvana has tüm özellikleri içerisinde bulundurur ancak köpek olmasından ileri gelen başka kendine has özellikleri de vardır.
     *  Kedi de bir hayvan türüdür. Doğal olarak hayvana has tüm özellikleri içerisinde bulundurur. Kedi olmasından ileri gelen kendine has özellikleri de vardır ancak köpeğin kendine has özelliklerini taşımaz.

   Bu ilişkileri yazılım diline aktarmak istediğimiz zaman, bir tane hayvan class’ı oluşturup tüm hayvanlarda ortak olan özellikleri o class’a aktarırız. Aynı şekilde kedi ve köpek classlarını da oluştururuz ancak bunların hayvan olmasından ileri gelen hayvansal özelliklerini ayrı ayrı sınıfların içerisinde tanımlamak yenine onları hayvan classından türetiriz. Yani hayvan class’ının özelliklerini taşımasını söyleriz. Buna ilaveten kedinin kedi, köpeğin de köpek olmasından ileri gelen kendine has özelliklerini de sınıfların içerisinde özel olarak tanımlarız.

 1.CLASS ve NESNE TANIMI

   Aşağıda bir class tanımı yapılmıştır. Class geneli belirtir. Insan class’ı her insanda var olan genel özellikleri içerisinde barındırır. Her insanın Ismi,Soyismi,Yaşı,Kilo’su vardır her insan yürür,koşar gibi. Burada farketmeniz gereken şey şuan hala genelde olduğumuzdur. Yani spesifik bir insandan bahsetmiyoruz.

Eğer spesifik bir insandan bahsedersek obje oluşturmamız gerekir.    Insan ornekInsan = new Insan(“Cagatay”,“Kızıltan”,25,77);  satırında ornekInsan adında bir insan oluşturduk. Bu insanın kendine özel bir ismi , soyismi yaşı ve kilosu var. Yani class içerisinde tanımlanmış genel property’lere spesifik bir insan yaratarak özel değerler atadık.

Buradaki mantık , her insanın ismi, yaşı, kilosu olur. Benim ismim cagatay, yaşım 25, kilom 77dir. Ancak bir başka arkadaşım için bunlar değişir şeklindedir.

namespace CLASSLAR
{
 class Program
 {
   static void Main(string[] args)
   {

     Insan ornekInsan = new Insan("Cagatay","Kızıltan",25,77);
     Insan ornekInsan2 = new Insan("Ali","Alan",26,77);

      ornekInsan.Yuru( );

   }
 }

 class Insan
 {
    string Isim;
    string Soyisim;
    int Yas;
    int Kilo;

    public Insan(string Isim,string Soyisim,int Yas,int Kilo)
    {
       this.Isim = Isim;
       this.Soyisim = Soyisim;
       this.Yas = Yas;
       this.Kilo = Kilo;

    }

   void Yuru()
   {
     Console.WriteLine(Isim +"Yuruyor");
   }

    void Kos()
    {
     Console.WriteLine(Isim +"Kosuyor");
    }

  }

}

2.KALITIM / INHERITANCE

 Kalıtım yukarıda da bahsettiğim gibi daha genel bir class’ın özelliklerinin alt sınıflarca kullanılmasıdır. Örneğin ; Köpek class’ı hayvan classı’nın özelliklerini, Araba sınıfı araç sınıfının özelliklerini kullanabilir.

 class Hayvan
 {
    ...
 }
 class Köpek : Hayvan
 {
    ...
 }

3.ÇOKLU KALITIM / INHERITANCE

Sınıflar tıpkı nine, anne, çocuk yapısında olduğu gibi ard arda türetilebilir. Yani örneğin B sınıfı A sınıfında türetilip C sınıfı da B sınıfından türetilebilir. Bu durumda C sınıfı türünden bir nesne yarattığımızda eğer C sınıfının ilgili yapıcı metoduna base takısını eklememişsek önce A, sonra B, sonra da C sınıfının yapıcı metotları çalıştırılır. Yani gidişat anadan yavruya doğrudur. Ayrıca tahmin edebileceğiniz gibi C sınıfı hem A’nın hem de B’nin bütün üye elemanlarına sahip olur.

 using System;
 class A
 {  
    public int OzellikA;
     
    public A()
    {  
       Console.WriteLine("A sınıfı");
    }

    public A(int a) 
    { 
      OzellikA=a;  
    }

 }
 class B:A
 {
    public int OzellikB;
    
    public B()
    {
       Console.WriteLine("B sınıfı");
    }

    public B(int b,int a):base(a) 
    { 
       OzellikB=b; 
   }
}
 class C:B
 {
    public C()
    {   
       public int OzellikC;
       Console.WriteLine("C sınıfı");
    }
    public C(int c,int b,int a):base(b,a) 
    { 
      OzellikC=c; 
    }
    static void Main()
    {
       C nesne=new C();
       C nesne2=new C(12,56,23);
    }
 }

3.1 CONSTRUCTOR KALITIMI

Aşağıdaki örnekte birbirinden kalıtılan class’ların nasıl birbirlerinin constructor’unu kullanabileceği gösterilmiştir.

 using System;
 class A
 {
    public int Ozellik1;
    public int Ozellik2;
    public A()   //Ana class'ın default constructor'ı
    {
      Console.WriteLine("Deneme");
    }
    public A(int ozellik1,int ozellik2) //Ana class'ın parametre alan constructoru
    {
      Ozellik1=ozellik1;
      Ozellik2=ozellik2;
    }
 }
 class B:A    //Alt sınıf ana sınıftan türetilir yani onun property ve metodlarını kullanabilir hale gelir.
 {
    public int Ozellik3;
    public int Ozellik4;
    public B(int ozellik1,int ozellik2,int ozellik3,int ozellik4):base(ozellik1,ozellik2) //alt sınıfın constructor'u üst sınıfın constructor'ıyla birleştirildi
    {
      Ozellik3=ozellik3;   //constructordan alınan bilgiler property'lere aktarılır.
      Ozellik4=ozellik4;
    }
 }
 class esas
 {
    static void Main()
    {
       B b=new B(3,4,1,2);
       Console.WriteLine(b.Ozellik1+" "+b.Ozellik2+" "+b.Ozellik3+" "+b.Ozellik4);
    }
 }

3.2   STATIK CONSTRUCTOR KULLANIMI VE KALITIMI
   Statik olarak tanımlanan contructorlarda durum biraz daha farklıdır. Normalde public constructor ve parent sınıftaki public construc için geçerli kural , alt sınıfın constructoru çalışmadan önce üst sınıfın constructor’u çalışır ve daha sonra alt sınıfın constructor’u çalışır. Bu sebeple biz bir public constructorun içerisinde hep   ustClassIsmi( );  şeklinde bir constructor çağırımının default bir şekilde olduğunu kabul ederiz.
Ancak statik constructorlarda işler biraz farkı, bu sefer önce alt sınıfın constructoru çalışır sonra üst sınıfın constructor’u çalışır yani public’in tam tersi.
İkinci dikkat edilmesi gereken  bir durum ise ilk nesne yaratıldıktan sonraki nesne yaratılmasında statik constructor çalıştırılmaz. Aşağıda bu konu örneklenmiştir.

 using System;
 class A
 {
    static A()
    {
       Console.WriteLine("A sınıfının statik yapıcı metodu");
    }
    public A()
    {
       Console.WriteLine("A sınıfının statik olmayan yapıcı metodu");
    }
 }
 class B:A
 {
    static B()
    {
       Console.WriteLine("B sınıfının statik yapıcı metodu");
       //sonda B(); varmış gibi kabul edilir.
    }
    public B()
    {  //başta A(); varmış gibi kabul edilir.
       Console.WriteLine("B sınıfının statik olmayan yapıcı metodu");
    }
 }
  class Ana
  {
     static void Main()
     {
       B b1=new B();
       Console.WriteLine("-------");
       B b2=new B();
    }
  }


EKRAN ÇIKTISI
B sınıfının statik yapıcı metodu
A sınıfının statik yapıcı metodu
A sınıfının statik olmayan yapıcı metodu
B sınıfının statik olmayan yapıcı metodu
-------
A sınıfının statik olmayan yapıcı metodu
B sınıfının statik olmayan yapıcı metodu