Nesne Tabanlı Programlama Nedir ve Mantığı Nasıl Çalışır?


KAPSÜLLEME
Nesne tabanlı programlamada esas olan, gerçek hayatta var olan olguların programlamaya aktarılmasıdır. Bundan önceki klasik programlamalarda verilerimiz ve fonksiyonlarımız mevcuttu. Buna göre
her şey veri ve bu veriyi işleyen metotlar tarafından dönüyordu. Nesne tabanlı programlamaya baktığımızda veri ve veriyi işleyip mantıklı sonuçlar üreten metotlar bulunur.

Mesela elimizde bir ütümüz olsun. Ütüye ait olan ütünün markası,modeli,rengi,çalıştığı elektrik voltajı ne tür kumaşları ütülediği bu
Ütüye ait özeliklerdendir.<<<(Veri).
Aynı zamanda ütümüzü ısıtabiliriz ütüleme işinde kullanabiliriz. Tüm bunlar ütünün fonksiyonlarıdır.<<<(metot).

Eğer nesne tabanlı programlama ile ütü ile ilgili bir program yapmış olsaydık, hemen bir ütü sınıfı(class) oluştururduk. Bu sınıfta ütüye ait bilgiler(veriler) ve ütü ile yababileceğimiz işler(metot)bulunurdu.

Şimdi kapsüllemenin ne olduğuna bakalım:
Kapsülleme, kendi amacına yönelik olarak yönetmiş olduğu kod ve veriyi
Birbirine bağlayan kod ve veriyi dış kaynaklı karışıklık ve hatalı  kullanım
dan koruyan bir sistemdir. Burada kod ve bulunan veriler bir bütün olarak
tutulur ve saklanır. Buna günlük yaşantımızdan örnek verecek olursak eli-
mizde bulunan   kapsüllü bir antibiyotik verilebilir. Mantık burada da aynı-
dır. Antibiyotiğin içinde bulunan toz dışardaki etkenlerden korunmak ama
cıyla kapsülle ambalajlanmıştır. Nesne tabanlı programlamada kod ve veri
kapsüllemeyle birbirine bağlanabilir. Burada yapılacak olan işlem için gerekli olan kod ve veri kapsülleme  içinde mevcuttur. Kod ve veri birbi
rine bağlandığında ortaya bir nesne(object)meydana gelir. Nesne taban
lı programlama da kapsülleme birimi sınıf(class)’tır. Sınıf,verileri ve bu
verilerle yapılacak olan işlemleri belirler. Başka bir deyişle sınıf bir nesnenin ne şekilde yapılandırılacağını belirler. Kod ve veri sınıf üyeleri içerisinde yer alır. Metot ise bir alt programdır. Kısaca ifade etmek gerekirse programlama dillerinde kullanılan fonksiyonlar nesne tabanlı
programlamada metot adını almıştır.  Kapsüllemeyle istediğimiz dışında
oluşabilecek atamaların önüne geçmemize ve ille de bu alanların değeri değişecekse bu bizim belirlediğimiz çizgide olur. Bu sayede de programcılıkta  ve özellikle nesne tabanlı programlamada çok büyük bir yere sahip olan kontrolün elimizde olmasını sağlıyor. Kapsülleme  nesneler arasındaki olan bağlantıyı azaltmaya yardımcı olur ve kod dayanıklılığını bu şekilde artırmış olur.  Ayrıca kapsülleme erişim değiştirici veya derleme dışında kod görünürlüğünü belirlememizi sağlar.
Şimdi erişim değiştiriciler ve kimler tarafından erişileceğine  bakalım.
Özel: Sadece aynı tür üyeler erişebilir.
Korumalı: Aynı türden türetilmiş üyeler erişebilir.
İç: Aynı derleme içindeki kod
İç Korunmuş:Aynı derlemeden türetilmiş kod.
 Kapsüllemenin  amaçlarına baktığımızda iki tür amacı vardır:
     1. Arka Plan Kodlarini Gizleme: Oluşturulmuş  bir class içinde yer alan kullanıcının yapacağı işlemlerin daha kolay gerçekleştirebilmesi için bazı işlemler birleştirilip (kapsüllenerek) birleştirilen bu  işlem bir işlem gibi gösterilir. Örneğin veri tabanında gerçekleştirilen bağlantı işleminde, biz sadece bağlantı değişkeninin var olan  Open() metodunu kullanmaktayız. Fakat sınıf içerisinde  kullanıcıdan aldığı  parametreleri kullanarak bağlantıyı gerçekleştirebilmek için birçok metot bulunmaktadır. Bu metotları kullanıcıya  gösterip bağlantıyı gerçekleştirebilmek için   tüm bunları su şekilde birleştirin demek yerine bu işlem sınıf  içerisinde yapılmış ve kullanıcının daha kolay kullanabilmesi için Open() metodu oluşturulmuştur.
     2. Değişkenlere Tam Erişimi Engelleme: Sınıf  içerisinde oluşturduğumuz global değişkenlere  dışarıdan erişmek için public olarak tanımlama yapmaktayız. Fakat bazen bu değişkenlerin değerlerini değiştirmek istemeyebiliriz. Fakat kullanmamız da gerekebilir. Bu durumda değişkenimizi  kapsüllememiz gerekmektedir. Yani, bu değişkeni private olarak tanımlamak ve bir read-only property ile bu değişkenin yazma iznini ortadan kaldırmamız gerekmektedir.
Şimdide kapsüllemenin özelliklerine bakalım:
Ø     Bir nesnenin dış dünyadan soyutlanıp iç dünyasında işlem yapması
Ø     Başka kod ve sınıflar tarafından kullanılmaması için bir koruyucu
bariyer  görevi görür.
Ø     Kodları erişilmez hale getirir.
Ø     Nesne tabanlı programlamanın temel ilkelerinden birisidir.

Not: Class içerisinde bir değişkene ulaşılmasını istemiyorsak bunu
private  olarak tanımlamalıyız.

Not : Class içinde bir değişkene ulaşılmaması için private olarak tanımlamalısınız.




Şimdi kapsüllemeyle ilgili örneklere göz atalım:


İlk örneğimiz kapsüllemenin temel amaçlarından olan arka plan kodlarını gizleme ve tam erişimi engellemeyle ilgilidir.

class SMS
    {
        private string kullaniciAdi, sifre;//private türünde değişkenler tanımladık.
        public SMS(string kullaniciAdi, string sifre)
        {
            this.kullaniciAdi = kullaniciAdi;
            this.sifre = sifre;
        }
        private void TurkceKarakterleriDuzenle(ref string mesaj)
        {
            char[] trKarakterler = { 'ç''g''i''ö''s''ü''Ç''G''I','Ö''S''Ü' };
            char[] ingKarakterler = { 'C''g''i''o''s''u''C''G''I','O''S''U' };
            for (int i = 0; i < ingKarakterler.Length; i++)
            {
                mesaj.Replace(trKarakterler[i], ingKarakterler[i]);
            }
        }
        private string XMLOlustur(string mesaj)
        {
            //Mesaj metnini, kullanici adi ve sifreyiXML içerisine yerlestir.
            throw new NotImplementedException();
        }
        private void SMSGonder(string xmlMetni)
        {
            //SMS'i gönderme islemi
        }
        public void Gonder(string mesaj)
        {
            //Türkçe karakterleri düzenle
            TurkceKarakterleriDuzenle(ref mesaj);//1

            string xmlMetni = XMLOlustur(mesaj);//2

            SMSGonder(xmlMetni);//3
        }
    }




Örnek2:
using System;
class Temel
{
protected double sayi =100.2;//sayımız ondalıklı olduğu için double olarak tanımladık.
}
class Tureyen : Temel
{
void erisim()
{
Temel t=new Temel();
Tureyen tr=new Tureyen();//Tureyen sınıfından Tureyen isimli bir nesne türetildi.
t.sayi=54.3; //Bu satırla hata olur.
tr.sayi=55.5; // Bu satırla hata olmaz.
}
}

Bu örnekte problemde protected erişim belirteciyle sayı adlı bir değişken oluşturularak ilk değeri atanmıştır. Temel sınıfın karakteristiğini taşıyan
Türeyen sınıfı oluşturularak erişim metodunda her iki sınıftan t ve  tr adlı
İki üye değişken atanmıştır. Bu iki değişkene ilk değerleri atanarak program derlendiğinde hata meydana gelmektedir.
Ünkü temel sınıftan oluşturulan t üye değişkeni türeyen sınıfta tanımlandığı için protected erişim belirteçli sayı değişkeninin içeriğini değiştirmeyecektir. Ancak, türeyen sınıftan oluşturulan tr üye değişkeni
Sayı değişkeninin içeriğini değiştirebilir. Böylece kapsülleme gerçekleştirilmiş olur.Programın çalışması için t. Sayi ile başlayan satırın önüne //yazarak derlemeye dahil edilmemesi gerekir.
using System;
namespace encaps2
{
class Temel
{
protected double sayi=100.2;
}
class Tureyen : Temel
{
static void Main()
{
Temel t= new Temel();
Tureyen tr =new Tureyen();
//t.sati=54.3 //Bu satırda hata olur.
tr.sayi=55.5; // Bu satırla hata olmaz.
}
}
}
KALITIM
 Nesne tabanlı programlama  dünyasında kalıtım kilit öneme sahip bir kavramdır. Nesne tabanlı programlamada gerçek dünya problemlerini bilgisayar uygulamaları yardımıyla çözmek için bu problemleri modellemek gerekir. Sınıflar, modellemenin yapı taşlarıdır.  Buna bir örnek verelim: Bir okul yönetim uygulaması geliştirileceği düşünülsün. Uygulamada müdür, öğrenci ve öğretmenleri modellemek için sınıflardan (Bunu okuldaki sınıflarla karıştırmayalım.) yararlanılır. Ancak hem müdür hem öğretmen hem de öğrenciler ortak özelliklere sahiptir. Örneğin, hepsinin de birer adı vardır. Müdür, öğretmen ve öğrenci sınıflarının hepsinde de ad şeklinde bir özellik kullanılırsa kod tekrarından nasıl kaçınılabilir? Bu pek de  mümkün olmaz. Mümkün olmayan bu durumu
Mümkün hale getirmemiz gerekir. Bu noktada devreye kalıtım girmektedir. Oluşturulmuş olan bu  sınıfların üstünde insan adında bir sınıf oluşturup müdür, öğretmen ve öğrenci sınıflarını da insandan türeterek bu problemin üstesinden gelinebilir. Hemen tüm problemleri modellerken benzer senaryolarla karşılaşılmakta ve kalıtımı yoğun bir şekilde kullanılmaktadır. Gereksiz kod tekrarından kaçınmanın yegâne yolu kalıtımı kullanmaktır. Kalıtımı anladıktan sonra gerçek dünyada da aslında her şeyin kalıtımla ne kadar ilişkili olduğu görülür. Artık modellemeler kalıtım olmaksızın düşünemez hâle gelinir.

1.1.Temel Sınıflar ve Türetilmiş Sınıflar
Nesne tabanlı programlama kullanmada ki amaç problemleri gerçek dünyadakine benzer tarzda nesneler şeklinde modelleyerek çözmeye çalışmaktır. İnşaat sektöründe bir bina nasıl inşa edilir? Bu binayı inşa etmek için öncelikle  projesi çizilir. Daha sonra ise bu proje gerçekleştirilir. Ve bina bu şekilde ortaya çıkar. Nesne tabanlı programlamada da önce sınıflar (bina örneğindeki projeye benzetilebilir) tasarlanır. Bir uygulama çok sayıda sınıf yardımıyla modellenebilir. Bu sınıflardan bazıları temel sınıf bazıları da türetilmiş sınıflardır.



Temel sınıf nesne tabanlı programlamada  “Ata” sınıf olarak işlev görür. Türetilmiş sınıf ise temel sınıfın özelliklerine sahip olmanın yanında kendisi temel sınıfta bulunmayan bazı yeni özellikler de geliştirebilir. Örneğin, girişte de bahsedildiği gibi bir “okul yönetim uygulaması” geliştirileceği düşünülsün. İşe okulda mevcut olan her şey modellenerek başlanır. Okulumuzda değişik rollerde insanlar vardır. Müdür, müdür yardımcısı, öğretmen, memur, hizmetli, öğrenci rolleri bunlara örnek sayılabilir. Her insan rolü için ayrı ayrı sınıf oluşturmak yerine “insan” sınıfı oluşturup  bundan sonra bu sınıftan “kalıtım” yoluyla “müdür”, “müdür yardımcısı”, “öğretmen”, “memur” ve “öğrenci” sınıfları türetilebilir. Bu örnekte “insan” sınıfı “temel sınıf”, diğerleri ise “türetilmiş sınıf” olarak adlandırılmaktadır.

                    class Insan
 {
 //temel sınıf üyeleri
 }
 class Ogrenci : Insan//kalıtım yapıldı.
 {
 //türetilmiş sınıf üyeleri
}
Yukarıdaki örnekte görüldüğü gibi “Kalıtım yoluyla türetme ’’ : (iki nokta üst üste) işlemci yardımıyla yapılmaktadır. İki noktanın solundaki sınıf (Ogrenci) türetilmiş, sağındaki ise (Insan) temel sınıftır. Burada Ogrenci sınıfı Insan sınıfından türetilmiş bulunmaktadır. Diğer bir ifadeyle Ogrenci sınıfı Insan sınıfının özel (private) olmayan tüm üyelerini kalıtım yoluyla almış bulunmaktadır. Türetme sonucunda Insan sınıfının özel (private) olmayan tüm alanlarını otomatik olarak Ogrenci sınıfı içermektedir.
Bir sınıftan doğrudan en fazla bir sınıftan türetilebilir. İki ya da daha fazla sınıftan türetilemez. Eğer böyle bir ihtiyaç olursa arayüzleri(interface) kullanmamız gerekir. Ancak tüm sınıflar dolaylı olarak System.Object sınıfından türetilmektedir. Bunun belirtilmesine de gerek yoktur. Örneğin yukarıda oluşturulan Insan sınıfına hiç üye eklenmese bile bazı üyelere otomatik olarak sahip olduğu görülür. Bunlardan bir tanesi ToString metodudur. Aslında bütün sınıflar bu metoda sahip olur. Bu da onların dolaylı olarak System.Object sınıfından türediğini kanıtlar.
Aşağıdaki tabloda Class View penceresi görülüyor.  Burada Insan sınıfının temel sınıfının (Base Types) Object olduğu açıkça görülmektedir.

Türetilmiş olan bir bir sınıftan başka sınıflar da türetilebilir. Ancak bunun bir şartı vardır. Eğer bir sınıfı  Sealed” olarak tanımlanmışsak bu  sınıftan başka bir sınıf türetilemez.
class Mudur : Insan
 {
 //türetilmiş sınıf üyeleri
 }
class MudurYardimcisi : Insan
 {
 //türetilmiş sınıf üyeleri
}
class Ogretmen : Insan
{
 //türetilmiş sınıf üyeleri
}
Türetilebilir.

1.2. Temel Sınıf Kurucularını Çağırma
Türetilmiş bir sınıf, temel sınıfın sahip olduğu tüm alanlarına sahiptir. Bu alanların başlangıçta ilk değerlerinin belirlenmesi gerekir. Bu amaçla kurucu metotlar çağrılır. Türetilmiş olan  bir sınıftan temel sınıfa ait kurucu metodu çağırmak için “base” anahtar sözcüğü kullanılır.

class Insan
{
//temel sınıf üyeleri public Insan(string ad)
//temel sınıf için kurucu metot { //... } //...
}
 class Ogrenci : Insan
{
//türetilmiş sınıf üyeleri
 public Ogrenci(string ad) : base(ad)//Insan(ad) temel sınıf kurucu metodunu çağırır.
{
 //…
 }
 //...
}
Bu şekilde temel sınıf kurucusu çağırılmazsa derleyici varsayılan temel sınıf kurucusunu çağırmaya çalışır. Çağrılan temel sınıf kurucusu  başarılamazsa bir derleyici hatası oluşur.

1.3.Sınıflar Atamak
Bir sınıf türü kullanarak bir değişken bildirmek ve  daha sonra bir nesne yaratarak  yaratılan bu değişkene atamak için aşağıdaki söz dizimi kullanılır. Aşağıdaki  gibi mevcut bir hiyerarşik yapıya sahip olunsun.

class Insan// insan adında bir class yaratıldı.
 {
 //temel sınıf üyeleri
public double Boy, Kilo;
 public string Ad;//string türünde ad tanımlandı dışardan erişilebilir.
public Insan(string ad)//temel sınıf için kurucu metot
 {
this.Ad = ad;
 this.Boy = 0.45;
this.Kilo = 3.5;
 }
 public void Buyu()
 {
Boy += 0.5; Kilo += 0.5;
 }
 }
class Ogrenci : Insan
 {
//türetilmiş sınıf üyeleri
 public Ogrenci(string ad) : base(ad)
//Insan(ad) temel sınıf kurucu metodunu çağırır
}
 new public void Buyu()
 {
 this.Boy += 1.5;
 this.Kilo += 1.5;
 }
public void Oku()
 {
 //Oku metodu kodları
}
 }
class Ogretmen : Insan//kalıtım yapıldı.
 {
public Ogretmen(string ad) : base(ad)
{
}
}
Burada bir Ogrenci  değişkeni Ogrenci  türünde bildiriliyor ve new sözcüğü ile oluşturulan yeni nesne bir Ogrenci değişkenine atanıyor.
Programlama dilindeki tür denetim kuralları bir türdeki nesneyi farklı bir türde bildirilmiş bir değişkene atamaya izin vermez.

 Ogrenci birOgrenci = new Ogrenci("Ali UZUN");
Ogretmen birOgretmen = birOgrenci; //hata

Ogrenci birOgrenci = new Ogrenci("Ali UZUN");
 Insan birInsan = birOgrenci; //geçerli bir atama

Ogrenci sınıfından tanımlanmış birOgrenci, Insan sınıfından tanımlanmış birInsan değişkenine atanabilir çünkü Insan sınıfı hiyerarşinin üst sırasında yer almaktadır.

1.4. New Metodu
 Programlamada programcının çok zorlandığı durumlardan bir tanesi de sınıflara ve sınıfların üyelerine benzersiz ve anlamlı adlar bulmaktır. Bu uğraşlar sonucunda sınıf hiyerarşisi içerisinde temel sınıfa ait bir metodun adı türemiş sınıfta kullanılacaktır. Örneğin,
 class Insan
 {
 //temel sınıf üyeleri
 public double Boy, Kilo;
 public string Ad;
 public Insan(string ad)
//temel sınıf için kurucu metot
{
this.Ad = ad;
 this.Boy = 0.45;
 this.Kilo = 3.5;
 }
public void Buyu()
 {
 Boy += 0.5;
 Kilo += 0.5;
 }
}
class Ogrenci : Insan
{
 //türetilmiş sınıf üyeleri
public Ogrenci(string ad) : base(ad)
//Insan(ad) temel sınıf kurucu metodunu çağırır
 {
 }
 new public void Buyu()
 {
 this.Boy += 1.5;
this.Kilo += 1.5;
}
 public void Oku()
 {
//Oku metodu kodları
}
 }

Insan  temel sınıfında yer alan Buyu metodu Ogrenci  türemiş sınıfında da kullanılmaktadır. Derleyici bu durumda Insan sınıfındaki Buyu metodunun gizlendiğini belirten bir uyarı görüntüler. Bu uyarı aynı zamanda “new” sözcüğünü kullanarak bu uyarının kaldırılabileceğini de belirtir. İşte türemiş Ogrenci sınıfındaki Buyu metodunun başında “new” sözcüğünü kullanma nedeni budur. Burada derleyiciye bilinçli olarak temel sınıftaki Buyu metodunun gizlendiği bildirilmiş olunuyor.

1.5.Virtual(Sanal) Metodu
Temel sınıfa ait bir metodun bazen türemiş sınıfta farklı bir şekilde kullanılması gerekebilir. Bu durumda temel sınıfın söz konusu metodu türemiş sınıfın değiştirip kullanabileceği yönünde izin vermesi gerekir. Bu izin, metodun temel sınıfta “virtual” olarak tanımlanması sonucu verilmektedir. Diğer bir ifadeyle temel sınıfta “virtual” olarak tanımlanmış bir metodun türemiş sınıfta yeniden yazılabileceği belirtilmiş olunuyor.
Örneğin:
public class Sekil
 {
public const double PI = Math.PI;
 protected double x, y;
 public Sekil()
{
 }
 public Sekil(double x, double y)
 {
 this.x = x; this.y = y;
 }
public virtual double Alan()
 { return x * y;
 }
}

Sekil sınıfına ait alan adında bir metot olsun. Örnekte alan metodunun “virtual” tanımlandığına dikkat edilmelidir. Sekil sınıfından türeyecek diğer sınıflar içerisinde alan metodunun değiştirilerek yeniden yazılmasına burada izin verilmiş bulunuluyor.

1.6.Override(Geçersiz Kılma) Metodu
Temel sınıfta “virtual” tanımlanmış bir metodun türemiş sınıfta yeniden yazılması için (geçersiz kılma) “override” sözcüğü kullanılır. Temel sınıfta “virtual” tanımlanmamış ya da “static” tanımlanmış olan üyeler (metot, özellik, dizinleyici ya da olay) türemiş sınıfta yeniden yazılamaz (Geçersiz kılınamaz.). 1.4 baĢlığı altında verilen örneği şu şekilde genişletilebilir:

public class Daire : Sekil
 {
 public Daire(double r) : base(r, 0)
 {
 }
 public override double Alan()
 {
 return PI * x * x;
}
}
class Kure : Sekil
 {
 public Kure(double r) : base(r, 0)
 {
 }
 public override double Alan()
 {
 return 4 * PI * x * x;
 }
 }
 class Silindir : Sekil
{
public Silindir(double r, double h)

: base(r, h)
{
}
 public override double Alan()
 {
return 2 * PI * x * x + 2 * PI * x * y;
}
}
Bu örnekte Daire, Kure ve Silindir sınıfları Sekil temel sınıfından türetilmişlerdir. Hepsinde de Sekil sınıfında “virtual” tanımlanan alan metodu yeniden yazılmıştır. Bu yeniden yazma (geçersiz kılma) esnasında “override” sözcüğünün kullanıldığına dikkat ediniz. Ayrıca burada dikkat edilmesi gereken nokta “virtual” ve “override” metotların imzalarının (dönüş türleri ile birlikte parametrelerinin tür ve sayıları) aynı olması gerekliliğidir.
 Bir diğer önemli nokta da “override” metotlar “new”, “static” ya da “virtual” sözcükleri ile tanımlanamaz.
Son olarak “virtual” metodun erişim belirteci “override” sırasında değiştirilemez. Yani temel sınıfta metot “public” ise türemiş sınıfta da “public”, “protected” ise “protected” kalmalıdır.

1.7.Protected(Korumalı)Erişim
Protected” sözcüğü bir erişim belirtecidir. Yani bir sınıfın üyelerine kalıtım hiyerarşisi içinde o sınıftan türemiş diğer sınıfların erişebileceğini belirtir. Hiyerarşi dışından ise kimse “protected” üyelere erişemez. Benzer şekilde erişimi denetleyen “public” sözcüğü bir üyeye herkesin erişebileceğini, “private” sözcüğü ise sınıf dışından üyeye kimsenin erişemeyeceğini belirtir. Programlama dili tasarımcıları, sınıflar içerisinde yer alan üyelere erişim konusunda programcılara tam bir özgürlük sağlar. Ancak nesne tabanlı programlama belgeleri alanların “private” tutulmasını, alanlara erişimin özellik adı verilen özel metotlarla yapılmasını önerir.

Şimdi kalıtımı genel bir örnekle inceleyelim:

sing System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Kalitim
{
    class otomobil
    {
        public int agirlik; //her yerden erisilebilir erisim seviyesi.
        public int  motorHacmi; //her yerden erisilebilir erisim seviyesi.
        public string renk; //her yerden erisilebilir erisim seviyesi.

        public virtual  void aracOzellikleri()//virtual anahtar kelimesi
        {
            Console.WriteLine("aracin ağırlığı=> {0},aracin motorHacmi=>{1},aracin rengi=>{2} ", agirlik, motorHacmi, renk);
        }
    }
    class spor : otomobil//Kaltım yapılmış
    {
        public int kapiSayisi;
        public string model;
        public override void aracOzellikleri()//override anahtar kelimesi
        {
          //base.aracOzellikleri();burayı aktif yaparsak otomobil sinifına ait aracOzellikleri metodu çalışacaktı.
            Console.WriteLine("aracin ağırlığı=> {0},aracin motorHacmi=>{1},aracin rengi=>{2},aracin kapı sayısı=>{3},aracin modeli{4} ", agirlik, motorHacmi, renk,kapiSayisi ,model );
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            otomobil otomobil1 = new otomobil();
            otomobil1.agirlik = 1250;
            otomobil1.renk = "beyaz";
            otomobil1.motorHacmi = 1600;
            otomobil1.aracOzellikleri();
            Console.ReadLine();
            ///////////////////////////////////////
            spor spor1 = new spor();
            spor1.agirlik = 1400;
            spor1.renk = "kırmızı";
            spor1.motorHacmi = 2500;
            spor1.kapiSayisi = 4;
            spor1.model = "2012";
            spor1.aracOzellikleri();
            Console.ReadLine();

 }
        }
    }

Programın ekran çıktısı aşağıdaki gibi olacaktır:






ÇOK BİÇİMLİLİK
Nesne tabanlı programlamada çok biçimlilik, nesnelerin dışarıdan aynı görünmelerine rağmen içerde farklı işlem yapmalarıdır.Bu nedenle sınıflar nesnelerin içindeki farklılıklardan etkilenmeden çalışır. Çok biçimlilik aslında bir arayüz(interface)kullanarak birden fazla metodun kullanılmasını sağlar. Çok biçimliliğin amacı genel bir sınıf belirtip aynı arayüzü kullanarak oluşabilecek karmaşıklığı azaltmaktır.

Nesne tabanlı programlamada sınıflar belli bir sıraya göre tasarlanır. Başta genel bir sınıf sonra da bu sınıftan oluşmuş ve yeni elemanlar
 katılarak farklı özelliklere sahip yeni sınıflar vardır. Yeni oluşturulan sınıflar temel sınıfın özelliklerini taşır. Ancak oluşturulan
sınıflar temel sınıfın özelliklerini taşırlarken temel sınıf türetilen sınıfın özelliklerini taşımaz. Bir örnekle açıklayacak olursak; OKULLAR sınıfının genel bir sınıf olduğunu düşünelim. Bu sınıfın bir elemanı olan MESLEK LİSELERİ vardır. Okullar sınıfının özelliklerini meslek liselerine geçirebiliriz. Ama tam tersi söz konusu değildir. Çünkü her meslek lisesi
bir okuldur ama her okul bir meslek lisesi değildir.

Çok biçimliliği şimdi bir örnekle açıklayalım:
Okul sınıfından Lise, Eml ve Fen sınıfları türetilerek Console’dan yapılan seçime göre okulun hangi tür olduğunu bulan programın kodları polymorphism mantığına göre yapılmıştır.

  using system;
 namespace  polymorphism
      {
class okul
{
class Lise:okul
{
public string okulum=”Benim okulum düz lise”;
}
class Eml:okul
{
public string okulum=”Benim okulum endüstri meslek”;
}
class Fen:okul
{
public string okulum=”Benim okulum fen lisesi”;
}
static void Main (string[] args)
{
String sec;
Console.writline(“1,Lise”);
Console.writline(“2.Eml”);
Console.writline(“seçiminiz.1-2-3: “); sec=console.ReadLine();
switch(sec)
{
Case “1”;
               Lise L=new Lise();
               Console:Writline(L.okulum);
               Console.Read():break;
Case “2”;
               Eml  ML=new Eml();
               Console:Writline(ML.okulum);
               Console.Read():break;
Case “3”;
               Fen F=new Fen();
               Console:Writline(F.okulum);
               Console.Read():break;
               default:
                        Console.Writline(“sınır dışı bir seçim”):break;

          }
      }
   }
}

Programda okul seçimi için switch() yapısı kullanılmıştır. Yapılan seçime göre (sec)   program uygun satıra yönlendirilerek işlem yapılmaktadır. Herhangi bir seçim işleminde o sınıfa ait bir üye değişken oluşturularak yazma işlemi bu üye değişene (L.okulum,ML.okulum, F.okulum) göre gerçekleştirilmiştir. Buna göre programın ekran görüntüsüresim 3.1’deki gibi olur.




(alıntıdır)










Hiç yorum yok:

Yorum Gönderme

Yorum yaptığınız için teşekkürler..