Merhaba arkadaşlar çok uzun bir aradan (3 ay) sonra ancak fırsat bulabildim. Bloğa yazamamamın sebeplerinden bazıları işi bıraktım ve yeni firmam da işe başladım bu zaman zarfı sürecinde yeni işime alıştım üç ay kadar ceviz.net yöneticilerinden Sercan Virlan ile beraber çalışma imkanı buldum ve şuan da yeni iş yerimde mutlu ve huzurluyum.
Konuya gelecek olursak bu yazıda daha önceki bahsettiğim singleton pattern ile paralel olan bir başka pattern, adapter pattern hakkında bilgi vermeye çalışacağım. Adapter pattern nerelerde kullanılır gerekli midir değil midir buna karar verecek olanlar sizlersiniz ama gerçek anlamda bir MVC yapısı kullancaksak artık bu oop mimarisi ve design patternlere önem vermeliyiz.
Adapter patterni şöyle izah edebiliriz bir düşüneyim ımmm bir firmada çalışan bir a elemanı var bu a elemanı bir proje geliştirmiş ve işten bir süre sonra ayrılmış daha sonra ise işe siz başlamışsınız ve o projeye ek bişeyler yapmanız isteniyor ancak a elemanı kendine göre yazdığı için ufak bir kod değişikliği demek tüm projeyi baştan sona kontrol etmek anlamına geldiği için iş biraz sıkıcı ve yorucu olacaktır. Adapter pattern ile mevcut koda ( interface, abstract class ) extends ederek türetilen yeni bir interface veya abstract class yaparak mevcut projeyi bozmadan işimizi kolay halletme yoludur diyebiliriz. Örnek vermek istedim çünkü böyle daha kolay anlaşılır diye düşündüm.
Şimdi bizim a elemanı ne yapmış olsun bir tane interface tanımlasın ve bu interface sadece girilen ismi ekrana yazdırmak için kullanılan bir arayüz olsun aşağıdaki gibi
< ?php
interface isim
{
public function getName($name);
}
?>
Bu arayüze (interface) uygun sınıfınıda yazmış olsun.
< ?php
class name implements isim
{
public function getName($name)
{
echo $name;
}
}
?>
Evet a elemanı tasarladığı arayüz üzerine sınıfınıda yazmış oldu. Ama hiç bir zaman kendisinin işi bırakacağını ve kendisinden sonra gelen birisinin buna ekleme yapması ihtimalini düşünmeyerek kodunu tamamladı. Derken işi bıraktı biz başladık işe ve bizim bu arayüze eklemeler yapmamız gerekti. Ancak arayüzü değiştirirsek bu sefer ona bağlı tüm classlarıda yeniden düzenlemek zorunda kalacağız. Çünkü arayüzle birleştirilmiş class birleştiriliği arayüz ile birebir aynı olmak zorundadır.
Yani biz tutupda arayüzü şu hale getiremeyiz.
< ?php
interface isim
{
public function getName($name);
public function getData();
}
?>
Bu şekile çevrilirse arayüz buna bağlı olan tüm classlar hata verecek ve işin içinden çıkılmaz bir hal alacaktır. Peki o zaman ne yapacağız mevcut yapıyı bozmadan nasıl kendi istediğimiz özellikleri bu isim arayüzüne ekleyeciz ? Classlar nasıl ki extends ile nasıl türetiliyor ise arayüzlerde bu şekilde türetilmektedir.
Derken biz bu arayüze bir metot daha tanımlamamız gerekti bu da ne olsun getSurname() metodu olsun yani girilen bir soyadını ekrana yazsın. Ama bunu yaparkende mevcut classları bozmasın.
Bunun içinde arayüzden arayüz türeteceğiz
< ?php
interface yeni_isim extends isim
{
public function getSurname($surname);
}
?>
Hemen buna uygun sınıfımızı da yazalım
< ?php
class new_name implements yeni_isim
{
public function getName($name)
{
echo $name;
}
public function getSurname($surname)
{
echo $surname;
}
}
?>
Evet herşey bu kadar. Yeni sınıfımızı istediğimiz arayüze kolayca adapte etmiş olduk. Bir kaç açıklama daha yapmak gerekirse Name Classı sadece getName() metodunu çalıştırır getSurname() metoduna erişim yapamaz ancak New_Name Classı ise hem getName() hem de getSurname() metotlarına ulaşabilir çünkü yeni_isim arayüzünden türetildiği için getSurname() metodunu barındırmak zorunda kaldı yeni_isim de isim arayüzünden türetildiği için aynı zamanda getName() metodunu da barındırmak zorunda kaldı.
Örnek kullanımlarını da gösterelim daha anlaşılır olsun.
< ?php
$name = new name;
$name->getName('yusuf');
$name->getSurname('koç'); // Php Hata verecektir.
$new_name = new new_name;
$new_name->getName('yusuf');
$new_name->getSurname('koç');
?>
Görüldüğü üzere Adapter Pattern bu kadar.
Decorate design pattern ile bir sınıfa başka bir sınıfı gömerek o sınıfa yeni bir sınıfın özelliklerini katmaya decorate pattern denir.
Decorate design pattern için bir interface tanımlayalım. Bu interface sabit bir metot içereceği için basit şekilde vereceğiz tabi siz kendinize göre oluşturabilirsiniz.
< ?php
interface isimDecorate
{
public function __construct(isim $isim);
}
?>
yukarıdaki interface de bir yapılandırıcı metot tanımladık ve bu metota adı isim olan bir sınıfın geleceğini belirttik. Şimdi de interface için uygun bir sınıf yazalım.
< ?php
class isimDecorateClass implements isimDecorate
{
public $isim;
public function __construct(isim $isim)
{
$this->isim = $isim;
}
}
?>
yukarıdaki isim sınıfımızı mevcut arayüzümüze göre yazdık. Yapılandırıcı metoduna isim adında bir sınıfın geleceğini ve bu gelen sınıfı da isimDecorate sınıfımızın içindeki publictanımlı $isim e aktaracağız.
Şimdide isim sınıfımızı tanımlayalım.
< ?php
class isim
{
private $ad;
private $soyad;
public function adTanimla($ad)
{
$this->ad = $ad;
return $this;
}
public function soyadTanimla($soyad)
{
$this->soyad = $soyad;
return $this;
}
public function adVeSoyadGetir()
{
echo 'Adınız: '.$this->ad.' Soyadınız: '.$this->soyad;
}
}
?>
Mevcut sınıflarımızı artık hazırladığımıza göre şimdi ise nasıl kullanacağız ona görelim.
< ?php
$isim = new isim;
$isim->adTanimla('yusuf');
$isim->soyadTanimla('koç');
$isimDecorate = new isimDecorateClass($isim);
$isimDecorate->isim->adVeSoyadGetir();
?>
Evet görüldüğü üzere önce isim sınıfımızı new ile başlatıp ad ve soyad tanımladıktan sonra oluşturduğumuz bu sınıfı isimDecorate içine gömdük ve isimDecorate sınıfına isim sınıfının özelliklerini katmış olduk.
Factory design pattern bize belirtilen sınıfları new operatörüyle başlatıp döndürür. Normal bir sınıf başlatmaktan pek bir farkı olmasada burdaki amaç bir nesne arayüzü yaratarak sınıflara erişimi bu arayüz üzerinden gerçekleştirmektir.
Örnek olarak bir factory pattern sınıfı yazalım. Bu sınıf bize belirtilen nesne adına göre uygun bir dizinden ( class ) ilgili classı bulup başlatıp döndürdürsün.
< ?php
class factory
{
const class_dir = 'classes';
public static function load($class)
{
try
{
if (file_exists(self::class_dir.'/'.$class.'.class.php'))
{
include_once(self::class_dir.'/'.$class.'.class.php');
return new $class();
}
else
{
throw new Exception('Class Bulunamadı.');
}
}
catch (Exception $e)
{
echo $e;
}
}
}
?>
Yukarıda tanımladığımız factory class bize belirtilen classın class_dir dizininde olup olmadığına bakarak eğer varsa bize başlatarak dönecektir eğer yok ise catch bloğu çalışarak class bulunamadı hatasını verecektir. Ayrıca yukarıdaki sınıfa göre sınıflar class_dir dizininde ve dosya adları da abc.class.php şeklinde olduğu varsayılmıştır.
Şimdi gelelim iki tane sınıf yazalım. Birtanesi girilen ismi yazsın diğer ise sadece soyadını yazsın. Örnekleri basit tutuyorum ki anlaşılabilsin diye sonra demeyin isim ve soyisimden başka bişey bilmiyor musun be adam sen diye
< ?php
class name
{
public function getName($name)
{
echo $name;
}
}
?>
Şimdide soyisim sınıfımızı tanımlayalım
< ?php
class surname
{
public function getSurname($surname)
{
echo $surname;
}
}
?>
Bu classları class_dir dizinine name.class.php ve surname.class.php olarak kaydettiğinizi varsayıyorum ve factory sınıfımızın kullanımına geçiyorum
< ?php
include_once('class_dir/factory.class.php');
$isim = factory::load('name');
$isim->getName('yusuf ');
$surname = factory::load('surname');
$surname->getSurname('koç');
?>
Yukarıda öncelikle factory sınıfımızı sayfamıza dahil ediyoruz ve ardından artık bize hangi sınıf gerekiyorsa onu factory sınıfımıza bildiriyoruz. Eğer sınıf belirtilen dizin içinde mevcutsa bize sınıfı başlatıp döndürüyor değil ise hata veriyor.
Bunun bize faydası sınıfları daha tertipli ve düzenli bir şekilde başlatma olanağı sağlıyor ve tek bir arayüz üzerinden istediğimiz değişikliğe gitmemize olanak sağlıyor.
Şöyle bir örnek verirsek sanırım daha iyi anlaşılacaktır. Farzedelim ki sınıflarınızı sayfalarınıza hep require veya include ile çağırdınız ve bir süre sonra sınıfları bir dizinde topladınız veya dizin adını değiştirdiniz. Ne yapmak lazım şimdi? Tüm sayfaları açıp require veya include satırlarını düzeltmek lazım. Ama eğer bunu factory pattern olarak düşünüp yazsaydık sadece factory classımızda değişiklik yaptığımızda tüm sitemizde uygulanmış olacaktı.
Ben gibi bir çok kişi de geliştiriği uygulamalarda zaman zaman uygulamaların büyüklüğüne göre sınıflar yazıp kullanmışızdır. Nesne yönelimli bu yazılımda en azından benim canımı sıkan olay bazen sayfalarda tek tek yazmış olduğumuz sınıfları çağırmak zorunda kalırız. Bu durum da ister istemez uygulamanın performansına etki etmektedir zira nesne yönelimli uygulamalar yazmak hoş olsada dikkat edilmediği zaman aşırı kaynak tüketimine yol açabilmektedir.
Bu yüzden bazı yazılım desenleri ortaya çıkmıştır. Benim bu yazıda size tanıtacağım yazılım deseni ise Singleton desenidir. Singleton deseni aslında bir sınıfın sadece bir kopya olmasını amaç edinmektedir. Yani bize lazım olacak bir veritabanı sınıfı uygulamada bir kez kullanmamız gerekmektedir. Çünkü veritabanı ile başka bir işlem yapmayacağızdır. Bu yüzden de birden çok veritabanı sınıf kopyası yerine daha önceden başlatılmış veritabanı sınıfını alıp kullanmaktır. Böylelikle kaynak tüketimini de boş yere harcamamış oluruz.
Singleton desenine geçmeden önce bu desen ile ilgili birşeyi atlamamamız gerekmektedir. Bu desende illaki static tanımlı erişim metodu olmak zorundadır. Static olma zorunluluğunun nedeni ise ramde tutulması içindir. Zaten bizde aynı sınıfa farklı bir yerde ihtiyaç duyduğumuzda daha önceden tanımlanmış ise ramden alacağız yoksada yeni başlatacağız.
Şimdi öncelikle bir bilgi sınıfı yazalım. Sınıf sadece girilen değerlere göre isim ve mesleği ekrana yazdırmak olacaktır.
< ?php
class bilgi
{
private $isim;
private $meslek;
public function isimGir($isim)
{
$this->isim = $isim;
return $this;
}
public function meslekGir($meslek)
{
$this->meslek = $meslek;
return $this;
}
public function bilgiGetir()
{
echo 'İsim: '.$this->isim.' Mesleği: '.$this->meslek;
}
}
?>
Sınıfımızı yukarıdaki gibi tanımladık böylece artık kendisine verilen bir isim ve mesleği ekrana yazdıracaktır. Sınıfımız ile ilgili bir gelin bir örnek yapalım.
< ?php
include_once('bilgi.class.php');
$b = new bilgi;
$b->isimGir('Yusuf Koç')->meslekGir('PHP Developer')->bilgiGetir();
?>
evet ne yaptık bilgi sınıfını kullanabilmemiz için öncelikle sayfamıza dahil ettik ve $b = new bilgi; diyerek sınıfı başlattık. İlk etapda gayet normal gibi görünsede aynı sınıfı farklı sayfalarda da kullanmak istediğimizde yeniden çalışma sayfamıza dahil edip başlatmamız gerekecek ve kaynakta yeniden yer işgal etmiş olacağız.
İşte singleton desenide burda devreye giriyor. Sadece bir tane başlatıp devamında bu sınıf çağrılmak istendiğinde mevcut başlatılmış sınıfı bize döndürüyor.
Singleton deseni için sınıfımızı yazalım.
< ?php
class Singleton
{
private static $sinif = array();
private static $sinifDizin = 'class';
public static $sinifSay = 0;
private function __construct() { }
public static function sinifOrnegiAl($sinif)
{
if (!(self::$sinif[$sinif] instanceof $sinif))
{
include_once(self::$sinifDizin.'/'.$sinif.'.class.php');
self::$sinif[$sinif] = new $sinif;
self::$sinifSay++;
}
return self::$sinif[$sinif];
}
}
?>
Singleton sınıfımızı kısaca açıklamak istiyorum. Öncelikle sınıf içinde kullanmak üzere bazı değişkenler tanımladık. Ayrıca sınıfımızın yapılandırıcı fonksiyonunu da private olarak tanımlayarak $s = new Singleton; gibi kullanımların önüne geçmiş olduk.
sinifOrnegiAl() metodu ile kullanmak istediğimiz sınıf adını belirtiyoruz. Burda dikkat etmemiz gereken şey ben sınıf adını vererek class/sinifadi.class.php şeklinde bir dizinde tutup ordan include ettiriyorum siz kendinize göre düzenleyebilirsiniz devam edelim if bloğunda sınıf içinde static tanımlanmış sinif nesnesinin bize bildirilen sınıfın bir örneği olup olmadığına bakıyoruz eğer bir örneği değil ise istenilen sınıfı include edip başlatıyoruz ve return ile döndürüyoruz. Ayrıca burdaki $sinifSay her kullanımda bir artırarak kullanılan toplam sınıf sayısını elde ediyoruz.
Gelelim şimdi kullanımına. Öncelikle ana sınıfımızı kullanmak istediğimiz sayfalarımıza dahil ediyoruz ve Ardından aşağıdaki gibi başlatıyoruz.
include_once('class/singleton.class.php');
$bilgi = new Singleton; // Ölümcül Hata Alırsınız. Çünkü Direk Erişimi private function __construct() ile yasakladık.
$bilgi = Singleton::sinifOrnegiAl('bilgi'); // Doğru olan bu.
$bilgi->isimGir('Yusuf Koç')->meslekGir('PHP Developer')->bilgiGetir();
yukarıda iki satır yazdım ve açıklamalarınıda yanına yazdım. Evet böylelikle bilgi sınıfımız tanımlandı ve bir daha tekrar kullanılmak için singleton sınıfı ile çağrıldığında artık daha önce başlatıldıysa direk return etcek başlatılmadıysa başlatıp öyle return etcek.
Diyeceklerim bu kadar anlatım bozuklukları olabilir gördüğünüz yerleri bana Hakkımda kısmından mail atarak bildirirseniz gerekli düzenlemeleri yaparım.
Şimdilik Hoşçakalın…
Php ile classlara değinmeden önce OOP nedir diye bir açıklama gereği hissetmiyorum . Direk konuya dalmak istiyorum zira herkes bi yerde mutlaka OOP nedir diye okumuşlardır. Okumayanlar içinde buyrun link burada.
Sınıflara ilk __autoload fonksiyondan başlayalım. Bu metot sınıflarımızı uygulamamıza otomatik olarak yükleyecektir böylece şu classı yüklemişmiydim yüklememişmiydim derdinden kurtuluyoruz.
Metotu bir örnekle açıklayıp bitirelim. Öncelikle bir dizin ve içinde index.php ve bir de class adında dizin oluşturalım ve class dizini içerisine de a.class.php ve b.class.php diye iki adet php dosyası oluşturalım.
Burdaki önemli nokta class dosyalarımıza gelişi güzel bir isim değilde bir düzen içerisinde isim vermektir. Çünkü fonksiyon belli bir düzeneğe göre eklemee yapacaktır. örneğin a.class.php dosyasını yüklerken class.b.php dosyasını yüklemeyecektir az sonra yazacağımız fonksiyon da bu düzeni siz kendinize göre oluşturabilirsiniz.
Evet dosyalarımızı oluşturduğumuza göre autoload fonksiyonumuzu yazalım.
autoload.php:
< ?php
function __autoload($classname)
{
$include = "class/{$classname}.class.php";
if (file_exists($include))
{
include_once($include);
}
else
{
exit($classname.' sınıfı yüklenemedi.');
}
}
?>
Yukarıdaki autoload fonksiyonunu sayfamızın üstüne include ediyoruz. Daha sonra ise class dizinindeki herhangi bir sınıfı başlatmak istediğimiz de autoload devreye girerek sınıfı yüklüyor. Eğer hiç bir sınıf başlatmassanız sayfada hiç bir sınıfı dahil etmemiş olursunuz.
class/a.class.php:
< ?php
class a
{
public function __construct()
{
echo 'Merhaba ben a sınıfıyım';
}
}
?>
class/b.class.php:
< ?php
class b
{
public function __construct()
{
echo 'Merhaba ben b sınıfıyım';
}
}
?>
Yukarıda autoload fonksiyonu ile yüklenmesini istediğimiz sınıfları yazdık ve class dizinine sınıfadi.class.php şeklinde kaydettik.
Şimdide en son olarak index.php mizi yazalım ve örneğimizin çalışır halini görelim.
index.php:
< ?php
# Sayfa tipini ve karakter setini belirtelim.
header('Content-Type: text/html; charset=utf-8');
# Autoload fonksiyonumuzu dahil edelim.
include_once('autoload.php');
$a = new a;
echo '';
$b = new b;
?>
Görüldüğü üzere __autoload fonksiyonu biz tek tek belirtmemize gerek kalmadan tüm sınıfları sayfamıza dahil etti. Burdan şu anlaşılmasın içinde 100 tane dosya varsa hepsini dahil etmiyor sayfanızda hangi sınıfı başlatıyorsanız o sınıfı dahil ediyor sadece.
Bir önceki yazımızda sınıflarımızda kullanabileceğimiz public, protected, private, static, const ve final gibi özelliklerin geldiğine değinmiştik. Bu özellikler sınıf içerisindeki bir değişken veya metodun kullanıcı tarafından kullanılıp kullanılmayacağına karar vermek veya türetilen bir sınıfın bunu kullanıp kullanamacağını karar vermek için kullanıyoruz. Yani kısaca özetlemek gerekirse bir kısıtlama söz konusu yapabilmekteyiz. Bu özellik php4 ile yapılamamktaydı bu da yazılımcılara büyük bir sıkıntı idi.
Zira hangi metot veya değişkenlerin public veya private olduğunu belirtmek zorunda kalırdık. Php5 ile artık bu özelliklere hakimiz.
Public Özelliği
Öncelikle public özelliğine değinelim. Public özelliği atanan bir değişken veya metot kullanıcı tarafından erişilebilir olmaktadır. Aynı zamanda sınıf içerisinden veya türeyen bir sınıf içersinden de erişebilir.
Hemen bir örnekle daha da pekiştirelim.
< ?php
class a
{
public $isim = 'yusuf';
public function isimGetir()
{
echo $this->isim;
}
}
$a = new a;
echo $a->isim;
echo '';
$a->isimGetir();
?>
Yukarıdaki örnekte hem bir değişkene public özelliğini hem de bir metoda public özelliğini atadık. Public ve diğer özellikler değişken veya metotdan önce başına yazılır örnektede görüldüğü gibi.
$a ve isimGetir() e public özelliği atandığı için sınıf başlatarak a classındaki bu değerlere erişme hakkına sahip olduk.
Protected Özelliği
Protected özelliği atanan bir değişken veya metot ise sadece sınıf içerisinden veya türetilen bir sınıf içerisinden erişim hakkına izin verir. Yani kullanıcı başlattığı sınıf içindeki protected tanımlı değişken veya metotlara asla erişemez.
Örnekle devam edelim.
< ?php
class a
{
protected $isim = 'yusuf';
public function isimGetir()
{
echo $this->isim;
}
}
$a = new a;
echo $a->isim;
echo '';
$a->isimGetir();
?>
Yukarıdaki örneği çalıştırdığımızda ekrana “Cannot access protected property..” diye hata çıktısı verecektir. Bunun sebebi classı başlatıp ardından da protected özelliği atanmiş değişkeni çağırmak istememizden dolayıdır. Ancak echo $a->isim; satırını silersek ekrana bu sefer $isim içeriğini yazacaktır.
Neden hata vermiyor gibi bir düşünce gelebilir aklınıza ama ne demiştik protected veya private tanımlı bir değişken veya metot sadece sınıfın kendi içinden çağrılabilir dolayısıyla public tanımlanmış isimGetir() metodu sınıfın içinde olduğu için $isim değişkenine bu metot sayesinde erişmiş oluyoruz. Böylece classı kullanacakların classı olumsuz etkilemesinden korumuş oluyoruz.
Private Özelliği
Private özelliği de işleyiş olarak protected a benzese de aslında protected tek farkı türetilen bir classdan erişim hakkı yapamaz. Bu da demek oluyor ki private özelliği atanan değişken veya metot sadece o sınıf için özel olmuş oluyor. Hiç bir şekilde classı kullanmak isteyen ziyaretçi veya türeyen bir sınıf bu değişken veya metota erişim yapamaz.
Örnekle devam edelim
< ?php
class a
{
private $isim = 'yusuf';
public function isimGetir()
{
echo $this->isim;
}
}
$a = new a;
echo $a->isim;
echo '';
$a->isimGetir();
?>
Yukarıdaki örnekte bu sefer $isim değişkenine private özelliğini atadık. Sınıf başlatılıp ardından $isim değişkenini çağırdığımızda ekranda “Cannot access private property..” gibi bir hata ile karşılaşarız. Çünkü $isim değişkeni sadece o sınıf için özel bir değişken. Hiç bir şekilde dışarıdan ( kullanıcı tarafından ) veya türetilen sınıftan erişim sağlanamaz.
Böylelikle türetilen classların da buna etki edebilerek mevcut classın işleyişinin bozulması önlenmiş olur.
Static özelliği
Static özelliği atanmış bir değişken veya metot ramde saklanır. Böylece sürekli sürekli çağrılarak ramden çalmak yerine bir defaya mahsus rame atılarak performans kaybı önlenmiş olur. Static özelliğini herşeye atamakta doğru değildir. Zira projede kullanılacak sabit değişken veya metota atamak doğrudur. Çünkü bunlar hep aynı sonucu döndürecekleri için bir defaya rame aktarılması bize performans açısından büyük hız getirecektir.
Ayrıca static özelliği atanmış bir değişken veya metoda sınıf içerisinde $this yerine self:: ile erişim sağlanmaktadır.
Örnekle devam edelim.
< ?php
class a
{
private static $isim = 'yusuf';
public static function isimGetir()
{
echo self::$isim;
}
}
a::isimGetir();
?>
Bu örnekte de isimGetir metoduna hem public ( dışarıdan erişim yapma özelliği ) hem de static özelliği atanmıştır. Burda tek fark olarak normalde sınıfı başlatmamız gerekirdi ancak isimGetir metodu static olduğu için direk olarak erişim yapabiliriz. Buna değişkenlerde dahil.
Dışarıdan erişim yaparken sınıfadi::metot veya değişken şeklinde erişim yapabiliriz. a::isimGetir() diyerek a classının isimGetir() metoduna direk erişim yaptık ve static metodumuzu çağırdık böylece artık rame atıldı veya bundan sonraki her çağrılmasında artık bize ramden dönerek performans artışı sağlamış olacaktır.
Const Özelliği
Const özelliği atanan bir değer class içinde sabit özelliğini alır. Bu bizim normal kodlarımızdaki define() metodu ile aynıdır fakat sadece class içinde geçerlidir. Const özelliği atanmış bir sabite $this ile değil yine self:: ile erişim yapmaktayız dolayısıyla static özelliğini alırlar çünkü sınıf boyunca sakladıkları değer aynı kalacağından bir defaya mahsus ram de tutulurlar.
Ayrıca const özelliği atanan sabitin başında $ işareti bulanamaz. const sabit = ‘deger’; şeklinde tanımlanırlar.
Örnekle devam edelim.
< ?php
class a
{
const isim = 'yusuf';
public function isimGetir()
{
echo self::isim;
}
}
$a = new a;
echo a::isim;
echo '';
$a->isimGetir();
?>
Bu örnekte de görüldüğü gibi isim sabiti static özelliği de olduğu için hem a::isim; şeklinde ulaşabildik hem de sınıf içinde bir metot sayesinde ulaşabildik.
Final Özelliği
Final özelliği atanmış bir metot veya sınıf son metot veya son sınıf olduğunu işaret eder yani kendisinden sonra herhangi bir başka metot veya sınıf gelemez anlamını taşımaktadır.
Örnekle devam edelim
< ?php
class a
{
private $isim = 'yusuf';
public final function isimGetir()
{
echo $this->isim;
}
}
class b extends a
{
private $baska_isim = 'veli';
public function isimGetir()
{
echo $this->baska_isim;
}
}
$b = new b;
$b->isimGetir();
?>
Bu örnekte a classının en son metodunun isimGetir() olduğu tanımlanmıştır ve bu metotdan sonra herhangi bir metot gelemeyecektir. Yani a sınıfından türeyen bir class da hiç bir şekilde isimGetir() metodu bulunamaz çünkü isimGetir() a sınıfının final metodur ve override (yok sayılarak yeniden aynı metot yazılamaz. (tamam tercümem biraz düşük oldu ) edilemez.
Bu örnek bize metot içindi birde sınıflar bir birleri arasında türetilirken artık son sınıf olduğunu belirtmemiz gerekebilir. Bunun için de class sözcüğünün başına final anahtarı getirilir.
< ?php
class a
{
public function aGetir()
{
echo 'Ben A sınıfıyım. ';
}
}
class b extends a
{
public function bGetir()
{
echo 'Ben B sınıfıyım. ';
}
}
final class c extends b
{
public function cGetir()
{
echo 'Ben C sınıfıyım ve benden sonra başka bir sınıf bana extends edilemez. ';
}
}
$c = new c;
$c->aGetir();
$c->bGetir();
$c->cGetir();
class d extends c
{
public function dGetir()
{
echo 'Ben D sınıfıyım.';
}
}
$d = new d;
?>
Bu örnek çalıştırıldığında c classı final anahtar sözcüğü atandığı için kendisinden hiç bir şekilde sınıf türetilemeyecek ve ekrana “Class d my not inherit from final class (c)..” gibi şeklinde hata mesajı döndürecektir.
Php ile classlara girmeden önce class yapısı hakkında biraz bilgi vermek istiyorum. Php5 ile class yapılarında ciddi bir değişiklik söz konusu oldu php4 deki class yapısı bize bir çok şeyi yapmamıza imkan vermiyordu. Örneğin bir signleton yazılım desenine olanak sağlamıyordu veya gizli olması gereken fonksiyon veya değişkenleri gizlemek için genelde diğerlerinden ayrı olsun diye comment satırları girer veya önlerine _ koyarak belirtmeye çalışır kullanıcıların yanlış kullanımlarını önlemeye çalışırdık.
Php5 den itibaren artık bu tarz comment satırları girmek yerine public, protected, private, static, final, const gibi tanımlar gelmiştir. Bunlar class yazılımında programcılara büyük bir avantaj sağlamaktadır. Örneğin kullanıcının kullanmasını istemediğimiz metot veya değişkenleri private tanımlayarak sadece class içerisinden erişim yapmasını sağlayabiliyoruz ve daha bunun gibi bir çok yeni güzel şeyler var.
Şimdi gelelim classlara. Php ile class yazarken genelde kullanacağımız iki adet sabit metot var diyelim. Sabit dedim başka bir isim bulamadım şuan aklıma gelmiyor. Bu metotlar olmassa olmaz değil ama zamanla çok işimize yarayacak olan __construct ve __destruct metotlarıdır. Construct bir class başlatılırken yapılacak olan işleri yapmakla yükümlü olurken destruct metodu ise tam tersi sınıf sonlandığında yapılması gereken işleri yapmakla yükümlüdür.
Nerelerde kullanacağız sorusuna gelince, Bir sınıf başlatılırken belli başlı bazı ayarlar veya ek işlemler varsa bu metot içine yazılır. Destruct da ise tam tersi örneğin bir class başlarken kullanılan ayarları sıfırlamak için kullanabilirsiniz veya değişkenleri unset etmek için kullanabilirsiniz.
Örnekle devam edelim.
< ?php
class ilk_sinifim
{
public function __construct()
{
echo 'Merhaba \'ilk_sinifim\' başlatıldı.';
}
}
$ilk_sinifim = new ilk_sinifim;
?>
Yukarıdaki örneğimizi yazıp çalıştırdığımız da ekrana “Merhaba ‘ilk_sinifim’ başlatıldı.” şeklinde bir yazıyla karşılaşırız. Ne demiştik __construct (kurucu fonksiyon, yapılandırıcı fonksiyon) sınıf başlatılırken yapılması gereken işlemler varsa bu metotda tanımlanır ve sınıf başlatılırken bu metot içeriği otomatik çalışır demiştik.
Aynı zamanda eğer __construct metodunu kullanacaksak kesinlikle public anahtarı ile tanımlanması gerekir aksi halde protected veya private tanımlanırsa hata ile karşılaşırsınız. İsterseniz __construct metoduna sınıf başlatılırken değişken de gönderebilirsiniz.
Aynı örneği bu sefer de değişken göndererek yapalım.
< ?php
class ilk_sinifim
{
public function __construct($name)
{
echo 'Merhaba {$name}, ben \'ilk_sinifim\' memnun oldum.';
}
}
$ilk_sinifim = new ilk_sinifim('yusuf');
?>
Bu örnekte de sınıf başlatılırken bir $name değişkeni gönderdik. Sınıf başlatıldığında ise “Merhaba yusuf ben ‘ilk_sinifim’ memnun oldum.” yazısı çıkacaktır.
Destruct metodu ise construct metodunun tam tersidir. Sınıf sona erdiğindeki işlemleri yapar.
Bir örnekle pekiştirelim.
< ?php
class ilk_sinifim
{
private $name;
public function __construct($name)
{
$this->name = $name;
echo $this->name;
}
public function __destruct()
{
echo 'Name değişken içeriği boşaltıldı.';
unset($this->name);
}
}
$ilk_sinifim = new ilk_sinifim('yusuf');
?>
Örnekte öncelikle dışardan erişemeyecekleri şekilde bir $name değişkeni tanımladık. Ardından __construct metoduna bir $name değişkeni göndererek sınıf içinde tanımladığımız $name değişkenine eşitledik ve ekrana yazdırdık. Ardından sınıf sonlanacağı vakit ekrana “Name değişken içeriği boşaltıldı.” yazısını yazıp sınıf içindeki $name değişkeninin içeriğini boşaltacaktır.
Destruct metoduda construct gibi public ile tanımlanmalıdır.
