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)
.jpg)
.jpg)
Hiç yorum yok:
Yorum Gönder
Yorum yaptığınız için teşekkürler..