PHP ile OOP

KODCU.com Makalelerin sahibi: Altuğ Bilgin Altıntaş

PDF’i düzenleyen: Zafer Latif

PHP’de Sınıf/Class yapısı ve NYP-1

Java, C++ vb bir dille kod geliştirmiş okuyucu “PHP’de sınıf/class yapısı ve NYP-1” başlığını

gördüğünde, bu yazının aslında PHP ile OOP (Object Oriented Programming) yani nesne yönelimli

programlama (yazının devamında buna kısaca NYP diyeceğiz) konusunu ele aldığını anlayacak ve belki

PHP’nin bu yönü ile ilk kez tanışacak ve şaşıracaktır

Evet, PHP ile de yukarıda andığım diller ve benzerleri gibi NYP gerçekleştirilebilir ve bu gerçekleştirme

en az söz konusu dillerdeki kadar esnek ve neredeyse onlarda olduğu kadar sonuca götürür(özellikle

PHP 5’den sonra) mahiyette olabilir/oluyor.

NYP kavramı ile ilk kez karşılaşıyorsanız “buda ne?” demeniz olası. NYP kısaca adından da anlaşılacağı

üzere, geliştirilen kodu nesneler üzerine bina etme anlayışı/yaklaşımıdırve oldukça faydalıdır.

NYP için anlayış/yaklaşım tabirini kullandım, buradan “NYP bir nevi yiğidin yoğurt yeme biçimi mi?”

sorusu akla gelebilir ve bu soruya rahatlıkla “Evet” cevabını verebiliriz . NYP ile geliştirilmiş bir kodun

yerine getirdiği işlevi, NYP gözardı edilerek, yapısal bir dil ile(yani farklı bir anlayış/yaklaşım ile) de

gerçekleştirmek pekala mümkündür.

Burada sözü fazla uzatmadan sizleri, yapısal programlama ve nesne yönelimli programlamaya dair

giriş seviyesinde bilgi ve kavramları bulabileceğiniz iki wiki adresine yönlendirip, örneklerle PHP’de

sınıf/class yapısı ve NYP konusuna giriş yapmak istiyorum.

Yapısal Programlama ( Ek-1 )

Nesne Yönelimli Programlama ( Ek- 2 )

Nesnelerle çalışmak

Konuyu, kod örnekleri ile işlemeye başlamadan önce bir geliştirme senaryosuna ihtiyacımız olduğunu

belirtmeliyim. Bu senaryo ihtiyacını, daha önceki yazılarımızda da kullandığımız kodcu.com makaleleri

örneğinden karşılayabiliriz, tabi bunu biraz geliştirerek.

Senaryomuz kabaca şöyle: Kodcu.com’da yer alan makaleleri , kategori-baslik –yazar- yayın tarihi

bilgisi ile depolayıp, çağırdığımızda çıktılayacak bir kod geliştirmek.

1. class makaleler { 2. 3. var $kategori; 4. var $baslik; 5. var $yazar; 6. var $yayin_tarihi; 7. 8. 9. function __construct ($kategori, $baslik, $yazar, $yayin_tarihi) { 10. 11. $this -> kategori = $kategori; 12. $this -> baslik = $baslik; 13. $this -> yazar = $yazar; 14. $this -> yayin_tarihi = $yayin_tarihi; 15. } 16. 17. }

Yukarıda gördüğünüz kod parçası, yazının girişinde bahsettiğim dillere aşina olanlar için son derece

tanıdık gelecektir, zira NYP mantığı küçük syntax/söz dizimi farkları müstesna aynıdır.

Kodumuzda, işe öncelikle bir sınıf/class deklerasyonu ile başladığımız görülüyor. Amacımıza uygun

olarak, kodcu.com’da yayınlacak makaleleri temsil edecek nesnemiz “class makaleler” ile başlayıp,

süslü parantezlerin içine aldığı kod bloğudur. Bir başka değiş ile kod içinde her bir makaleyi

nesneleştirecek araç bu sınıf/class’ımızdır.

Kodumuzda “var” anahtarı ile başlayan satırlarda tanımlananlar değişkenlerdir, “function” ile

başlayan satırda ise sınıfımızı işlevsel hale getirecek metodumuzu deklare ediyoruz.

Sınıflarda yer alan değişkenlere özellik/attribute, fonksiyonlara ise metod/method denir. İsmini

“makaleler” olarak belirlediğimiz sınıfımızın içinde yer alan metodun “__construct” adında olması

dikkatinizi çekmiştir. Bu adlandırmadan da anlayabileceğiniz gibi, söz konusu metod sınıf/nesnemizin

yapılandırıcısıdır. Yapılandırıcı kısaca, sınıf/nesne’nin örneği oluşturulduğunda ilk çağrılan ve

çalıştırılan, bu özelliği gereği istendiğinde nesne özelliklerini ilk kullanıma hazırlayan ve varsa

yapılması arzulanan diğer işlemleri gerçekleştirdiğimiz metottur.

PHP sınıfları, temelde değişken örüntülerinden oluşan veri türleridir ve yapılandırıcı metodlar ile,

sınıf/nesne içinde tanımlayabileceğimiz diğer metodları işlevsel kılan şey, tamda sınıfların bu mahiyeti

ile söz konusu metodların sınıf değişkenlerine erişim özelliğidir.

Tam bu noktada, metodumuzun parametre olarak, sınıf içinde deklare ettiğimiz değişken/özelliklerle

aynı isimde(siz arzu ederseniz farklı isimler kullanabilirsiniz, bu tamamen sizin tercihinize ve kod yazım

tekniğinize bağlıdır) değerler aldığını ve içinde, gelen bu değerleri sınıf değişkenleri/özelliklerine

atadığını/set ettiğini görüyoruz.

1. $this -> kategori = $kategori;

Burada gördüğünüz “this” anahtarı ile sınıf özelliğine erişiyor(‘$’ sembolünün kullanılmadığına dikkat

edin) ve yapılandırıcı fonksiyonun parametre olarak aldığı değeri, sınıf özelliğine set ediyoruz.

Kabaca “makale” nesnemizi tanıdığımıza göre, şimdi bu nesneyi nasıl kullanacağımıza, bir başka değiş

ile onu nasıl oluşturacağımıza, veri/değer atayıp okuyacağımıza, değiştireceğimize gelelim.

1. $yeni_yazi = new makaleler("PHP", "PHP'ye Giriş", "Hüseyin Akdoğan", "19.04.2011");

Tek satırlık kodu inceleyelim.

Öncelikle “yeni_yazi” isminde bir değişkene “new” anahtarı ile makale sınıfı/nesnesinin bir örneğinin

atandığını görüyoruz. Evet, PHP’de bir sınıf örneği yani bir nesne, new anahtarı ile yukarıda

gördüğünüz şekilde oluşturulur.

Sonrasında ise, makaleler nesnemizin yapılandırıcı metodunun aldığı parametre sayısınca değerin,

parantez içine alındığını görüyoruz. Buradan da anlayacağınız gibi, aslında yaptığımız şey, makaleler

nesnesinin yapılandırıcısını çağırmaktır. Bir başka değiş ile, “new” anahtarı ile yeni bir örneği

oluşturulan nesnenin yapılandırıcı metodu var ise, PHP yorumlayıcı/çözümleyicisi bu aşamada onu

çağıracak ve çalıştıracaktır. Bizim metodumuz parametre aldığı için kod yukarıdaki gibi oldu, eğer

parametre almayan bir yapılandırıcı söz konusu olsaydı kodumuz şu şekilde olacaktı.

1. class makaleler { 2. 3. function __construct() { 4. echo "Nesne oluşturuldu… "; 5. } 6. } 7. 8. $yeni_yazi = new makaleler;

Bu kodun çıktısı

Nesne oluşturuldu…

olacaktır.

Şimdi bir önceki kodumuza dönüp, incelememize devam edelim. Daha öncede söylediğim gibi, söz

konusu yapılandırıcı metod, aldığı değerleri sınıf özelliklerine set ediyordu. Bu durumda gerçekleşen

işlemin ne olduğunu, aşağıdaki kodun çıktısı bize söyleyecektir.

1. echo $yeni_yazi->kategori; 2. echo $yeni_yazi->baslik; 3. echo $yeni_yazi->yazar; 4. echo $yeni_yazi->yayin_tarihi;

PHP PHP’ye Giriş Hüseyin Akdoğan 19.04.2011

Şimdi tekrar olana zoom yapalım. Kodumuzda echo ile, yeni_yazi değişkeni üzerinden,

makale sınıfı/nesnesinin özelliklerini, daha doğru bir ifade ile, yeni/new bir örneğini oluşturup,

yapılandırıcı metodu ile değer ataması yaptığımız ve yeni_yazi değişkenine atadığımız

makale sınıfı/nesnesi türündeki(hatırlayalım, sınıflar değişken örüntülerinden oluşan veri

türleri idi) verileri çıktılıyoruz.

Bunu yaparken “->” anahtarını kullanıyoruz. Buradan da anlayabileceğiniz gibi “->”

anahtarı, sınıf değişken/özellikleri ve fonksiyon/metodlarına erişim için

kullanılmaktadır.

Aynı yöntemle, makale sınıfı/nesnesi özelliklerinin sakladığı değerleri değiştirmemiz de

mümkündür. Yani sınıf/nesne özelliklerine salt yapılandırıcı/constructor içinde değer

atamıyor, eğer değişken deklare edilirken “private,protected” olarak tanımlanmamış

ise(public, private ve protected erişim belirteçleri PHP 5 ile gelmiştir), kod içinde bu

özelliklere yeni değerler set edebiliyoruz.

1. class makaleler { 2. 3. var $kategori; 4. var $baslik; 5. private $yazar; //bu değişken/özelliğe sınıf dışından değer atayamayız. 6. public $yayin_tarihi; 7. 8. function yeniMetod($kategori, $baslik, $yazar, $yayin_tarihi){ 9. 10. $this -> kategori = $kategori; 11. $this -> baslik = $baslik; 12. $this -> yazar = $yazar; 13. $this -> yayin_tarihi = $yayin_tarihi; 14. 15. } 16. } 17. 18. $yeni_yazi = new makaleler; 19. $yeni_yazi -> yeniMetod("PHP", "PHP'de sınıf/class yapısı ve NYP-

1", "Hüseyin Akdoğan", "05.05.2011"); 20. 21. $yeni_yazi->yayin_tarihi = "06.05.2001"; 22. //Artık yayin_tarihi değişken/özelliğinin sakladığı değer 05.05.2011 değil 23. 24. echo $yeni_yazi->yazar = "Ahmet oğlu Mehmet"; 25. //Bu satır error verecektir çünkü makaleler sınıfı/nesnesinin 26. //yazar isimli değişken/özelliği private olarak deklare edilmiştir

Burada öncelikle sınıf/nesne içinde yer alan yapılandırıcı/constructor metodumuz yerine

“yeniMetod” adında yeni bir metod deklare ettiğimiz dikkatinizi çekmiştir. Bu metod ile

yapılandırıcı/constructor metodu ayıran temel fark, yapılandırıcı/constructor metodunun nesne

“new” anahtarı ile oluşturulduğu anda çağrılmasıdır. Yani “yeniMetod” metodu, makaleler

nesnesinin yeni bir örneği oluşturulduğu anda çağrılmayacaktır. Bu metodun nerede nasıl çağrıldığını

1. $yeni_yazi -> yeniMetod("PHP", "PHP’de sınıf/class yapısı ve NYP-1", "Hüseyin Akdoğan", "05.05.2011");

yukardaki satırda görüyoruz.

İlgili satırı incelediğimizde, kendisine makale sınıfının/nesnesinin bir yeni/new örneğiatanmış

yeni_yazi değişkeninin, makale sınıfı/nesnesinin “yeniMetod” metodunu “->” anahtarı ile çağırdığını

ve bu metoda aldığı parametre sayısınca, parametre geçirdiğini görüyoruz. Bu metod da, aldığı

değerleri sınıf özelliklerine set ediyor. Bu örnek size, nesneler içinde yer alan metodların, nesneleri

işlevselleştirme gücüne dair fikir verebilir. Dışarıdan erişime kapattığınız değişkenlerinize nesne

içinde değer atama, değiştirme ve okuma gibi işlemlerde, bu kullanımın yararları ortadadır.

Kodumuzu incelemeye devam edelim

1. $yeni_yazi->yayin_tarihi = "06.05.2001";

Bu satırda, yayin_tarihi değişken/özelliğinin sakladığı “05.05.2011” değerini, “06.05.2011” ile

değiştiriyoruz. Bir sonraki satırda ise aynı yöntemle yazar özelliğinin değerini değiştirmeye çalışıyoruz.

1. echo $yeni_yazi->yazar = "Ahmet oğlu Mehmet";

Ancak başarılı olamıyoruz, çünkü makaleler sınıfı/nesnesinin yazar isimli değişken/özelliği private

olarak deklare edilmiştir, dolayısıyla çalışma zamanında bu satır error verecektir.

Peki, gerek gördüğümüzde private erişim belirtecine sahip nesne özelliklerine nasıl erişir ve değer

ataması yapabiliriz? Bu sorunun cevabı, sınıf/nesnelerimizi işlevsel hale getirdiğini daha önce

belirttiğimiz metodlar ve kullanımlarındadır. İzin verirseniz, gerek bahsettiğim bu tür durumlara dair

kullanım örnekleri ve gerek, NYP söz konusu olduğunda bahsedilmemesi tuhaf

kaçacak kalıtım konusunu bir sonraki yazıya bırakalım.

PHP’de Sınıf/Class yapısı ve NYP-2

Bir önceki yazımızda son olarak, PHP sınıfları içinde public erişim belirtecine sahip olmayan nesne

özelliklerine gerek gördüğümüzde nasıl erişir, değer ataması yapabilir ve değer okuyabiliriz sorusunda

kalmıştık.

O yazıda da belirttiğim gibi bu sorunun cevabı, sınıf/nesnelerimizi işlevsel hale getirdiğini daha önce

belirttiğimiz metodlar ve kullanımlarındadır. Birazdan örneklendireceğimiz kullanım, bir NYP kavramı

olan “sarmalama/encapsulation” dır. Sarmalama, kısaca özellik/metodların erişim yapısının

belirlenmesidir. Örneğimizde yazar özelliğini, erişimin sadece sınıf içinden sağlanması adına private

erişim belirteci ile deklare ettik. Ancak aynı değişkene kodun akışı içinde gerekli olduğunda okumak

ve yeni değer atamak için erişmemiz gerekiyor. Bu sorunu, söz konusu değişkene erişimi sağlayacak

işlevsel metodlarla aşacağız.

Örnek kod üzerinden irdeleyelim.

1. class makaleler { 2. var $kategori; 3. var $baslik; 4. private $yazar; 5. public $yayin_tarihi; 6. function yeniMetod($kategori, $baslik, $yazar, $yayin_tarihi){ 7. $this -> kategori = $kategori; 8. $this -> baslik = $baslik; 9. $this -> yazar = $yazar; 10. $this -> yayin_tarihi = $yayin_tarihi; 11. } 12. /*yazar değişkenine 13. değer atamak için 14. kullanacağımız metod 15. */ 16. function setYazar($yazar){ 17. $this -> yazar = $yazar; 18. } 19. 20. } 21. $yeni_yazi = new makaleler; 22. $yeni_yazi -> yeniMetod("PHP", "PHP'de sınıf/class yapısı ve NYP-

2", "Hüseyin Akdoğan", "10.05.2011"); 23. 24. $yeni_yazi->setYazar = "Ahmet oğlu Mehmet"; 25. }

Kodda “setYazar” isimli metod dikkatinizi çekmiştir, işte private erişim belirtecine sahip nesne

özelliğine değer atamak için kullanacağımız metod bu metottur çünkü söz konusu özelliğe sınıf

dışından değer atayamıyor ve okuyamıyoruz.

Değer atamasını yaptığımız satıra baktığımızda, işleyişin daha önce örneklerini gördüğüklerimizden

hiçbir farkı bulunmadığını görürüz.

1. $yeni_yazi->setYazar("Ahmet oğlu Mehmet");

Bu aşamadan sonra, yeni_yazi değişkeninin bir örneğine sahip olduğu makale nesnesinin yazar

özelliği “Ahmet oğlu Mehmet” değerini taşıyacaktır. Bu değeri okumak içinde aynı yönteme

başvuracağız çünkü erişmeye çalışacağımız özellik private erişim belirtecine sahip olduğundan “echo

$yeni_yazi->yazar;” şeklinde bir kullanım söz konusu olamayacaktır.

1. function getYazar(){ 2. return $this -> yazar; 3. }

1. echo $yeni_yazi->getYazar();

Ahmet oğlu Mehmet

Bu örneklerden hareketle, metodların sınıflarımız üzerinde bize sağladığı kontrol gücü

hakkında bir fikir edinebildiğinizi umuyorum. Bu kontrol gücü bize aynı zamanda “işlevsellik”

noktasında da fikir vermektedir. Tekrar belirtmeliyim ki örneklendirdiğimiz şey, bir NYP

kavramı olan “sarmalama/encapsulation” dır. Yukarıda söylediğimiz gibi bu kavram, kısaca

özellik/metodların erişim yapısının belirlenmesini ifade etmektedir. Örneğimizde, yazar

özelliğini private erişim belirteci ile deklare ederek, bu özelliğe sınıf dışından erişimi

engelledik ve söz konusu özelliğin okunması ve değer ataması için 2 ayrı metod kullandık,

yani onu sarmaladık.

Kalıtım/Inheritance

Bir başka NYP kavramı olan kalıtım kısaca, bir sınıfın bir başka sınıftan türemesidir. Bu

türemiş sınıf, kendisinden türediği sınıftan özellik ve metodları miras almaktadır ki, kalıtım

konusunda en önemli kavram, bu miras kavramıdır.

Konuyu kavramak için yine bir örneğe müracat edelim.

1. class uni { 2. var $adi = "Kodcu.Com Yazılım Üniversitesi"; 3. var $mekan = "Sanal Alem"; 4. 5. } 6. 7. class fakulte extends uni { 8. 9. var $bolumadi; 10. 11. function __construct($bolumadi){ 12. $this -> bolumadi = $bolumadi; 13. } 14. } 15. 16. $bolum = new fakulte("Yazılım Mühendisliği"); 17. echo "Okulu: ".$bolum->adi." Fakültesi: ".$bolum->bolumadi. " Mekan: ".$bolum-

>mekan;

Kodu hızlıca incelediğimizde, “uni” ve “fakulte” adında 2 ayrı sınıfımız olup, fakulte sınıfının

“extends” anahtarı ile oluşturulduğunu göreceğiz.

1. class fakulte extends uni

Buradan da anlayabileceğiniz gibi, bir sınıf bir başka sınıftan türetildiğinde bu extendsanahtar

sözcüğü ile yukarıda görüldüğü gibi yapılmaktadır. Uni sınıfı/nesnesi içinde her hangi bir metod

olmamakla birlikte iki özelliğin deklare edilip, değer ataması yapıldığını görüyoruz. Fakulte

sınıfı/nesnesi içinde ise “bolumadi” adında tek bir özellik ile bir yapılandırıcı metodumuz

bulunduğunu ve bu metod içinde, metoda geçirilen değerin sınıf/nesne özelliğine atandığı/set

edildiğini görüyoruz.

Kodumuzda kalıtım ve miras konusu için aydınlatıcı satır

1. echo "Okulu: ".$bolum->adi." Fakültesi: ".$bolum->bolumadi. " Mekan: ".$bolum->mekan;

yukarıdaki satırdır. Bu satırda “$bolum->adi” ve “$bolum->mekan” şeklinde, aslında fakulte

sınıfı/nesnesi içinde tanımlamadığımız özelliklere erişmeye çalışıyoruz. Kodumuzu çalıştırdığımızda

bizi aşağıdaki çıktı karşılayacaktır.

Okulu: Kodcu.Com Yazılım Üniversitesi Fakültesi: Yazılım Mühendisliği Mekan: Sanal

Alem

“$bolum->adi” ve “$bolum->mekan” ile eriştiğimizi yukarıdaki çıktıda gördüğümüz özellikler, uni

sınıfı/nesnesinin “adi” ve “mekan” özellikleridir. İşte kalıtım ve miras tam da burada gördüğümüz

gibi, fakulte sınıfı/nesnesinin, kendisinden türediği uni sınıfı/nesnesi içinde yer alan bu iki özelliği

miras almasıdır.

Bir başka değiş ile, türetilen sınıflar, kendilerinden türedikleri sınıfların özellik ve metodlarını miras

alırlar.

Bir başka örnek.

1. class uni { 2. var $adi = "Kodcu.Com Yazılım Üniversitesi"; 3. var $mekan = "Sanal Alem"; 4. 5. } 6. 7. class fakulte extends uni { 8. 9. var $bolumadi="Yazılım Mühendisliği"; 10. 11. function info(){ 12. echo "Fakulte sınıfının içindeyiz..."; 13. } 14. } 15. 16. class ogrenci extends fakulte{ 17. 18. var $ogrenci_kimligi; 19. 20. function __construct($ogrenci_kimligi){ 21. $this -> ogrenci_kimligi = $ogrenci_kimligi; 22. } 23. 24. } 25. 26. $ogrenci = new ogrenci("Hüseyin Akdoğan"); 27. $ogrenci->info();

Bir önceki örneğimizi biraz değiştirerek oluşturduğumuz kodda, fakulte sınıfına “info” isimli bir metod

eklediğimizi ve aynı sınıftan “ogrenci” adında bir sınıf türettiğimizi görüyoruz.

1. $ogrenci->info();

Bu satırda ise, ogrenci sınıfının kendisinden türediği fakulte sınıfının “info” isimli metodunun

çağrıldığını görüyoruz. Kodumuzu çalıştırdığımda karşılaşacağımız çıktı

Fakulte sınıfının içindeyiz…

olacaktır.

Buradan da, yukarıda söylediğimiz gibi türetilen sınıfların, kendilerinden türedikleri sınıfların

özellikleri yanı sıra metodlarını da miras aldıklarını görüyoruz.

Bu ve bir önceki yazımızda kurgulamaya çalıştığımız nesne modellerinin, çok boyutlu ve özellikle

veritabanı ile etkileşimli bir kayıt sisteminde, kodlayıcıya sağladığı avantajlar tartışılmazdır. NYP

yaklaşımının, programlayıcıya sağladığı avantajları kısaca saymamız gerekirse bunları şu şekilde

özetleyebiliriz.

NYP yaklaşımı, tasarlanacak kod ile gerçek yaşam arasında akli bir bağ kurarak, tutarlı ve

sağlam modellemeler kurulmasını kolaylaştırmaktadır.

NYP yaklaşımı ile değişken ve metod/fonksiyonlar arası ilişkiler, tasarlanan nesnenin

depolama özelliğine yüklenmiş ve programcı bu ilişkiler yükünden kurtulmuştur.

NYP yaklaşımında kalıtım sayesinde, geliştirilen kod farklı amaçlar için genişletilebilmekte,

ek özellikler alabilmekte ve bu kodun ana iskeletini bozmadan/değiştirmeden

gerçekleştirilebilmektedir.

NYP yaklaşımında yazılan kodun okunabilirlik ve anlaşılabilirlik oranı yükselmekte, buda

özellikle ekip çalışması ile geliştirilen kod geliştirme süreçlerine ciddi katkı sağlamaktadır.

PHP ile NYP konusunu işlemeye devam edeceğiz.

Not: PHP’de fonksiyonların yapı ve kullanımı, son iki yazımızda gördüğünüz metod ve

kullanımları(yapılandırıcı/construct metodların çalışma prensibi hariç) ile aynıdır. Dikkatinizi çekmiştir

ki, sınıflar içinde yer alan metodlar “function“ anahtarı ile deklare edilmektedir. Bir başka değiş ile,

fonskiyonlar sınıflar içinde yer aldığında “metod” olarak adlandırılmaktadır.

PHP’de Sınıf/Class yapısı ve NYP-3

PHP ile NYP konusuna devam ediyoruz. Bu yazımızda amacımız, NYP çerçevesinde geçmiş iki yazıda

değinsek de, yazıların hacmini artırmamak adına detaylarını ihmal ettiğimiz konuları tamamlamak ve

böylece bir sonraki yazıda, şu ana kadar ele almadığımız NYP konu/kavramlarına geçmek.

Bu bağlamda daha önce değindiğimiz erişim belirteçleri (yine daha önce değindiğimiz sarmalama

/encapsulation ile ilişkisi sebebi ile) ve metodlar hakkında, yazı hacmi sebebi ile söz etme fırsatı

doğmayan hususlara değinmek istiyorum.

Erişim belirteçleri

Konuya girerken, sınıf/nesne özellikleri için söylediğimiz şeylerin, sınıf/nesne metodları için de

geçerli olduğunun altını çizmek istiyorum. PHP’de sınıflarımız içinde, deklare edeceğimiz özellik ve

metodlar için kullanabileceğimiz erişim belirteçleri şunlardır.

Public

Protected

Private

Public(ve PHP 4’den miras aynı işlevi görecek var) erişim belirteçine sahip sınıf/nesne

özelliklerine, sınıf/nesnelerin dışından da erişim mümkündür, buna dair kod örnekleri önceki

yazılarımızda yer almıştı.

Protected erişim belirteçine sahip sınıf/nesne özelliklerine, sınıf/nesne dışından erişmek mümkün

değildir. Erişim ihtiyacı için sarmalama yöntemine başvurmamız gerekmektedir.Protected olarak

declare edilmiş sınıf/nesne özellikleri, kalıtım yolu ile alt sınıf/nesnelere aktarılabilir. Ağağıdaki

örneği inceleyelim.

1. class Personel { 2. 3. public $Firma = "Kodcu A.Ş"; 4. public $Adres = "İstanbul/Türkiye"; 5. protected $TicSicilNO = "123456"; 6. protected $NaceKod = "855903"; 7. 8. } 9. 10. class Isci extends Personel { 11. 12. public $Adi; 13. function __construct($Adi){ 14. $this -> Adi = $Adi; 15. } 16. 17. function getTicSicilNO(){ 18. return $this->TicSicilNO; 19. } 20. 21. function getNaceKod(){ 22. return $this->NaceKod; 23. } 24. } 25. 26. $isci = new Isci("Hüseyin Akdoğan"); 27. echo $isci->Firma."\n"; //Kodcu A.Ş çıktılanacaktır 28. echo $isci->Adres."\n"; //İstanbul/Türkiye çıktılanacaktır

29. echo $isci->TicSicilNO."\n"; //Fatal error: Cannot access protected property

30. echo $isci->NaceKod."\n"; //Fatal error: Cannot access protected property 31. echo $isci->getTicSicilNO()."\n"; //TicSicilNO bilgisi çıktılanacaktır 32. echo $isci->getNaceKod()."\n"; //NaceKod bilgisi çıktılanacaktır

Personel sınıfı/nesnesinde protected olarak deklare edilen TicSicilNO ve NaceKod özelliklerine,

kalıtım yolu ile Personel sınıfından türemiş, Isci sınıfının bir yeni/new örneğini barındıran isci

değişkenini kullanarak direk ulaşmak istediğimizde “Fatal error: Cannot access protected property”

hatası alıyoruz. Hata mesajı ulaşmak istediğimiz özellik/property’nin korumalı/protected olduğunu ve

erişim iznimiz bulunmadığını söylüyor. Ancak bu iki özelliğe, kendilerini sarmaladığımız iki getter

metodu ile ulaştığımızda, hem kalıtım yolu ile bu iki protected özelliğin alt sınıf/nesmemizce miras

alındığını görüyor, hem değerlerine ulaşabiliyoruz.

Private erişim belirtecine sahip sınıf/nesne özelliklerine, yalnızca sınıf/nesne içinden erişmek

mümkündür ve bu özellikler kalıtım yolu ile aktarılmazlar. Private erişim belirtecine sahip

sınıf/nesne özelliklerine erişim ihtiyacı için sarmalama yöntemine başvurmamız gerekmektedir.

Aşağıdaki örneği inceleyelim.

1. class Asker { 2. 3. private $Birligi="İstanbul"; 4. function getBirligi() { 5. return $this->Birligi; 6. } 7. } 8. 9. class Er extends Asker { 10. 11. public $Kunye; 12. function __construct($Kunye){ 13. $this -> Kunye = $Kunye; 14. } 15. } 16. 17. $asker = new Asker; 18. echo $asker->getBirligi(); //İstanbul bilgisi çıktılanacaktır 19. $er = new Er("Hüseyin Akdoğan, İstanbul, 1975/4, M"); 20. echo $er->Kunye."\n"; //Kunye bilgisi çıktılanacaktır 21. echo $er->Birligi."\n"; //Undefined property hatası alınacaktır

Static anahtarı

Static anahtarı ile deklare edilen sınıf/nesne özellik ve metotlarına, o sınıf/nesnenin bir yeni/new

örneğini oluşturmadan sınıf/nesne dışından erişmek mümkündür. Bu erişim, yine static bir

metod yada etki alanı çözünürlük işleci(:: anahtarı) ile sağlanır.

Örneğimizi inceleyelim.

1. class Dersler { 2. 3. static $Konu = "Fen Bilimleri"; 4. public $Not; 5. 6. function __construct($Not){ 7. $this -> Not = $Not; 8. } 9. } 10. 11. echo Dersler::$Konu."\n";

Kodumuzda static olarak deklare edilmiş “Konu” adındaki sınıf/nesne özelliğine, Dersler

sınıfı/nesnesinin bir yeni/new örneğini oluşturmadan, etki alanı çözünürlük işleci(::) ile ve “$”

sembolünü kullanarak eriştiğimizi görüyorsunuz. Static olarak deklare edilmiş sınıf/nesne

özelliklerine, sınıf/nesnenin bir yeni/new örneği oluşturulmadan erişebiliyor oluşumuz sebebi ile, bu

özelliklere “$this” ve “->” anahtarları ile ulaşamayız. Aynı sebeple“$this” anahtarını, static bir metod

içinde de kullanamayız.

1. class Dersler { 2. 3. static $Konu = "Fen bilimleri"; 4. public $Not; 5. 6. function __construct($Not){ 7. $this -> Not = $Not; 8. } 9. 10. public static function getKonu(){ 11. return self::$Konu; 12. } 13. } 14. 15. echo Dersler::getKonu()."\n"; 16. $ders = new Dersler("8"); 17. echo $ders->Konu; //Undefined property hatası alınacaktır

Kodumuzda yer alan getKonu metoduna dikkat ederseniz, onun da static olarak deklare edildiğini ve

bu sebeple Dersler sınıf/nesnesinin bir yeni/new örneği oluşturulmadan çağrılabildiğini görürsünüz.

Metod içinde “self” anahtarına da dikkat edin. Self anahtarı isimlendirmesinden de anlayabileceğiniz

gibi , sınıf/nesnenin statik özellik ve metodlarına erişim için kullanılmaktadır. Son olarak, static bir

özellik yada metodu aynı zamanda protected yada private olarak da deklare edebileceğinizi ve bu

static özellik ve metodların kalıtım yolu ile alt sınıf/nesnelerce miras alınacağını da belirtelim.

Metodların iptal edilmesi/Method overriding

Türemiş bir sınıf, türetildiği sınıfta yer alan bir metodu kendi içinde iptal edebilir. Örneğimizi

inceleyelim.

1. class Yayin { 2. 3. function okuyorum(){ 4. echo "Her hangi bir yayını okuyorum..."; 5. } 6. } 7. 8. class YazilimDergisi extends Yayin { 9. 10. function okuyorum(){ 11. echo "Yazılım Dergisi okuyorum..."; 12. } 13. } 14. 15. $dergi = new YazilimDergisi; 16. echo $dergi->okuyorum();

YazilimDergisi isimli sınıf/nesnemiz, kendisinden türetildiği Yayin sınıf/nesnesinde yer alan

“okuyorum” metodunu kendi içinde barındırarak, kalıtım yolu ile miras aldığı metodu override etmiş

yani geçersiz kılmıştır. Bunun anlamı, YazilimDergisi sınıf/nesnesi üzerinden okuyorum metodu

çağrıldığında, çalışacak metodun, kalıtım yoluyla miras alınan değil, YazılımDergisi sınıf/nesnesi içinde

deklare edilen metod olacağıdır. Kodu çalıştırdığımızda alacağımız çıktı

Yazılım Dergisi okuyorum…

olacaktır.

Final Sınıf/Metodlar

Final anahtarı, PHP 5 ile gelen yeniliklerden biridir. Final anahtar sözcüğü ile deklare edilmiş

bir sınıf genişletilemez, yani bir başka sınıf extends anahtarı ilekendisinden türetilemez. Yine

final olarak tanımlanmış bir metod, türemiş sınıflar içinde geçersiz(override) kılınamaz.

Örneklerimizi inceleyelim.

1. final class Kalici { 2. 3. function __toString(){ 4. return "Bu sınıf final olarak deklare edildiğinden, genişletilemez..."; 5. } 6. } 7. 8. class Doviz { 9. 10. final function dovizCinsi() { 11. return "Bilinmiyor..."; 12. } 13. } 14. 15. class Dolar extends Doviz { 16. 17. function dovizCinsi(){ 18. return "Döviz cinsi: Dolar..."; 19. } 20. } 21. 22. $dolar = new Dolar; 23. echo $dolar->dovizCinsi(); //Cannot override final method 24. //hatası alınır 25. 26. $kalici = new Kalici; 27. echo $kalici; //"Bu sınıf final olarak deklare 28. //edildiğinden, genişletilemez..." 29. //stringi çıktılanacaktır

Hızlıca kodumuzu incelediğimizde, Kalici sınıf/nesnesinin final olarak deklare edildiğini görüyoruz. Bu

sınıf/nesneyi bir başka sınıf/nesne kalıtım yolu ile genişletemez. Bu sınıfta “toString” metodu

dikkatinizi çekmiş olmalı. Bu metod, sınıf/nesnelerimiz hakkında çıktılamak istediğimiz tanıtıcı/info

bilgisi için kullanılabileceği gibi, geliştirme aşamasında test ve hata ayıklama/debugging işlemlerinde

de bize yardımcı olabilir.

Döviz sınıf/nesnesine geldiğimizde, burada dovizCinsi isminde bir metodun final anahtarı ile deklare

edildiğini görüyoruz. Doviz sınıf/nesnesinden türeyen(bir başka değiş ile Doviz sınıf/nesnesini

genişleten) Dolar sınıf/nesnesi içinde de aynı isimde bir metodun yer aldığını görüyoruz. Dolar

nesnesi üzerinden bu metoda ulaşmaya çalıştığımızda “Cannot override final method “ hatası

alacağız.

Gördüğünüz gibi anlat anlat bitmiyor, NYP konusunda tekrar görüşeceğiz

PHP’de Soyut/Abstract sınıflar

NYP yaklaşımında belli başlı ve öncelenmesi gereken konu/kavramlar şunlardır.

Kalıtım/Inheritance

Soyutlama/Abstraction

Arayüzler/Interface

Çok biçimlilik/Polymorphism

Kalıtım konusunu daha önce işlemiştik, bu yazıda PHP’de soyutlama konu/kavramını kod örnekleri ile

ele almak istiyorum.

Soyutlama/Abstraction

Soyut sınıflar, içlerinde en az bir soyut metod barındıran ve sınıf/nesnenin yerine getirmesi istenen

temel işlevi metod düzeyinde belirlemek dışında ayrıntılara yer vermeyen yapılardır. Bu sınıf ve

metodlara soyut denmesinin sebebi, somut işlevleri içermemeleri, bu somut işlevleri kalıtım yolu ile

kendilerinden türeyen sınıflara bırakmalarıdır. Soyut bir sınıfın yeni/new bir örneği oluşturulamaz ve

soyut sınıfı genişleten sınıflar, soyut sınıftaki soyut metodları iptal/override etmek

zorundadırlar. İptal/override edilen metodların erişim belirtçeleri, soyut metodun deklare edildiği

erişim belirteçlerinden daha sınırlı olamaz. Bu, örneğin protected olarak deklare edilmiş soyut bir

metodu iptal/override edecek metodun private erişim belirteçine sahip olamayacağı anlamına

gelmektedir.

Basit bir örnekle soyut/abstract sınıf/neslelere giriş yapalım.

1. abstract class Personel { 2. 3. public $maas; 4. abstract public function pozisyon(); 5. 6. } 7. 8. class Isci extends Personel { 9. 10. function __construct($maas){ 11. $this -> maas = $maas; 12. } 13. 14. public function pozisyon(){ 15. return "Pozisyon: İşçi, maaş: ".$this->maas; 16. } 17. 18. } 19. 20. class Mudur extends Personel { 21. 22. function __construct($maas){ 23. $this -> maas = $maas; 24. } 25. 26. public function pozisyon(){ 27. return "Pozisyon: Personel Müdürü, maaş: ".$this->maas; 28. } 29. 30. } 31. 32. //$personel = new Personel; Cannot instantiate abstract class Personel

33. $calisan = new Isci("750 TL"); 34. $mudur = new Mudur("1250 TL"); 35. 36. echo $calisan->pozisyon()."\n"; 37. echo $mudur->pozisyon()."\n";

Kodumuzu incelediğimizde, Personel isminde soyut/abstract bir sınıf/nesnemiz olduğunu, bu

sınıf/nesneyi Isci ve Mudur adında iki sınıf/nesnenin genişlettiğini görüyoruz. Personel sınıfı soyuttur

çünkü pozisyon adında gövdesiz soyut bir metoda sahiptir, bu yüzden sınıf/nesne soyut/abstract

olarak deklare edilmiştir.

1. abstract class Personel

1. abstract public function pozisyon();

Gövdesiz ifadesine ve yukarıda gördüğünüz pozisyon metodunun nasıl deklare edildiğine lütfen dikkat

edin. Soyut metodlar gövde içermezler, bu yüzden soyutturlar ve ait oldukları sınıfı genişleten sınıfça

iptal/override edilmek zorundadırlar. Burada soyut sınıfların, gövdeli metodlar da içerebileceğini ve

bu metodların, türeyen/genişleten sınıf/nesne tarafından iptal edilmek zorunda olmadıklarını da

belirtelim.

Kodumuzu incelemeye devam edersek, soyut sınıf/nesnemizin soyut pozisyon metodunu, Personel

sınıf/nesnesini genişleten Iscı ve Mudur sınıf/nesnelerinin iptal ettiğini, aynı şekilde bu iki

sınıf/nesnenin, Personel sınıf/nesnesinin “maas” ismindeki özelliğini de kalıtım yoluyla miras alıp, bu

özelliğie sınıf/nesne yapılandırıcısında değer set ettiklerini ve ardından çağrılan pozisyon metodu ile,

çalışanın pozisyonu ve maaş bilgisinin ekrana bastırıldığını görüyoruz.

Bir soyut sınıf/nesneyi kısaca incelediğimzie göre, zihninizde oluşması muhtemel “peki ama

neden/nerede, soyut sınıf ve metodlar kullanayım/kullanmalıyım?” sorusunun cevabına gelelim. Ben

soyutlama/abstraction ile, daha önce NYP yaklaşımının faydaları konusunda belirttiğim noktalardan

birisi olan, tasarlanacak kod ile gerçek yaşam arasında akli bir bağ kurarak, tutarlı ve sağlam

modellemeler inşaası arasında sıkı bir bağ görüyorum. Bu bağ, soyut sınıfların oynadığı “birleştirici”

rolden kaynaklanmaktadır. Konuyu, kod örnekleri üzerinden incelediğimizde ne demek istediğim

daha iyi anlaşılacaktır.

Çeşit çeşit ürünün perakende satış fiyatlarını, fiyata o ürüne uygulanan kdv oranını yansıtarak

döndüren bir sınıf/nesneye ihtiyacımız olduğunu düşünelim. Bu durumda klasik yöntemlerle

geliştirilecek kod kabaca, her bir ürün için, kdv oranını ve fiyatı döndüren, o ürün(yani nesneye) has

metodlar ihtiva edecektir. Oysa bu ihtiyacı, daha önce de belirttiğimiz soyut sınıfların oynadığı

“birleştirici” rolden yararlanarak daha tutarlı/kararlı bir kodlama ile karşılayabilir, böylece kodumuzda

ilerde olası değişiklikler için daha esnek ve genişletilebilir/geliştirilebilir bir yapı kurgulayabiliriz.

Aşağıdaki kod, böylesi bir ihtiyaca cevap vermektedir.

1. abstract class Perakende { 2. 3. abstract public function KDV($urunKodu); 4. public function FiyatHesapla($fiyat, $urunKodu) { 5. return $fiyat + ($fiyat * $this->KDV($urunKodu)); 6. } 7. } 8. 9. class KuruUzum extends Perakende { 10. public $oran; 11.

12. public function KDV($urunKodu){ 13. 14. switch($urunKodu){ 15. case 1: 16. $this->oran = 0.08; 17. break; 18. case 2: 19. $this-

>oran = 0.18; //Şeker, Soya vb. maddelerle kaplananlarda oran %18 20. break; 21. default: 22. $this->oran=0; //Tanımsız urun 23. } 24. return $this->oran; 25. } 26. 27. } 28. 29. class KuruIncir extends Perakende { 30. public $oran; 31. 32. public function KDV($urunKodu){ 33. 34. switch($urunKodu){ 35. case 1: 36. $this->oran = 0.08; 37. break; 38. case 2: 39. $this-

>oran = 0.18; //Şeker, Soya vb. maddelerle kaplananlarda oran %18 40. break; 41. default: 42. $this->oran=0; //Tanımsız urun 43. } 44. return $this->oran; 45. } 46. 47. } 48. 49. $uzum = new KuruUzum; 50. $incir = new KuruIncir; 51. 52. echo "Kuru Üzüm, Ürün Kodu: 1 Fiyat: ".$uzum->FiyatHesapla(200,1)." TL\n"; 53. echo "Kuru Üzüm, Ürün Kodu: 2 Fiyat: ".$uzum->FiyatHesapla(200,2)." TL\n"; 54. 55. echo "Kuru İncir, Ürün Kodu: 1 Fiyat: ".$incir->FiyatHesapla(200,1)." TL\n"; 56. echo "Kuru İncir, Ürün Kodu: 2 Fiyat: ".$incir->FiyatHesapla(200,2)." TL\n";

Kodumuzu soyut Perakende sınıf/nesnemizden başlayarak inceleyeme başladığımızda, sınıf/nesnenin

soyut KDV metodu yanı sıra, bu soyut metodu çağıran gövdeli FiyatHesapla metodunu içerdiğini

görüyoruz. Perakende sınıf/nesnesini genişleten KuruUzum ve KuruIncir adında iki sınıf/nesnenin,

soyut KDV metodunu iptal/override ettiğini ancak gövdeli FiyatHesapla metodunu iptal/override

etmediğini görüyoruz. Bu, daha önce ifade ettiğimiz gibi zorunlu değildir. Bu noktaya dikkat çekme

sebebim, bahsettiğimiz “birleştirici” rolün tam da bu noktada toplanmasındandır. KuruUzum ve

KuruIncir sınıf/nesneleri, kalıtım yolu ile FiyatHesapla metodunu miras almışlardır, dolayısıyla bu iki

sınıf/nesnenin yeni/new bir örneğini kendisinde depolanmış değişken üzerinden, FiyatHesapla

metodunu çağırmak mümkündür ve bu yüzden tek bir metodla, Perakende sınıf/nesnesini

genişleten sınıf/nesnelerin fiyatlarına kdv oranlarını yansıtabiliyoruz.

1. $uzum->FiyatHesapla(200,1);

Yukarıda gördüğünüz kullanımda gerçekleşen işlemleri adım adım irdeleyelim.

KuruUzum sınıf/nesnesinin bir örneğini taşıyan uzum değişkeni üzerinden “ ->” anahtarı ile,

kendisine “200” ve “1” değerleri parametre olarak geçirilmiş Perakende sınıf/nesnesinin

FiyatHesapla metodu çağrılıyor.

FiyatHesapla metodu içinde soyut KDV metodu, FiyatHesapla metoduna geçirilen

parametrelerden ikincisi olan urunKodu parametresiyle $this->KDV($urunKodu) şeklinde

çağrılıyor. Daha doğru bir ifade ile aslında tam bu noktada, PHP yorumlayıcı/çözümleyicisi

KuruUzum sınıf/nesnesinin KDV metodunu çağırıyor.

Daha sonra KuruUzum sınıf/nesnesinin KDV metodundan dönen değer, FiyatHesapla

metoduna geçirilen parametrelerden birincisi olan fiyat parametresi ile çarpılıyor, böylece

ürün fiyatına eklenecek KDV tutarı hesaplanmış oluyor.

Ardından aynı satırda, hesaplanan KDV tutarı, çıplak fiyatı temsil eden fiyat değerine

eklenerek geri döndürülüyor.

Burada gerçekleşen işlemlerde can alıcı(bir başka değiş ile geliştirici için kurtarıcı )

noktanın, FiyatHesapla metodunu çağıran nesneye bağlı olarak çağrılacak KDV metodunu

PHP yorumlayıcı/çözümleyicisinin belirlemesi olduğunun tekrar altını çizelim.

1. $incir->FiyatHesapla(200,1);

Satırı çalıştırıldığında yukarıda anlatmaya çalıştığım adımlar tekrar edilecek, değişen tek şey,

FiyatHesapla metodunu çağıran nesne değiştiği için çağrılacak KDV metodu olacaktır.

Burada biz, KuruUzum KuruIncir ve eklenebilecek diğer ürünlerin fiyat hesaplamasını, nesnenin diğer

işlemlerinden soyutladık, bu soyutlama sayesinde soyut Perakende sınıfını genişleten nesnelerin

tamamının fiyat hesaplamasını, FiyatHesapla metodunda, yani tek bir metod içinde yaptık.

Bunun kod geliştirme sürecinde bizlere sağladığı yarar açıktır. Projeye eklenecek yeni nesnelerin fiyat

hesaplaması için ekstra hiçbir şey yapmamıza gerek kalmayacaktır. Ayrıca, fiyatlara yansıtılacak bir

değişim söz konusu olduğunda(örneğin bütün ürünlerde %20 indirip kampanyası gibi), müdahale

edeceğimiz yer sadece FiyatHesapla metodu olacaktır.

PHP’de Nesne Arayüzleri/Object Interfaces NYP yaklaşımında, öncelikle ele alınması gereken konu/kavramları işlemeye devam ediyoruz.

Hatırlayacağınız gibi bir önceki yazıda soyut/abstract sınıf ve metodları incelemiştik, bu gün ise

kullanım ve iş mantığı soyut sınıflara çok benzeyen nesne arayüzlerini(objectinterfaces) ele alacağız.

Arayüz/Interface

Nesne arayüzleri soyut sınıf/nesnelere çok benzerler, nesne arayüzlerinin soyut sınıf/nesnelerden

ayrıldıkları temel nokta, gövdeli yordamlar barındırmamaları ve içerdikleri metod ve özelliklerin

public erişim belirteçine sahip olma zorunluluğudur.

Nesne arayüzlerinin sadece gövdesiz metodlar içermeleri, soyut sınıf/nesneleri ele aldığımız yazıda

belirttiğimiz “birleştirici” olma özelliği hatırlanacak olursa, geliştirdiğimiz kodda böylesi bir yaklaşımı

zorlamak istediğimizde başvurabileceğimiz temel aracın nesne arayüzleri olduğunu bize

düşündürecektir. Temelde soyut sınıf/nesneler ile nesne arayüzlerinin amacı, gövdesiz metodlarını

kendilerini genişleten/uygulayan sınıflara iptal/override ettirmektir. Dolayısıyla,

sınıf/nesnelerimizin mutlaka ihtiva etmeleri gerektiğini düşündüğümüz metodlarımız varsa,

soyut sınıf/nesneler ile nesne arayüzlerine başvurarak, sınıf/nesnelerimizi buna zorlarız.

Nesne arayüzleri, interface anahtar sözcüğü ile deklare edilir/tanımlanır. Bu

arayüzlerimplements işleci ile sınıf/nesnelere uygulanır/gerçeklenir. Yine nesne arayüzleri diğer

nesne arayüzlerince genişletilebilir. Nesne arayüzlerindeki metodların tamamı, arayüzü

uygulayan/implement eden sınıf/nesne içinde iptal/override edilmelidir(nese arayüzlerini uygulayan

soyut/abstract sınıf/nesnelerin böyle bir zorunluluğu yoktur) ve yine bir sınıf/nesne, birden fazla

arayüzü uygulayabilir.

Nesne arayüzlerine dair bilinmesi gereken temel bilgileri kısaca verdiğimize göre, konuyu kod

örnekleri üzerinden incelemeye geçebiliriz.

1. interface Personel { 2. public function tabiOlduguYasa(); 3. } 4. 5. class Memur implements Personel { 6. public function tabiOlduguYasa(){ 7. return "657 sayılı Devlet Memurları Kanunu..."; 8. } 9. } 10. 11. class Isci implements Personel { 12. public function tabiOlduguYasa(){ 13. return "1475 sayılı İş Kanunu..."; 14. } 15. }

Kodumuzda görüldüğü üzere, Personel isminde, “interface” anahtarı ile deklare edilmiş ve

tabiOlduğuYasa isminde gövdesiz bir metoda sahip bir arayüzümüz var. Personel arayüzünü iki

sınıf/nesnenin, “impelements” anahtarı ile implement ettiğine yani uyguladığına ve arayüzün sahip

olduğu metodu iptal/override ettiğine dikkat edin. Bu iptal/override işlemi, Personel arayüzünü

uygulayan her sınıf/nesne için bir zorunluluktur.

Basit bir arayüz deklerasyon ve implementasyonunu gördüğümüze göre, tıpkı soyut sınıf/nesnelerde

olduğu gibi ilk başta aklınıza gelebilecek muhtemel “peki ama neden/nerede, nesne arayüzlerini

kullanayım/kullanmalıyım?” sorusunun cevabına gelelim.

Bu sorunun cevabı, soyut sınıf/nesneler için verilen cevapta olduğu gibi “birleştirici rol”ün anlam ve

mahiyetinde gizlidir. Arayüzlerin oynadığı birleştirici rolü, aşağıda yer alan birazdan inceleyeceğimiz

kodda görmeniz mümkündür. Önce UML diyagramına bakalım.

Kodumuz;

1. interface Bitki { 2. public function familya(); 3. public function govde(); 4. } 5. 6. interface Agac extends Bitki{ 7. public function yaprak(); 8. } 9. 10. interface Patates extends Bitki{ 11. public function renk(); 12. } 13. 14. class Kavak implements Agac{ 15. 16. public function familya(){ 17. return "SALİCACEAE"; 18. } 19. public function govde(){ 20. return "ODUNSU"; 21. } 22. 23. public function yaprak(){ 24. return "YAPRAKLI"; 25. } 26. 27. public function getAdi(){ 28. return "Kavak Ağacı"; 29. } 30. } 31. 32. class Granula implements Patates { 33. 34. public function familya(){ 35. return "SOLANACEAE"; 36. } 37. 38. public function govde(){ 39. return "YUMRU"; 40. } 41. 42. public function renk(){ 43. return "SARI"; 44. } 45. 46. public function getAdi(){ 47. return "Granula Patates"; 48. } 49. } 50. 51. 52. class Goster { 53. 54. public function Info(Bitki $bitki){ 55. echo $bitki->getAdi().", Familyası: ".$bitki->familya()." Gövdesi: ".$bitki-

>govde()."\n"; 56. } 57. 58. } 59. 60. $goster = new Goster; 61. $kavak = new Kavak; 62. $granula = new Granula; 63. 64. $goster->Info($kavak); 65. $goster->Info($granula);

Kavak Ağacı, Familyası: SALİCACEAE Gövdesi: ODUNSU Granula Patates, Familyası: SOLANACEAE

Gövdesi: YUMRU

UML diyagramı ve kodumuza baktığımızda, familya ve govde adında iki metoda sahip Bitki

isimli arayüzün, Agac ve Patates arayüzlerince genişletildiğini, bu iki arayüzünden Agac’ın

yaprak, Patates’in ise renk isminde birer metoda sahip olduğunu görüyoruz.

Kavak isimli sınıf/nesne Agac arayüzünü implement ederken, Granula sınıf/nesnesi ise

Patates arayüzünü implement ediyor. Her iki sınıf, uyguladıkları arayüzlerin gövdesiz

metodlarını iptal/override ediyor. Burada dikkat edilmesi gereken, iptal/override edilen

metodlar arasında Bitki arayüzünde deklare edilen familya ve govde metodlarının da

olmasıdır. Bunun sebebi, Agac ve Patates arayüzlerinin kalıtım yolu ile Bitki

arayüzünden bu metodları miras almış olmalarıdır.

Kodumuzda, UML diyagramında yer almayan Goster ismindeki sınıfın info metodu, nesne

arayüzlerinin oynadıkları birleştirici rolü tam olarak gözlemleyebileceğimiz yerdir.

1. public function Info(Bitki $bitki){ 2. echo $bitki->getAdi().", Familyası: ".$bitki->familya()." Gövdesi: ".$bitki-

>govde()."\n"; 3. }

Metodun Bitki arayüzü tipinde bir parametre aldığına dikkat edin. İşte bu sayededir ki,

1. $goster->Info($kavak); 2. $goster->Info($granula);

şeklinde bir kullanım ile, tek bir metod içinde, Bitki arayüzünü implement eden sınıf/nesnelerin, bu

arayüzde gövdesiz olarak deklare edilip sınıf/nesne içinde iptal edilmiş metodlarını çağırabiliyor ve

nesne özelliklerini çıktılayabiliyoruz.

Altını çizerek belirtelim ki burada gördüğümüz şey, Kavak, Patates ve bu yapıya eklenebilecek diğer

bitkilerin familya, gövde ve isim bilgilerini tek bir metod içinde, nesnenin implement ettiği arayüz

tipindeki değişken referansı ile çıktılanmasıdır.

Böylesi bir kullanımın, ortak kategoriler ve fakat farklı içerikler ihtiva eden yapılarda kod geliştirme

sürecinde bizlere sağladığı yarar açıktır. Projeye eklenecek yeni bitkilerin farklı familya ve gövde

yapılarına sahip olması ve yine bunlar dışında(örneğimizdeki yaprak, renk unsurları gibi) özelliklerinin

bulunması bizim için bir sorun oluşturmayacaktır. Ortak kategorilerdeki farklı özellikleri, yine aynı

yöntemle tek bir metod ve referansla çıktılayabileceğiz.

PHP’de Çok Biçimlilik/Polymorphism Bu gün ele alacağımız Çok biçimlilik/Polymorphism konusu ile, PHP’de NYP yaklaşımı konusunu

nihayetlendiriyoruz. Çok biçimlilik(yazının devamında polimorfizm diyeceğiz) kalıtım konusuyla

ilintilidir ve bir örneği, nesne arayüzlerini ele aldığımız yazıda geçmiştir.

O örnekte, Bitki tipinde parametre alan Info metoduna, Bitki arayüzünü implement eden

sınıf/nesnelerin parametre olarak geçirildiğini, bu nesneler üzerinden de söz konusu arayüzde

gövdesiz olarak deklare edilip sınıf/nesneler içinde iptal edilmiş metodlarını çağrılabildiğini

görmüştük.

Bunu sağlayan şey, soyut sınıf/nesneler konusunu işlerken de değindiğimiz “birleştirici olma

fonksiyonu” idi. Bu birleştiriciliği kalıtım ve onun doğurduğu akrabalık ilişkisine yakından bakarak

anlamaya çalışalım.

1. public function Info(Bitki $bitki){ 2. echo $bitki->getAdi().", Familyası: ".$bitki->familya()." Gövdesi: ".$bitki-

>govde()."\n"; 3. }

Kalıtım konusunu ele aldığımız yazıdan hatırlayacağınız üzere kalıtım, bir sınıfın bir başka sınıftan

türemesidir. Türemiş sınıf, kendisinden türediği sınıftan özellik ve metodları miras almaktadır ve

kalıtım konusunda en önemli kavram, bu miras kavramıdır.

Türemiş sınıf ile türetildiği sınıf arasında miras bağını oluşturan akrabalık vardır, buna “bir ilişkisi” de

diyoruz. Türeyen sınıf aynı zamanda bir türetilen sınıftır. Daha önce çokça örneği geçtiği için tekrara

düşmemek adına, bir ilişkisini basit bir örnek üzerinden tekrar gösterelim.

1. class Insan { 2. 3. private $dogum_tarihi; 4. } 5. 6. class Erkek extends Insan { 7. 8. private $boyu; 9. private $kilosu; 10. } 11. 12. class Kadın extends Insan { 13. 14. private $boyu; 15. private $kilosu; 16. }

Insan sınıf/nesnesinden Erkek ve Kadın isminde iki sınıf/nesnenin türediğini görüyoruz. Erkekbir

İnsan’dır, Kadın’da bir İnsan’dır.

Kalıtım yoluyla metod ve özelliklerin miras alındığını gözönüne alırsak, türetilen sınıfın kendisinden

türediği sınıfın yaptığı her işi yapabileceğini görürüz. Örneğimizden hareketle bu Erkek ve Kadın

sınıf/nesnesinin, İnsan sınıf/nesnesinin yaptığı her işi yapabileceği anlamına gelmektedir

ve polimorfizm tam da bu noktada karşımıza çıkmaktadır. Ne demiştik, bir ilişkisi sebebi ile Erken

aynı zamanda bir İnsan’dır, Kadın’da öyle. İşte polimorfizm ile kastetilen budur.

Bir örnek üzerinden konuya tekrar yakından bakalım.

1. class Milletvekili { 2. 3. public $donem; 4. public $secimbolgesi; 5. public $pozisyon; 6. 7. function __construct($donem, $secimbolgesi, $pozisyon) { 8. $this-> donem = $donem; 9. $this-> secimbolgesi = $secimbolgesi; 10. $this-> pozisyon = $pozisyon; 11. } 12. 13. function Oturum(){ 14. return "Meclis oturumuna katıldı..."; 15. } 16. } 17. 18. class Bakan extends Milletvekili { 19. 20. function __construct($donem, $secimbolgesi, $pozisyon) { 21. parent::__construct($donem, $secimbolgesi, $pozisyon); 22. } 23. 24. function Oturum(){ 25. return "Bakanlar kuruluna katıldı..."; 26. } 27. } 28. 29. class Basbakan extends Bakan { 30. 31. function __construct($donem, $secimbolgesi, $pozisyon) { 32. parent::__construct($donem, $secimbolgesi, $pozisyon); 33. } 34. 35. function Oturum(){ 36. return "Bakanlar kuruluna başkanlık yaptı..."; 37. } 38. } 39. 40. class MeclisTV { 41. 42. function haberler(Milletvekili $mv){ 43. echo "Seçim bölgesi ".$mv->secimbolgesi." olan ".$mv->donem." ".$mv-

>pozisyon 44. ." ".$mv->oturum()."\n"; 45. } 46. } 47. 48. $mv = new Milletvekili("24. Dönem", "İstanbul", "Milletvekili"); 49. $bakan = new Bakan("24. Dönem", "İstanbul", "Kültür ve Turizm Bakanı"); 50. $basbakan = new Basbakan("24. Dönem", "İstanbul", "Başbakan"); 51. 52. $tv = new MeclisTV; 53. $tv->haberler($mv); 54. $tv->haberler($bakan); 55. $tv->haberler($basbakan);

Kodu incelediğimizde, aralarında bir ilişkisi olan Milletvekili, Bakan ve Basbakan sınıf/nesnelerimizi

görüyoruz. Bakan sınıf/nesnesi Milletvekili sınıf/nesnesinden türetiliyor, bu Bakan nesnesinin aynı

zamanda bir Milletvekili olduğu anlamına geliyor ve Bakan sınıf/nesnesi, Milletvekili sınıf/nesnesine

ait özellik ve metodları miras alıyor.

Basbakan sınıf/nesnesi Bakan sınıf/nesnesinden türetiliyor, bu Basbakan nesnesinin aynı zamanda

bir Bakan, Bakan sınıf/nesnesi Milletvekili sınıf/nesnesinden türetildiği için de aynı zamanda bir

Milletvekili olduğu anlamına geliyor ve Basbakan sınıf/nesnesi, Milletvekili sınıf/nesnesine ait özellik

ve metodları miras alıyor.

Elimizdeki Bakan nesnesi aynı zamanda bir Milletvekili ve Başbakan nesnesi aynı zamanda bir Bakan

ve Milletvekili, işte polimorfizm

Kodumuzda bu çok biçimliliğin bize sağladığı işlevselliği, MeclisTV sınıf/nesnemizin haberler

metodunda görüyoruz.

1. function haberler(Milletvekili $mv){ 2. echo "Seçim bölgesi ".$mv->secimbolgesi." olan ".$mv->donem." ".$mv-

>pozisyon 3. ." ".$mv->oturum()."\n"; 4. }

Milletvekili tipinde parametre alan metodumuzu biz

1. $tv->haberler($mv); 2. $tv->haberler($bakan); 3. $tv->haberler($basbakan);

bu şekilde, yani Bakan ve Basbakan nesnelerini parametre olarak geçirerek çağırabiliyor ve aşağıdaki

çıktıyı alabiliyoruz.

Seçim bölgesi İstanbul olan 24. Dönem Milletvekili Meclis oturumuna katıldı… Seçim

bölgesi İstanbul olan 24. Dönem Kültür ve Turizm Bakanı Bakanlar kuruluna katıldı…

Seçim bölgesi İstanbul olan 24. Dönem Başbakan Bakanlar kuruluna başkanlık yaptı…

Neden?

Çünkü Bakan nesnesi aynı zamanda bir Milletvekili’dir, Basbakan nesnesi de aynı zamanda hem Bakan

hem Milletvekilidir. Yazının başlangıcında belirttiğim gibi, nesne arayüzlerini incelediğimiz yazıda

gördüğümüz Info metodu içinde olan da budur. Kalıtım ile oluşan bir ilişkisi, soyut sınıf/nesneler ile

nesne arayüzlerini incelediğimiz yazılarda değindiğimiz “birleştirici olma fonskiyonu”nun da

doğurduğu bir sonuçtur.

EK – 1 / Yapısal programlama

Yapısal programlama, programlama dilleri kullanılarak yazılan, mantıksal bütünlük gösteren bloklara

(bölümlere) bölünebilirler. Bu yolla uzun ve karmaşık programların, bloklara ayırarak daha kolay

biçimde yazılabilmesi mümkün olmaktadır.

Yapısal programlama yordamsal programlamanın bir alt/yan dalı olarak görülebilir, temel programlama

tekniklerinden birisidir. “goto” terimine karşı bağımlılığı azalttığı ve hatta kaldırdığı için ünlenmiştir.

Tarihsel olarak bakıldığında yapısal programlamadan pek çok alt yöntem türetilmiştir. Bunlardan ikisi

Jackson’ın Yapısal Programlaması ve Dijkstra’nın Yapısal Programlamasıdır.

Yapısal programlama, yordamsal programlama dillerinin pek çoğu ile yapılabilmektedir. 1970’lerin

başlarında popülerleşmeye başlayan yapısal programlama ile pek çok yeni yordamsal programlama dili

yapısal programlamayı destekleyecek özellikleri barındırmaya başladılar. Bu dillere örnek olarak Pascal ve

Ada verilebilir. Küçük kod parçacıkları seviyesinde yapısal programlama hiyerarşik program akışı yapılarını

tavsiye eder. Bu yapılar pek çok modern dilde kolayca elde edilebilen, “while”, “repeat”, “for” gibi yapılardır.

Yapısal programlama bu yapılar için tek giriş ve tek çıkış noktalarını tavsiye eder. Bu tavsiyeyi zorunlu kılan

dillere rastlanmaktadır.

Bu teknik ile programcılar büyük kod parçalarını daha kısa alt yordamlar halinde yazarlar. Bu sayede

parçacıklar anlaşılabilecek kadar küçük olurlar. Genel olarak programlarda çok az veya hiç genel (global)

değişkenler kullanılmaz, genel değişkenler yerine altyordamlar yerel değişkenler kullanırlar ve değişkenlerini

adres ve değer ile gönderir.

Dijkstra’nın yapısal programlaması

Dijkstra’nın yapısal programlaması programın alt bölümlere ayrılması ve programın tek giriş ve çıkış noktası

olması mantığına dayanır. Yukarıda anlatılan Yapısal Programlamanın temeli Dijkstra’nın tekniğine dayanır.

Jackson’ın Yapısal Programlamas

Jackson’ın Yapısal Programlaması (JYP) veri akışı yapısı ile program yapısı arasındaki ilişkiye dayanır.

JYP ilk olarak 1970’lerde Michael A. Jackson tarafından geliştirilmiş ve “Principles of Program Design”

isimli kitabında yayınlanmıştır. Jackson’ın amacı standart COBOL programlamayı iyileştirmek olsa da

bu metot modern programlama dilleri (örneğin C ve Perl gibi) ile kodlamada da geçerlidir.

JSP’yi oluşturan temel yapılar…

Temel eylemler

Sıralamalar

Tekrarlar

Seçimler

Metot programın girdilerinin temel yapılar ile ifade edilmesi ile başlar. Daha sonra programın çıktıları

aynı şekilde ifade edilirler. Her girdi ve çıktı ayrı bir Veri Yapısı Diyagramı olarak modellenirler.

Girdi ve çıktı yapıları daha sonra Program Yapı Diyagramı (PYD) olarak birleştirilirler. Bazı programlar

tüm veriyi almadan çıktı üretmezken bazıları her girdi birimi için çıktı üretir, bu durum PYD’de

işlenmiş olur.

Dil bağımlı olmayan PYD daha sonra bir programlama dili vasıtası ile uygulanır. PSD daha çok

yordamsal diller için uygun bir yaklaşım olup nesne yönelimli dillerde kullanılmamaktadır.

JSP programın girdi, çıktı ve program yapısını anlatmak için diyagramları kullanır.

EK – 2 / Nesne Yönelimli Programlama

Nesne yönelimli programlama (NYP), (İngilizce:Object Oriented Programming) özetle bir

bilgisayar programlama yaklaşımıdır. Günümüzde pekçok çağdaş programlama dili tarafından

desteklenmektedir.

1960'lı yılların sonuna doğru ortaya çıkan bu yaklaşım, o dönemin yazılım dünyasında beliren bir

bunalımın sonucudur. Yazılımların karmaşıklığı ve boyutları sürekli artıyor, ancak belli bir nitelik düzeyi

korumak için gereken bakımın maliyeti zaman ve çaba olarak daha da hızlı artıyordu. NYP'yi bu

soruna karşı bir çözüm haline getiren başlıca özelliği, yazılımda birimselliği (modularity)

benimsemesidir. NYP ayrıca, bilgi gizleme (information hiding), veri soyutlama (data abstraction), çok

biçimlilik (polymorphism) ve kalıtım (inheritance) gibi yazılımın bakımını ve aynı yazılım üzerinde

birden fazla kişinin çalışmasını kolaylaştıran kavramları da yazılım literatürüne kazandırmıştır.

Sağladığı bu avantajlardan dolayı, NYP günümüzde geniş çaplı yazılım projelerinde yaygın olarak

kullanılmaktadır.

NYP'nın altında yatan birimselliğin ana fikri, her bilgisayar programının (izlence), etkileşim içerisinde

olan birimler veya nesneler kümesinden oluştuğu varsayımıdır. Bu nesnelerin her biri, kendi içerisinde

veri işleyebilir, ve diğer nesneler ile çift yönlü veri alışverişinde bulunabilir. Hâlbuki NYP'den önce var

olan tek yaklaşımda (Yordamsal programlama), programlar sadece bir komut dizisi veya birer işlev

(fonksiyon) kümesi olarak görülmektediler.

Nesne yönelimli programlama dilleri yukarıda adı geçen tüm öğelere sahip olurken, Visual

Basic gibi nesne tabanlı programlama dilleri birkaçından yoksundur.

Tasarım Şablonları

Nesneye yönelik tasarım esnasında bazı sorunlara sıkça rastlanır. Bu sık rastlanan sorunlara karşı yaygın olarak

kabul edilmiş çözümler de mevcuttur. Bu çözümlere Tasarım Şablonları denir (İngilizce - Design patterns). Bu

alanda en çok tanınmış kaynak, Erich Gamma, Richard Helm, Ralph Johnson ve John Vlissides tarafından

yazılmış Design Patterns: Elements of Reusable Object-Oriented Software adlı, en sık kullanılan 23 tasarım

şablonu içeren kitaptır. Bu tasarım şablonları Oluşturucu Tasarım Şablonları, Yapısal Tasarım

Şablonları, Davranışsal Tasarım Şablonları olmak üzere üç kategoriye ayrılır.

Oluşturucu Tasarım Şablonları

Teklik(Singleton) Tasarım Şablonu | Fabrika(Factory) Tasarım Şablonu | Soyut Fabrika(Abstract Factory)

Tasarım Şablonu | İnşaatcı (Builder) Tasarım Şablonu | Prototip(Prototype) Tasarım Şablonu

Yapısal Tasarım Şablonları

Adaptör(Adapter) Tasarım Şablonu | Vekil(Proxy) Tasarım Şablonu | Köprü (Bridge) Tasarım Şablonu

Cephe(Façade) Tasarım Şablonu | Dekoratör (Decorator) Tasarım Şablonu | Kompozit (Composite) Tasarım

Şablonu | Sinek Siklet (Flyweight) Tasarım Şablonu

Davranışsal Tasarım Şablonları

Strateji (Strategy) Tasarım Şablonu | Durum (State) Tasarım Şablonu | Yineleyici (Iterator) Tasarım Şablonu

Memento Tasarım Şablonu | Observer Tasarım Şablonu | Sorumluluk Zinciri(Chain of Responsibility) Tasarım

Şablonu | Ziyaretçi(Visitor) Tasarım Şablonu | Şablon (Template) Tasarım Şablonu

Komut (Command) Tasarım Şablonu | Aracı (Mediator Tasarım Şablonu)