PHP ile OOP - Honest Travel Group

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
Nesne Yönelimli Programlama
( Ek-1 )
( 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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
class makaleler {
var
var
var
var
$kategori;
$baslik;
$yazar;
$yayin_tarihi;
function
__construct ($kategori, $baslik, $yazar, $yayin_tarihi) {
$this -> kategori = $kategori;
$this -> baslik = $baslik;
$this -> yazar = $yazar;
$this -> yayin_tarihi = $yayin_tarihi;
}
}
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.
2.
3.
4.
echo
echo
echo
echo
$yeni_yazi->kategori;
$yeni_yazi->baslik;
$yeni_yazi->yazar;
$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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
class makaleler {
var $kategori;
var $baslik;
private $yazar; //bu değişken/özelliğe sınıf dışından değer atayamayız.
public $yayin_tarihi;
function yeniMetod($kategori, $baslik, $yazar, $yayin_tarihi){
$this
$this
$this
$this
->
->
->
->
kategori = $kategori;
baslik = $baslik;
yazar = $yazar;
yayin_tarihi = $yayin_tarihi;
}
}
$yeni_yazi = new makaleler;
$yeni_yazi -> yeniMetod("PHP", "PHP'de sınıf/class yapısı ve NYP1", "Hüseyin Akdoğan", "05.05.2011");
$yeni_yazi->yayin_tarihi = "06.05.2001";
//Artık yayin_tarihi değişken/özelliğinin sakladığı değer 05.05.2011 değil
echo $yeni_yazi->yazar
= "Ahmet oğlu Mehmet";
//Bu satır error verecektir çünkü makaleler sınıfı/nesnesinin
//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 NYP1", "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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
class makaleler {
var $kategori;
var $baslik;
private $yazar;
public $yayin_tarihi;
function yeniMetod($kategori, $baslik, $yazar, $yayin_tarihi){
$this -> kategori = $kategori;
$this -> baslik = $baslik;
$this -> yazar = $yazar;
$this -> yayin_tarihi = $yayin_tarihi;
}
/*yazar değişkenine
değer atamak için
kullanacağımız metod
*/
function setYazar($yazar){
$this -> yazar = $yazar;
}
}
$yeni_yazi = new makaleler;
$yeni_yazi -> yeniMetod("PHP", "PHP'de sınıf/class yapısı ve NYP2", "Hüseyin Akdoğan", "10.05.2011");
23.
24. $yeni_yazi->setYazar
25. }
= "Ahmet oğlu Mehmet";
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
class uni {
var $adi = "Kodcu.Com Yazılım Üniversitesi";
var $mekan = "Sanal Alem";
}
class fakulte extends uni {
var $bolumadi;
function __construct($bolumadi){
$this -> bolumadi = $bolumadi;
}
}
$bolum = new fakulte("Yazılım Mühendisliği");
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
class uni {
var $adi = "Kodcu.Com Yazılım Üniversitesi";
var $mekan = "Sanal Alem";
}
class fakulte extends uni {
var $bolumadi="Yazılım Mühendisliği";
function info(){
echo "Fakulte sınıfının içindeyiz...";
}
}
class ogrenci extends fakulte{
var $ogrenci_kimligi;
function __construct($ogrenci_kimligi){
$this -> ogrenci_kimligi = $ogrenci_kimligi;
}
}
$ogrenci = new ogrenci("Hüseyin Akdoğan");
$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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
class Personel {
public $Firma
= "Kodcu A.Ş";
public $Adres
= "İstanbul/Türkiye";
protected $TicSicilNO = "123456";
protected $NaceKod
= "855903";
}
class Isci extends Personel {
public $Adi;
function __construct($Adi){
$this -> Adi = $Adi;
}
function getTicSicilNO(){
return $this->TicSicilNO;
}
function getNaceKod(){
return $this->NaceKod;
}
}
$isci = new Isci("Hüseyin Akdoğan");
echo $isci->Firma."\n";
//Kodcu A.Ş çıktılanacaktır
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
class Asker {
private $Birligi="İstanbul";
function getBirligi() {
return $this->Birligi;
}
}
class Er extends Asker {
public $Kunye;
function __construct($Kunye){
$this -> Kunye = $Kunye;
}
}
$asker = new Asker;
echo $asker->getBirligi(); //İstanbul bilgisi çıktılanacaktır
$er = new Er("Hüseyin Akdoğan, İstanbul, 1975/4, M");
echo $er->Kunye."\n";
//Kunye bilgisi çıktılanacaktır
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
class Dersler {
static $Konu = "Fen bilimleri";
public $Not;
function __construct($Not){
$this -> Not = $Not;
}
public static function getKonu(){
return self::$Konu;
}
}
echo Dersler::getKonu()."\n";
$ders = new Dersler("8");
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
class Yayin {
function okuyorum(){
echo "Her hangi bir yayını okuyorum...";
}
}
class YazilimDergisi extends Yayin {
function okuyorum(){
echo "Yazılım Dergisi okuyorum...";
}
}
$dergi = new YazilimDergisi;
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
final class Kalici {
function __toString(){
return "Bu sınıf final olarak deklare edildiğinden, genişletilemez...";
}
}
class Doviz {
final function dovizCinsi() {
return "Bilinmiyor...";
}
}
class Dolar extends Doviz {
function dovizCinsi(){
return "Döviz cinsi: Dolar...";
}
}
$dolar = new Dolar;
echo $dolar->dovizCinsi(); //Cannot override final method
//hatası alınır
$kalici = new Kalici;
echo $kalici; //"Bu sınıf final olarak deklare
//edildiğinden, genişletilemez..."
//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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
abstract class Personel {
public $maas;
abstract public function pozisyon();
}
class Isci extends Personel {
function __construct($maas){
$this -> maas = $maas;
}
public function pozisyon(){
return "Pozisyon: İşçi, maaş: ".$this->maas;
}
}
class Mudur extends Personel {
function __construct($maas){
$this -> maas = $maas;
}
public function pozisyon(){
return "Pozisyon: Personel Müdürü, maaş: ".$this->maas;
}
}
//$personel = new Personel; Cannot instantiate abstract class Personel
33.
34.
35.
36.
37.
$calisan
$mudur
= new Isci("750 TL");
= new Mudur("1250 TL");
echo $calisan->pozisyon()."\n";
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.
13.
14.
15.
16.
17.
18.
19.
public function KDV($urunKodu){
switch($urunKodu){
case 1:
$this->oran = 0.08;
break;
case 2:
$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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
interface Personel {
public function tabiOlduguYasa();
}
class Memur implements Personel {
public function tabiOlduguYasa(){
return "657 sayılı Devlet Memurları Kanunu...";
}
}
class Isci implements Personel {
public function tabiOlduguYasa(){
return "1475 sayılı İş Kanunu...";
}
}
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
interface Bitki {
public function familya();
public function govde();
}
interface Agac extends Bitki{
public function yaprak();
}
interface Patates extends Bitki{
public function renk();
}
class Kavak implements Agac{
public function familya(){
return "SALİCACEAE";
}
public function govde(){
return "ODUNSU";
}
public function yaprak(){
return "YAPRAKLI";
}
public function getAdi(){
return "Kavak Ağacı";
}
}
class Granula implements Patates {
public function familya(){
return "SOLANACEAE";
}
public function govde(){
return "YUMRU";
}
public function renk(){
return "SARI";
}
public function getAdi(){
return "Granula Patates";
}
}
class Goster {
public function Info(Bitki $bitki){
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
class Insan {
private $dogum_tarihi;
}
class Erkek extends Insan {
private $boyu;
private $kilosu;
}
class Kadın extends Insan {
private $boyu;
private $kilosu;
}
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.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
class Milletvekili {
public $donem;
public $secimbolgesi;
public $pozisyon;
function __construct($donem, $secimbolgesi, $pozisyon) {
$this-> donem = $donem;
$this-> secimbolgesi = $secimbolgesi;
$this-> pozisyon = $pozisyon;
}
function Oturum(){
return "Meclis oturumuna katıldı...";
}
}
class Bakan extends Milletvekili {
function __construct($donem, $secimbolgesi, $pozisyon) {
parent::__construct($donem, $secimbolgesi, $pozisyon);
}
function Oturum(){
return "Bakanlar kuruluna katıldı...";
}
}
class Basbakan extends Bakan {
function __construct($donem, $secimbolgesi, $pozisyon) {
parent::__construct($donem, $secimbolgesi, $pozisyon);
}
function Oturum(){
return "Bakanlar kuruluna başkanlık yaptı...";
}
}
class MeclisTV {
function haberler(Milletvekili $mv){
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)