Nesne yönelimli programlama kavramının son temel özelliği olan çok biçimlilik (polymorphism) kavramını “C# Polymorphism Nedir” başlığı altında ele alarak yeni bir bilgi öğrenim serüvenine giriş yapacağız.
Bu çıkacağımız serüven içerisinde çok biçimlilik kavramının avantajları ve örnekleri gibi alt başlıklara yer vererek içeriğimizi bilgi yönünden zenginleştirmiş olacağız. Çıkacağımız bu güzel bilgi serüvenine hazırsanız C# Polymorphism (Çok Biçimlilik) kavramını yakından tanımaya başlayalım. 👨🏻🏫🔎👀
C# Polymorphism Nedir?
C# Polymorphism, nesne yönelimli programlamanın temel yapı taşlarının arasında yer alan, çok biçimlilik olarak bilinen bir kavramdır. C# polymorphism nedir sorusuna ise programımızda oluşan bir nesne yapısının birbirinden farklı nesneler şeklinde davranmasını sağlayan yapı olarak cevaplayabiliriz.
Teorik olarak polymorphism (çok biçimlilik) kavramının tanımını anlamamış olabilirsiniz. Bu yüzden konuyu daha kolay anlamanıza yardımcı olacak, bir biriyle iç içe bir yapıda olan kalıtım konusuna göz atabilirsiniz. İsterseniz daha önce paylaşmış olduğum “C# Kalıtım Nedir” içeriğine emrecelen.com.tr/c-sharp-kalitim-nedir/ bu bağlantıyı takip ederek ulaşabilirsiniz.
Peki C# ile geliştirmiş olduğumuz programlarda çok biçimlilik kavramını kullanmamızın bize ne gibi avantajlar sağladığını, niçin kullanmamız gerektiğini merak ediyorsanız gelin bir sonraki aşamamız olan “C# Polymorphism Avantajları” başlığına geçiş yapalım.
C# Polymorphism Avantajları
- Projelerimizde kurmuş olduğumuz yapılara esneklik sağlar ve farklı yapıdaki işlemler ile arasındaki bağlantı ilişkilerini azaltarak daha güvenli bir hale getirir.
- Kod yapımızın tekrarlayan bir şekilde yazılmasının minimum seviyeye indirerek projelerimizin okunabilirlik oranında artış sağlamasına yardımcı olur.
- Polymorphism yapısı kullandığımız projelerimizde almış olduğumuz hatayı tek bir yapı içerisinde çözüme ulaştırma kolaylığı bulunur.
Polymorphism kavramının bu maddelerde gördüğümüzden daha fazla özelliği ve sağlamış olduğu avantajları vardır. Fakat bilmemiz gereken ve en önemli özellikleri, avantajlarını yukarıdaki maddelere eklediğimden şüpheniz olmasın. 👍🏻
C# Polymorphism Örnekleri
Polymorphism yapısının Türkçe karşılığına baktığımız zaman karşımıza çok biçimlilik, çok şekillilik gibi kavramlar karşımıza çıkıyor. Teorik olarak bu isimler ilk baktığımız zaman aklımızda bazı fikirlerin oluşmasına yardımcı olsa da hayatımızın içerisinden bazı polymorphism örnekleri oluşturmak istiyorum. Bu örnek yapıları şu şekildedir:
- Programlama dillerinde yazmış olduğumuz kodun sorunsuz bir şekilde çalışması için önce kodun derlenmesi gerekmektedir. Derleme işlemi genel bir çatı olsa da işleyiş bakımından C++ üzerinde farklı, Java dilinde farklı bir şekilde arka plana sahiptir.
- Bir ulaşım aracını düşündüğümüz zaman o aracın hareket edebilmesini sürmek eylemi ile ifade etmemize rağmen otomobil için farklı, bisiklet için farklı bir anlam ifade etmektedir.
- Son olarak bir öğrencinin okuduğu okuldan mezun olma koşulu vardır. Fakat bir üniversite öğrencisinin mezuniyeti için gereken koşullar ile bir lise öğrencisinin mezun olması için gerek duyduğu gereksinimlerin farklı olması.
Hayatımızın içerisinde olan bazı kavramları kullanarak oluşturmuş olduğum yukarıdaki örnek yapıları polymorphism (çok biçimlilik) kavramını temsil etmektedir. 🔭📱
Bu aşamaya kadar C# polymorpihsm nedir sorusunu cevapladık, programlarımıza sağlamış olduğu avantajları gördük ve hayatımızın içerisinde bulunan öğeleri kullanarak polymorphism örnekleri oluşturduk. Şimdi ise bu öğrendiğimiz bilgilerden faydalanarak programlarımız içerisinde oluşturduğumuz kod bloklarında polymorphism kavramını nasıl kullanacağımızı öğrenelim. 👨🏻💻
Daha zorlu örnek yapılarına geçmeden önce standart hale gelmiş ve çoğu akademik dersin içerisinde yer bulmuş basit bir polymorphism örneği olan hayvanlar yapısını ele alarak çok biçimlilik kavramında ilk adımımızı atalım.
- Öncelikle hayvan yapılarının genel yönetimini gerçekleştireceğim “Animal” isminde bir sınıf oluşturarak içerisinde gizli olarak tutmak istediğim bazı veriler için değişkenler tanımladım.
- Tanımlamamdan sonra programım içerisinde bu sınıf yapımı polymorphism yapısında kullanmama kolaylık sağlayacak basit bir kaç constructor metot yapısı tanımlayarak kendime bir kolaylık sağladım.(Böylelikle programımı da esnek bir hale sokmuş oldum)
- Üst şablon sınıfımı oluşturduğumuza göre artık bu sınıftan türeyecek alt hayvan grupları için yeni sınıflar oluşturabiliriz. Bunun için “Dog” isminde bir sınıf oluşturdum.
- Bu sınıf yapısı içerisinde üst sınıfta bulunan constructor yapılarını ve metotları override ederek yeni bir tanımlama oluşturdum.
- Farkı daha iyi gözlemleyebilmek adına bir alt hayvan sınıfı daha oluşturarak bu yapıma “Cat” ismini verdim.
- Daha sonra “Dog” sınıfında olduğu gibi yapımın özelliklerini değiştirecek yeni tanımlamalar oluşturdum.
- Tüm bu işlemler sonucunda polymorphism yapısının sonuçlarını gözlemlemek için “Main” sınıf yapıma giderek bazı tanımlamalar gerçekleştirdim.
Uygulamış olduğum bu iki aşamadan sonra ilk adımım olan “Animal” sınıf yapımın içeriği aşağıdaki halini almış oldu.
namespace PolymorphismApp
{
class Animal
{
///---> Değişken Tanımlamaları <---\\\
protected string name, sound, info, mark = new string ('-',6);
public string getInfo
{
get { return info; }
}
///---> Constructor Metot Tanımlamaları <---\\\
public Animal()
{
this.name = null;
this.sound = null;
this.info = null;
}
public Animal (String name, String sound)
{
this.name = name;
this.sound = sound;
this.info = null;
}
public Animal (String name, String sound, String info)
{
this.name = name;
this.sound = sound;
this.info = info;
}
///---> Metot Tanımlaması <---\\\
public void infoText()
{
Console.WriteLine("{0}\n < Hayvan Kimliği >\n{1}\n-> Türüm: {2}\n-> İsmim: {3}\n-> Çıkardığım Ses: {4}\n{5}",mark,mark, info,name,sound,mark);
}
}
}Bu tanımlama işlemlerimden sonra “Dog” sınıfımın içeriği aşağıdaki halini almış oldu.
namespace PolymorphismApp
{
class Dog : Animal
{
public Dog(String name)
{
this.name = name;
this.sound = "Hav Hav";
this.info = "Köpek";
}
public Dog (String name, String info)
{
this.name = name;
this.info = info;
this.sound = "Hav Hav";
}
}
}
namespace PolymorphismApp
{
class Cat : Animal
{
public Cat(String name)
{
this.name = name;
this.sound = "Miyav Miyav";
this.info = "Kedi";
}
public Cat (String name, String info)
{
this.name = name;
this.sound = "Miyav Miyav";
this.info = info;
}
}
}namespace PolymorphismApp
{
class Program
{
static void Main(string[] args)
{
///---> Gerekli Tanımlamalar <---\\\
Animal dog = new Dog("Zaar","Kangal");
Animal cat = new Cat("Mutlu", "Tekir");
///---> Ekran Çıktılarına Bakalım <---\\\
dog.infoText();
Console.WriteLine("");
cat.infoText();
}
}
}Kod Çıktısı:
Bu örnek ile edindiğimiz teorik bilgiyi basit bir şekilde anlamlandırdığımızı düşünüyorum. Eğer, örnek yapısını anlamakta zorluk çekiyorsanız bir sonraki örneğe geçmeden aşağıda bulunan yorum yap kısmından bana anlamadığınız noktayı sorabilirsiniz. Unutmayın bu öğrenmek için çıktığımız yolda beraber yürürsek daha güçlü oluruz. 🚶🏻 🚶🏻♂️💪🏻
Temel olarak çok biçimliliğin uygulanması konusunda bir fikir sahibi olduğumuza göre artık daha farklı ve projelerimizde kullanabileceğimiz yeni bir örnek oluşturabiliriz. Merak etmeyin konuyu daha iyi anlayabilmemiz için yukarıdaki “hayvan sesleri” uygulamasının şablonuna benzer bir yapı oluşturarak örneğimizi çözeceğiz.
Bir firmanın çalışan elemanlarının bilgilerini kayıt altına alarak bazı hesaplamalar yürütebilmesine imkan veren bir otomasyon sistemi düşünelim. Bu otomasyon sisteminde eklenen çalışanları mühendisler ve diğer çalışanlar olarak iki alana ayırarak çeşitli özel işlemlere tabii tutacak olalım. Bu sistemi kod içerisine entegre edebilmek için aşağıdaki aşamaları gerçekleştirdim.
- İki kısımdan oluşacak bu kayıt sistemimizin ilk ve genel sınıfı olacak “Employe” isminde bir sınıf oluşturarak örneğimizin ilk adımını atmış oldum.
- Daha sonra bu oluşturduğum sınıf yapısının içerisine çalışan kişilerin bilgilerini not alabileceğim, işleyebileceğim bazı değişkenler ve metot yapıları tanımladım.
- Bu tanımlamalardan sonra sınıf yapımı kullanarak bir çalışanın eklenmesini sağlayacak Constructor metotların tanımlamasını gerçekleştirdim.
- İlk adımımızı başarılı bir şekilde attığımıza göre artık örneğimizin ikinci kısmı mühendislerin kayıt olmasını sağlayacak yeni bir sınıf oluşturmaya geçebiliriz. Bunun için “Engineer” isminde bir sınıf tanımladım.
- Tanımlamış olduğum sınıfımın içerisine girerek kayıt işlemini gerçekleştirecek Constructor yapılarını kurdum.
- Tüm bu işlemlerden sonra “Employe” sınıfı içerisinde çalışanlara zam yapmak için oluşturmuş olduğum metot yapımı override ederek yeni bir zam sisteminin hesaplamasını oluşturdum.
- Bütün bu işlemler sonunda “Main” sınıfıma giderek çalışanların kayıtlarını oluşturdum ve bunun sonucunda konsol ekranına nasıl bir çıktı verdiğini gözlemledim.
Tüm bu işlemler sonucunda örneğimin ana gövdesini oluşturacak “Employe” isimli sınıf yapım aşağıdaki halini almış oldu.
namespace PolymorphismApp
{
class Employe
{
///---> Değişken Tanımlaması <---\\\
private int salary, hday, raise;
private string job = "Çalışan", mark = new string('-', 6);
public string name, surname;
///---> Private Değişkenlere Erişmek İçin <---\\\
public int pSalary
{
get { return salary; }
set { salary = value; }
}
public int pHday
{
get { return hday; }
set { hday = value; }
}
public string pJob
{
get { return job; }
set { job = value; }
}
///---> Constructor Metot Yapıları <---\\\
public Employe()
{
this.name = null;
this.surname = null;
this.job = null;
this.salary = 0;
this.hday = 0;
}
public Employe(string name, string surname)
{
this.name = name;
this.surname = surname;
this.job = "Stajyer";
this.salary = 2900;
this.hday = 7;
}
public Employe(string name, string surname, int salary)
{
this.name = name;
this.surname = surname;
this.salary = salary;
this.job = createJob(salary);
setHday();
}
///---> Metot Tanımlamaları <---\\\
public string createJob(int salary)
{
if (job.Contains("Çalışan") == true)
{
if (salary >= 2900 && salary <= 3900)
return "Vasıfsız Çalışan";
else if (salary > 3900 && salary <= 4900)
return "Vasıflı Çalışan";
else if (salary > 4900 && salary <= 5900)
return "Kıdemli Çalışan";
else if (salary > 5900)
return "Uzman Çalışan";
else
return "Stajyer";
}
else if (job.Contains("Mühendis") == true)
{
if (salary >= 5000 && salary <= 6000)
return "Mühendis";
else if (salary > 6000 && salary <= 7000)
return "Kıdemli Mühendis";
else if (salary > 7000)
return "Uzman Mühendis";
else
return "Stajyer Mühendis";
}
else
return "Stajyer";
}
public void setHday()
{
if (job.Contains("Çalışan"))
{
if (job.Contains("Uzman"))
hday = 28;
else if (job.Contains("Kıdemli"))
hday = 21;
else
hday = 14;
}
else
{
if (job.Contains("Uzman"))
hday = 35;
else if (job.Contains("Kıdemli"))
hday = 28;
else
hday = 21;
}
}
public void makeRaise(int value)
{
raise = salary;
///---> Mühendislere Ekstra %10 Zam Uygulanıyor <---\\\
if (job.Contains("Mühendis"))
{
salary += value;
salary = salary + Convert.ToInt32(salary * 0.1);
job = createJob(salary);
setHday();
}
else if (job.Contains("Çalışan"))
{
salary += value;
job = createJob(salary);
setHday();
}
}
public void infoBox()
{
Console.WriteLine("{0}\n< {1} Bilgileri >\n{2}\n-> Personel İsmi: {3}\n-> Personel Soyismi: {4}\n-> Görevi: {5}\n-> Maaşı: {6} TL\n-> İzin Günü: {7} Gün\n{8}"
, mark, job, mark, name, surname, job, salary, hday, mark);
}
public void raiseBox()
{
if (raise != 0)
Console.WriteLine("{0}\n < {1} Zam Uygulaması >\n{2}\n-> Personelin Eski Maaşı: {3} TL\n-> Yeni Verilecek Maaş: {4} TL\n{5}", mark, job, mark, raise, salary, mark);
}
}
}Bu işlemlerden sonra “Engineer” ismindeki sınıfımda tamamlanmış oldu.
namespace PolymorphismApp
{
class Engineer : Employe
{
public Engineer (string name, string surname)
{
this.name = name;
this.surname = surname;
this.pJob = "Stajyer Mühendis";
this.pSalary = 4000;
this.pHday = 14;
}
public Engineer(string name, string surname, int salary)
{
pJob = "Mühendis";
this.name = name;
this.surname = surname;
this.pJob = createJob(salary);
this.pSalary = salary;
setHday();
}
}
}namespace PolymorphismApp
{
class Program
{
static void Main(string[] args)
{
///---> Çalışan Sınıflarının Tanımlanması <---\\\
Employe employe = new Employe("Mert","Çağlayan",3500);
Employe engineer = new Engineer("Ömer Faruk", "Yıldız",5500);
///---> Kayıtların Ekran Çıktısını Oluşturalım <---\\\
employe.infoBox();
Console.WriteLine("");
engineer.infoBox();
}
}
}Kod Çıktısı:
İsterseniz birde bu yapımızın sorunsuz bir şekilde çalıştığını kontrol etmek için oluşturmuş olduğumuz çalışanlara “750 TL” zam uygulayalım (Mühendis mesleğinde bulunan kişiler zam uygulamalarında ekstra olarak %10 daha zam elde edecektir). Daha sonra zam sonucunda çalışan kişilerin bilgisini tekrar sorgulayarak bir konsol çıktısı alalım.
Kod Çıktısı:
Polymorphism (Çok Biçimlilik) kavramını anlamamız ilk başta zor ya da karmaşık bir kavrammış gibi gelmiş olsa da projelerimizde kullanmamız bizlere oldukça hızlı ve esnek bir yapı oluşturmamıza yardımcı olacak zevkli bir konu.
Teorik olarak “C# Polymorphism Nedir” sorusuna ekstra bir kaynaktan daha cevap aramak isterseniz sizlere Microsoft tarafından hazırlanmış rehber içeriğini öneririm. Bahsetmiş olduğum içeriğe buraya tıklayarak ulaşabilirsiniz.
Unutmayın, aklınıza takılan, sormak istediğiniz ya da konu işleyişi hakkında bulunacağınız herhangi bir öneriyi aşağıda bulunan yorum yap kısmında bana iletebilirsiniz. 👋🏻
