Metotların,Kurucuların ve Operatörlerin aşırı yüklenmesi dair açıklama ve bir windows uygulaması üzerinde açıklaması
Yazan: Volkan Atasever

           Kurucuların ve operatörlerin aşırı yüklenmesi konusunun daha iyi anlaşabilmesi için öncelikle, metotların aşırı yüklenmesinin izahı daha faydalı olacağı kanaatindeyim.
Şöyle ki:
Araştırmalarımda ;
a)- metotların aşırı yüklenmesi,
b)- Kurucuların aşırı yüklenmesi,
c)- operatörlerin aşırı yüklenmesi'nin ayrı ayrı ele alındığını tespit ettim. Bu makalemde yukarıda belirttiğim üç hususu bir Windows uygulamasın da ne şekilde tatbik edilebileceğini izaha çalışmak istiyorum.
          Bir metodu aşırı yüklemek, aynı isimli birden fazla metodun çalışabilir olması manasına gelmektedir. Tabii bunun içinde bazı kurallarımız vardır. Bunlardan biri, metodumuzun parametrelerinin tiplerinin farklı olmasıdır. Eğer bu koşul sağlanamıyorsa; parametre sayıları farklı olmak zorundadır. Bu koşulu sağladığımızda metodumuza aşırı yüklenmiş diyebiliriz. Dikkat edilmesi gereken diğer bir husus, metodun sadece geri dönüş değerinin farklı bir tipte olması yeterli değildir.
          Öncelikle sınıfımızı tasarlayalım ve bu sınıfımızın içinde aşırı yüklenmiş metotlar bulunsun. Bu metotları nesnemiz üzerinden çağıralım.
          Sınıfımız:


class asiriyukleme
{
           public string yuklenmis(int iYerel)
           {
                      return iYerel.ToString();
           }
           public string yuklenmis(int iYerel1, string sYerel2)
           {
                      return (iYerel1.ToString() + " " + sYerel2);
           }
           public string yuklenmis(bool bYerel)
           {
                      return (bYerel.ToString());

           }

      }

          
Yukarıda ki örnekte dikkat etmeniz gereken husus, geri dönüş değerinin sabit olmasına rağmen parametrelerinin farklı tipte olmasıdır.
          Kurucuları aşırı yüklemeye gelince sizden şöyle bir mantık yürütmenizi tavsiye edeceğim. Kurucularıda bir süreliğine metot gibi görmelisiniz. Bu bakış açısının ardından çok daha kolay kavranacağı kanısındayım. Geri dönüşü olmayan metotlar!
          Kurucularımız içinde farklı bir sınıf tasarlayalım:



      class kurucular
      {

           int iSayi; string sKelime;
           bool bMantıksal;
           public kurucular()
           {
                      iSayi = 123;
                     sKelime = "Sıfırlandım";
                      bMantıksal = true;
           }
           public kurucular(int a, string b)
           {
                      iSayi = a;
                      sKelime = b;
                      bMantıksal = true;
           }
           public kurucular(bool a)
           {
                      bMantıksal = a;
                      sKelime = "Sıfırlandım";
                     iSayi=123;
           }
           public kurucular(bool a, string b)
           {
                      bMantıksal = a;
                     sKelime = b;
                      iSayi = 123;
           }
           public kurucular(int a)
           {
                      iSayi = 123;
                      bMantıksal = true;
                     sKelime = "Sıfırlandım";
           }


}

          Diğer kurucuları yazdığımız için varsayılan kurucuyu da bizim tanımlamamız lazım. Aksi takdir de kurucumuza parametre yollamadığımız zaman, sandığımız gibi varsayılan kurucu çalışmayacak. Hatayla karşılaşmak kaçınılmaz olacaktır. Yukarıda ki kurucular sınıfında farklı parametrelerle çalışabileceğinizi formumuzu da tasarladıktan sonra görebileceğiz.
          Operatörlerin aşırı yüklenmesi ise + operatörünün bir metot ismiymiş gibi her atraksiyonu yaptırmamıza yarar ve kod yazarken inanın çok işimize yarayacaktır. Doğru yazılmış bir sınıfla iki nesneyi toplayabiliriz veya nesnenin önüne + ifadesi getirip o nesnedeki alanların pozitif değerlerini alabiliriz. Aynı mantıkla – operandınıda aşırı yükleyebiliriz. Operatörleri aşırı yüklerken;
           public static geri_döndürdüğü_sınıf_ismi operator
kıstaslarına dikkat etme zorunluluğumuz var.
          Operatorler sınıfımız:


      class operatorler
      {
           public int iSayi=0;
           public operatorler(int a)
           {
                      iSayi = a;
           }
           public static operatorler operator +(operatorler sinif1,operatorler sinif2){
                      operatorler don=new operatorler(0);
                      don.iSayi=sinif1.iSayi+sinif2.iSayi;
                     return don;
           }
           public static operatorler operator -(operatorler sinif1,operatorler sinif2){
                      operatorler don = new operatorler(0);
                     don.iSayi = sinif1.iSayi - sinif2.iSayi;
                      return don;
           }
           public static operatorler operator +(operatorler sinif1)
           {
                      sinif1.iSayi = +sinif1.iSayi;
                     return sinif1;
           }
           public static operatorler operator -(operatorler sinif1)
           {
                      sinif1.iSayi = -sinif1.iSayi;
                      return sinif1;
           }
     }

           Operatörler sınıfımızın kurucusu integer tipinde iSayi isimli bir parametre alıyor. İlk metodumuz iki operatorler tipinden parametresi olan + operandı.
          Bir adet geri dönüş değeri için bir nesne daya yaratıyoruz ve geri dönüş tipi yine operatorler sınıfından unutulmaması gereken geri dönüş değeri olarak operatorler nesnesi yerine void tipide kabul edilebilirdi ama tasarımımız da + operantı ile iki nesne toplayacağımız için böyle bir geri dönüş yararlı olamazdı. Metodumuzun içinde ise don adında bir sınıfı 0 değeri ile canlandırıyoruz. Ardından don isimli nesnemize ilk gelen operatorler sınıfından sinif1 adlı nesnenin iSayi isimli alanına ulaşıp, sinif2 adlı nesnemizdeki iSayi ile toplayıp don adlı nesnemizin iSayi isimli alanına atıyoruz. 2 parametre alan – operatörü de aynı şekilde çalışırken aynı sınıftaki tek parametreli + ve – metotları ise daha farklı çalışmaktadır buradada ikinci bir aşırı yüklenme mevcut. Ve gelen nesnenin içindeki iSayi isimli alanın pozitifini veya negatifini yine aynı nesneye atarak geri döndürebiliyoruz.
           Windows uygulamamızın tasarımı ise aşağıdaki şekilde: 

public partial class Form1 : Form
      {
           operatorler oDeneme1;
           operatorler oDeneme2;
           operatorler oDeneme=new operatorler(0);
          Formumuza öncelikle operatorler sınıfından oDeneme1 ve oDeneme2 yi deklare etmemiz ardından oDeneme sınıfımızı 0 parametresini kurucuya yollayarak canlandırmamız gerekmektedir.
          Kuruculara ait groupboxımızın içinde bulunan comboboxın selectedindexchanged event’ine ise aşağıdaki kodları yazalım:

      private void comboBox2_SelectedIndexChanged(object sender, EventArgs e)
      {
           int i = comboBox2.SelectedIndex;
           kurucular kDeneme;
           switch (i)
           {
                      case 0:
                                kDeneme = new kurucular();
                                listBox1.Items.Add("ilk Kurucu Metot Çalıştı");
                     break;
                     case 1:
                                kDeneme = new kurucular(2, "deneme");
                               listBox1.Items.Add("ikinci Kurucu Metot Çalıştı");
                     break;
                     case 2:
                               kDeneme = new kurucular(true);
                               listBox1.Items.Add("ucuncu Kurucu Metot Çalıştı");
                     break;
                     case 3:
                               kDeneme = new kurucular(true, "deneme");
                               listBox1.Items.Add("dorduncu Kurucu Metot Çalıştı");
                     break;
                     case 4:
                               kDeneme = new kurucular(3);
                               listBox1.Items.Add("besinci Kurucu Metot Çalıştı");
                     break;
           }
      }


           Üstte ki kodumuzda sabit değerlerle comboboxda seçtiğimiz kurucu varyasyonlarını çalıştırıyoruz.
          Metotların aşırı yüklenme örneği içinse, ait olduğu groupbox’a çift tıklayalım ve şu kodları ekleyelim:

      int i = comboBox1.SelectedIndex;
           asiriyukleme aDeneme = new asiriyukleme();
           switch (i)
           {
                      case 0:
                                try
                                {
                                          listBox1.Items.Add(aDeneme.yuklenmis(Convert.ToInt32(textBox1.Text)));
                                }
                                 catch
                                 {
                                           listBox1.Items.Add("Hata");
                                            return;
                                 }
                      break;
                      case 1:
                                try
                                {
                                          listBox1.Items.Add(aDeneme.yuklenmis(Convert.ToInt32(textBox1.Text),textBox2.Text.Trim()));
                                }
                                catch
                                 {
                                          listBox1.Items.Add("Hata");
                                           return;
                                }
                     break;
                      case 2:
                                if (textBox1.Text.ToLower() == "true")
                                listBox1.Items.Add(aDeneme.yuklenmis(true));
                                 else if (textBox1.Text.ToLower() == "false")
                                 listBox1.Items.Add(aDeneme.yuklenmis(false));
                                else
                                 listBox1.Items.Add("Hata Lütfen true veya false yazınız");
                      break;
                     default:
                                listBox1.Items.Add("Lütfen aşırı yükleyeceğiniz metodu seçiniz");
                      break;
      }

          Bu kod parçamızdada textboxlarımızın içindeki değerleri integer tipine çevirip ardından aDeneme nesnesinin üzerinden yuklenmis metoduna parametre olarak gönderiyoruz.aDeneme nesnesinin üzerinde aşırı yüklenmiş yuklenmis metodlarını basit bir switch mantığıyla işliyoruz.
          Son olarakta operatorler sınıfımızın kullanımına değinecek olursak:

           oDeneme = -oDeneme1;
           listBox1.Items.Add("1. Nesnenin Negatifi :"+oDeneme.iSayi);
          oDeneme1 nesnesinin üzerinde – operatörünü kullanarak oDeneme nesnesine atıyoruz çünkü geri dönüş değerimizde bir nesne.

           oDeneme = oDeneme1 - oDeneme2;
           listBox1.Items.Add("1. Nesneden 2. Nesne Çıkarıldı Sonuç:" + oDeneme.iSayi);
          Burada ise diğer – operatörümüz çalışmaktadır – operatörünün iki parametre alan hali ile çalışmaktadır.
          Operatörler groupboxımızdaki 1. + 2. butonumuzu aşağıda ki gibi:

           oDeneme = oDeneme1 + oDeneme2;
           listBox1.Items.Add("2. Nesne ile 1. Nesne Toplandı Sonuç:" + oDeneme.iSayi);
          ve 2. – 1. metodumuzuda aşağıdaki gibi kodlayalım:

           oDeneme = oDeneme2 - oDeneme1;            listBox1.Items.Add("2. Nesneden 1. Nesne Çıkarıldı Sonuç:" + oDeneme.iSayi);

          Uygulamamıza görsellik açısından zenginlik katmak için ise uygulamamıza şu kodları ekleyelim.
Formumuzun Load event’ine:

           private void Form1_Load(object sender, EventArgs e)
           {
                      groupBox1.Enabled = false;
                      groupBox2.Enabled = false;
                      groupBox3.Enabled = false;
           }
Sırasıyla da her radiobutton kontrolümüzün CheckedChanged event’ine de gerekli şekilde true false değerleriyle işleyebilirsiniz.
          Gördüğünüz gibi metotların aşırı yüklenmesinden sonra kurucu metotların ve operatörlerin aşırı yüklenmesini daha kolay izah edebildik. Makalemizde oluşturduğumuz uygulamanın tam kodlarını ve çalıştırılabilir dosyasına örnek kodlar kısmından ulaşabilirsiniz. Yorum ve görüşlerinizi volkan@volkanatasever.com adresine gönderebilirsiniz.