class sinif {
 
    public $ozellik1;
    public $ozellik2;
    const SABIT = 20;
 
    public function yontem()
    {
        echo 'Merhaba';
    }
 
}
 
// Yukarıdaki sınıftan bir nesne türetelim
$nesne = new sinif;
 
// Nesne özelliklerine değer atayalım
$nesne->ozellik1 = 5;
$nesne->ozellik2 = 10;
 
// Oluşturduğumuz nesneyi serialize edelim
$nesnenin_serialize_hali = serialize($nesne);
/*
Bu işlem sonucunda değişkenin değeri aşağıdaki gibi olur
$nesnenin_serialize_hali = 'O:5:"sinif":2:{s:8:"ozellik1";i:5;s:8:"ozellik2";i:10;}'
*/

// Değişkene nesnenin serialize edilmiş halini atayalım
$nesnenin_serialize_hali = 'O:5:"sinif":2:{s:8:"ozellik1";i:5;s:8:"ozellik2";i:10;}';
 
// Unserialize işlemi ile nesneyi tekrar elde edelim
$nesne = unserialize($nesnenin_serialize_hali);
 
// Nesne içeriğini ekranda gösterelim
echo '<pre>'.print_r($nesne, TRUE).'</pre>';
/*
Çıktı:
 
__PHP_Incomplete_Class Object
(
    [__PHP_Incomplete_Class_Name] => sinif
    [ozellik1] => 5
    [ozellik2] => 10
)
// Görüldüğü gibi nesnede en başta bulunan SABIT ve yontem() üyeleri artık bulunmuyor 
*/
 
echo $nesne->ozellik1; // Çıktı: 5
 
$nesne->yontem(); // HATA; nesnede şu anda böyle bir yöntem bulunmuyor

// Önce sınıf tanımını sayfaya ekleyelim
class sinif {
 
    public $ozellik1;
    public $ozellik2;
    const SABIT = 20;
 
    public function yontem()
    {
        echo 'Merhaba';
    }
 
}
 
// Değişkene nesnenin serialize edilmiş halini atayalım
$nesnenin_serialize_hali = 'O:5:"sinif":2:{s:8:"ozellik1";i:5;s:8:"ozellik2";i:10;}';
 
// Unserialize işlemi ile nesneyi tekrar elde edelim
$nesne = unserialize($nesnenin_serialize_hali);
 
// Nesne içeriğini ekranda gösterelim
echo '<pre>'.print_r($nesne, TRUE).'</pre>';
/*
Çıktı:
 
sinif Object
(
    [ozellik1] => 5
    [ozellik2] => 10
)
*/
 
echo $nesne->ozellik1; // Çıktı: 5
 
echo sinif::SABIT; // Çıktı: 20
 
$nesne->yontem(); // Çıktı: Merhaba

class sinif {
 
    public $ozellik1;
    public $ozellik2;
    const SABIT = 20;
 
    public function yontem()
    {
        echo 'Merhaba<br/>';
    }
 
    // Bu sihirli yöntem, nesne serialize işlemine tabi tutulduğunda devreye girer
    public function __sleep()
    {
        echo 'Serialize işlemi gerçekleşti<br/>';
 
        // Serialize işlemine dahil edilmesi gereken özellik isimlerini dizi olarak döndürmemiz gerek
        return array('ozellik1', 'ozellik2');
    }
 
    // Bu sihirli yöntem, unserialize işlemi sonucu nesne tekrar elde edildiğinde devreye girer
    public function __wakeup()
    {
        echo 'Unserialize işlemi gerçekleşti<br/>';
    }
 
}

function __autoload($sinif)
{
    include $sinif.'.php'; // "sinif.php" dosyası otomatik dahil edilecek
}
 
$nesne = new sinif;
 
$nesne->ozellik1 = 5;
$nesne->ozellik2 = 10;
 
$x = serialize($nesne);
/*
__sleep() sihirli yöntemi devreye girer
$x = 'O:5:"sinif":2:{s:8:"ozellik1";i:5;s:8:"ozellik2";i:10;}' olarak atanır
 
Çıktı: Serialize işlemi gerçekleşti
*/
 
$nesne = unserialize($x);
/*
__wakeup() sihirli yöntemi devreye girer
 
Çıktı: Unserialize işlemi gerçekleşti
*/
 
echo '<pre>'.print_r($nesne, TRUE).'</pre>';
/*
Çıktı:
 
sinif Object
(
    [ozellik1] => 5
    [ozellik2] => 10
)
*/
 
echo $nesne->ozellik1.'<br/>'; // Çıktı: 5
 
$nesne->yontem(); // Çıktı: Merhaba
 
echo sinif::SABIT; // Çıktı: 20

class sinif {
 
    public function yontem1($x)
    {
        // "yontem" isimli yöntem, 1 parametre ile çağrılırsa bu yöntem çalışacak
 
        echo $x.'<br />';
    }
 
    public function yontem2($x, $y)
    {
        // "yontem" isimli yöntem, 2 parametre ile çağrılırsa bu yöntem çalışacak
 
        echo $x.' - '.$y;
    }
 
    public function __call($tanimsiz_yontem_adi, $parametreler)
    {
        if ($tanimsiz_yontem_adi == 'yontem')
        {
            $parametre_sayisi = count($parametreler);
 
            switch ($parametre_sayisi)
            {
                case 1:
                    // "yontem" isimli yöntem, 1 parametre ile çağrılırsa "yontem1" yöntemi çalıştırılsın
                    $calistirilacak_yontem_adi = 'yontem1';
                    break;
                case 2:
                    // "yontem" isimli yöntem, 2 parametre ile çağrılırsa "yontem2" yöntemi çalıştırılsın
                    $calistirilacak_yontem_adi = 'yontem2';
                    break;
                default:
                    throw new Exception('Eksik veya fazla parametre girdiniz!');
            }
 
            // Nesnemizin ilgili yöntemini parametrelerimizi de göndererek çalıştıralım
            call_user_func_array(array($this, $calistirilacak_yontem_adi), $parametreler);
 
            // Ek bilgi:
            // call_user_func_array() fonksiyonu, bir nesnenin bir yöntemini çalıştırmaya yarar
            // Kullanımı: call_user_func_array(array($nesne, $calistirilacak_yontem_adi), $parametre_dizisi)
        }
        else
        {
            throw new Exception('Tanımsız bir yöntem çağırdınız!');
        }
    }
 
}
 
$nesne = new sinif;
 
$nesne->yontem(3); // __call() devreye girer, yontem1() çalıştırılır
$nesne->yontem(3, 5); // __call() devreye girer, yontem2() çalıştırılır
 
// Olmayan static tanımlı bir yöntem çağrılırsa, __callStatic() devreye girer

class sinif {
 
    public function __construct()
    {
        // Nesne oluşturulurken gönderilen parametre sayısı
        $parametre_sayisi = func_num_args();
 
        // Nesne oluşturulurken gönderilen parametrelerden oluşan dizi
        $parametreler = func_get_args();
 
        // Nesne oluşturulurken, sınıf kaç parametre ile çağrıldı ise ilgili kurucu yöntem çalıştırılsın
        switch ($parametre_sayisi)
        {
            case 0: // Parametresiz kullanılmışsa
                $this->__call('__construct0', array());
                break;
            case 1: // 1 parametre ile kullanılmışsa
                $this->__call('__construct1', $parametreler);
                break;
            case 2: // 2 parametre ile kullanılmışsa
                $this->__call('__construct2', $parametreler);
                break;
            default: // Diğer durumlarda
                throw new Exception('Parametre sayısı hatalı!');
        }
    }
 
    public function __construct0() // Birinci yapılandırıcı yöntemimiz
    {
        echo '__construct0 çalıştı<br />';
    }
 
    public function __construct1($x) // İkinci yapılandırıcı yöntemimiz
    {
        echo '__construct1 çalıştı<br />';
    }
 
    public function __construct2($x, $y) // Üçüncü yapılandırıcı yöntemimiz
    {
        echo '__construct2 çalıştı';
    }
 
    public function __call($tanimsiz_yontem_adi, $parametreler)
    {
        if (substr($tanimsiz_yontem_adi, 0, 11) == '__construct')
        {
            call_user_func_array(array($this, $tanimsiz_yontem_adi), $parametreler);
        }
        else
        {
            throw new Exception('Tanımsız bir yöntem çağırdınız!');
        }
    }
 
}
 
$nesne0 = new sinif; // __construct0 çalıştırılır
$nesne1 = new sinif(3); // __construct1 çalıştırılır
$nesne2 = new sinif(3, 5); // __construct2 çalıştırılır

class sinif {
 
    // Olmayan özellikleri çalışma esnasında dizi tipindeki bu özellikte tutacağız
    public $dinamik_ozellikler = array();
 
    public function __set($ozellik, $değer)
    {
        // Olmayan bir özelliğe değer atanmaya çalışılırsa bu yöntem devreye girer
 
        $this->dinamik_ozellikler[$ozellik] = $değer;
    }
 
    public function __get($ozellik)
    {
        // Olmayan bir özelliğin değeri alınmaya çalışılırsa bu yöntem devreye girer
 
        if (isset($this->dinamik_ozellikler[$ozellik]))
        {
            return $this->dinamik_ozellikler[$ozellik];
        }
    }
 
    public function __isset($ozellik)
    {
        // Olmayan bir özelliğin varlığı kontrol edilirse bu yöntem devreye girer
 
        if (isset($this->dinamik_ozellikler[$ozellik]))
        {
            return TRUE;
        }
        else
        {
            return FALSE;
        }
    }
 
    public function __unset($ozellik)
    {
        // Olmayan bir özellik yokedilmeye çalışılırsa bu yöntem devreye girer
 
        if (isset($this->dinamik_ozellikler[$ozellik]))
        {
            unset($this->dinamik_ozellikler[$ozellik]);
        }
    }
 
}
 
$nesne = new sinif;
 
$nesne->x = 5; // __set() devreye girer
 
echo $nesne->x; // __get() devreye girer
 
if ( ! empty($nesne->x)) // __isset() devreye girer
{
    unset($nesne->x); // __unset() devreye girer
}

// namespace bloğu dışında PHP kodu bulunamaz
 
namespace alan1 {
 
    class sinif {
 
       public function yontem()
       {
               echo 'İsim alanı : '.__NAMESPACE__.'<br/>';
               echo 'Sınıf : '.__CLASS__.'<br/>';
               echo 'Yöntem : '.__METHOD__.'<br/><br/>';
       }
 
    }
 
}
 
// namespace bloğu dışında PHP kodu bulunamaz
 
namespace alan2 {
 
    // Durum 1 : İsim alanına başka bir isim alanını dahil ediyoruz
    use alan1; // (Durum-1)
 
    // Durum 2 : İsim alanına başka bir isim alanındaki bir sınıfı dahil ediyoruz
    //use alan1\sinif2; // (Durum-2)
 
    // Durum 3 : İsim alanına dahil ettiğimiz sınıflara takma ad tanımlayabiliyoruz
    //use alan1\sinif2 as _sinif2; // (Durum-3)
 
    class sinif {
 
       public function yontem()
       {
           echo 'İsim alanı : '.__NAMESPACE__.'<br/>';
           echo 'Sınıf : '.__CLASS__.'<br/>';
           echo 'Yöntem : '.__METHOD__.'<br/><br/>';
       }
 
       public function yontem2()
       {
           $nesne = new alan1\sinif2; // (Durum-1)
 
           //$nesne = new sinif2; // (Durum-2)
 
           //$nesne = new _sinif2; // (Durum-3)
 
           $nesne->yontem();
       }
 
    }
 
}
 
// namespace bloğu dışında PHP kodu bulunamaz

include 'isim_alani.php';
 
$nesne1 = new alan1\sinif;
$nesne2 = new alan2\sinif;
 
$nesne1->yontem();
/*
Çıktı:
 
İsim alanı : alan1
Sınıf : alan1\sinif
Yöntem : alan1\sinif::yontem
*/
 
$nesne2->yontem();
/*
Çıktı:
 
İsim alanı : alan2
Sınıf : alan2\sinif
Yöntem : alan2\sinif::yontem
*/
 
$nesne2->yontem2();
/*
Çıktı:
 
İsim alanı : alan1
Sınıf : alan1\sinif2
Yöntem : alan1\sinif2::yontem
*/

interface arayuz1 {
 
    public function yontem1(); // Public olmak zorunda
 
}
 
interface arayuz2 {
 
    public function yontem2(); // Public olmak zorunda
 
}
 
class sinif implements arayuz1, arayuz2 {
 
    public function yontem1() // Tanımlanmak zorunda, yoksa hata verir
    {
        echo 'Selam ';
    }
 
    public function yontem2() // Tanımlanmak zorunda, yoksa hata verir
    {
        echo 'Merhaba ';
    }
 
    public function yontem3()
    {
        echo 'Dünya';
    }
 
}
 
$nesne = new sinif;
$nesne->yontem1();
$nesne->yontem2();
$nesne->yontem3();
 
// Çıktı: Selam Merhaba Dünya

interface I_vt {
 
    public function baglan($sunucu, $kullanici_adi, $sifre);
    public function veritabani_sec($veritabani_adi);
    public function sorgu_calistir($sorgu);
    public function kayitlari_getir($vt_kaynak); // $vt_kaynak : mysql_query() fonksiyonundan dönen değer
    public function baglantiyi_sonlandir($vt_baglanti); // $vt_baglanti : mysql_connect() fonksiyonundan dönen değer
 
}
 
class vt_mysql implements I_vt {
 
    public function baglan($sunucu, $kullanici_adi, $sifre)
    { ... }
    public function veritabani_sec($veritabani_adi)
    { ... }
    public function sorgu_calistir($sorgu)
    { ... }
    public function kayitlari_getir($vt_kaynak)
    { ... }
    public function baglantiyi_sonlandir($vt_baglanti)
    { ... }
 
}
 
class vt_pgsql implements I_vt {
 
    public function baglan($sunucu, $kullanici_adi, $sifre)
    { ... }
    public function veritabani_sec($veritabani_adi)
    { ... }
    public function sorgu_calistir($sorgu)
    { ... }
    public function kayitlari_getir($vt_kaynak)
    { ... }
    public function baglantiyi_sonlandir($vt_baglanti)
    { ... }
 
}
 
// Veritabanı işlemlerini MySQL ile yapmak istersem
$vt = new vt_mysql;
 
// Veritabanı işlemlerini PostgreSQL ile yapmak istersem
$vt = new vt_pgsql;
 
// Her iki durumda da aşağıdaki yöntemler geçerli olacaktır
$vt->baglan($sunucu, $kullanici_adi, $sifre);
$vt->veritabani_sec($veritabani_adi);
$vt->sorgu_calistir($sorgu);
$kayitlar = $vt->kayitlari_getir($vt_kaynak);
$vt->baglantiyi_sonlandir($vt_baglanti);

abstract class soyut_sinif {
 
    public $x = 'Selam ';
 
    public abstract function yontem1(); // Soyut yöntem; sadece tanım satırı var, gövdesi yok
 
    public function yontem2()
    {
        echo 'Merhaba ';
    }
 
}
 
class sinif extends soyut_sinif {
 
    public function yontem1() // Tanımlanmak zorunda, yoksa hata verir
    {
        echo $this->x;
    }
 
    public function yontem3()
    {
        echo 'Dünya';
    }
 
}
 
// $nesne = new soyut_sinif; // HATA; soyut sınıftan nesne türetilemez
 
$nesne = new sinif;
 
$nesne->yontem1();
$nesne->yontem2();
$nesne->yontem3();
 
// Çıktı: Selam Merhaba Dünya

abstract class canli {
 
    // Bu sınıf, bütün canlılara özgü en genel özellik ve eylemleri içeriyor
    // "canli" sınıfı tek başına bir anlam ifade etmiyor
    // Kendisinden başka sınıflar türetildiğinde anlam ifade ediyor
 
    protected $yas; // Her canlının bir yaşı vardır
    protected $yasama_durumu = TRUE; // Her canlı bir gün ölür
 
     // Her canlı beslenir ancak beslenme şekilleri birbirinden farklıdır
    public abstract function beslen();
 
}
 
class hayvan extends canli {
 
    protected $tur;
    protected $cins;
 
    public function beslen()
    {
        // Hayvanın beslenmesi insandan farklıdır
    }
 
}
 
class insan extends canli {
 
    protected $cinsiyet;
    protected $meslek;
 
    public function beslen()
    {
        // İnsanın beslenmesi hayvandan farklıdır
    }
 
}

/**
 * vt.sinif.php
 * 
 * Veritabanı işlemleri için basit bir sınıf
 *
 * @author Bülent YILMAZ
 */
class vt {
 
    private $sunucu; // Veritabanı sunucusunun adresini tutacak
    private $kullanici_adi;
    private $sifre;
    private $veritabani_adi; // Kullanılacak veritabanının adını tutacak
    private $vt_baglanti; // mysql_connect() fonksiyonundan dönen değeri tutacak
    private $vt_kaynak; // mysql_query() fonksiyonundan dönen değeri tutacak
    private $sonuc; // SELECT sorgularından dönen nesne dizisini tutacak
 
    /**
     * Kurucu yöntem. Burada ilklendirme işlemleri yapılır.
     *
     * @param string $sunucu
     * @param string $kullanici_adi
     * @param string $sifre
     * @param string $veritabani_adi
     */
    public function __construct($sunucu, $kullanici_adi, $sifre, $veritabani_adi)
    {
        $this->sunucu = $sunucu;
        $this->kullanici_adi = $kullanici_adi;
        $this->sifre = $sifre;
        $this->veritabani_adi = $veritabani_adi;
        $this->vt_baglanti = NULL;
        $this->vt_kaynak = NULL;
        $this->sonuc = array();
    }
 
    /**
     * Veritabanı bağlantısı yapılır.
     */
    public function baglan()
    {
        // Veritabanı sunucusuna bağlan
        $this->vt_baglanti = mysql_connect($this->sunucu, $this->kullanici_adi, $this->sifre);
 
        // Veritabanı sunucusu ile bağlantı gerçekleşti ise istenen veritabanını seçili hale getir
        if (is_resource($this->vt_baglanti))
        {
            mysql_select_db($this->veritabani_adi);
        }
 
    }
 
    /**
     * Sorgu işletilir.
     *
     * @param string $sorgu
     */
    public function sorgu_islet($sorgu)
    {
        $this->vt_kaynak = mysql_query($sorgu, $this->vt_baglanti);
    }
 
    /**
     * SELECT sorguları için nesne dizisi döndürülür
     * 
     * @return array
     */
    public function kayitlari_getir()
    {
        if ($this->vt_kaynak && mysql_num_rows($this->vt_kaynak))
        {
            while ($sorgu_fo = mysql_fetch_object($this->vt_kaynak))
            {
                $this->sonuc[] = $sorgu_fo; // Her kayıt bir nesne olarak dizide toplanır
            }
 
            return $this->sonuc; // Nesne dizisini döndür
        }
    }
 
    /**
     *  Yıkıcı yöntem. Burada sonlandırma işlemleri yapılır.
     */
    public function __destruct()
    {
        if (is_resource($this->vt_baglanti))
        {
            mysql_close($this->vt_baglanti); // Veritabanı bağlantısını sonlandır
        }
 
        unset($this->sonuc); // Nesne dizisi oluşturulmuş ise yoket
    }
 
}

include 'vt.sinif.php'; // Veritabanı sınıfımızın tanımlı olduğu dosyayı dahil edelim
 
$vt = new vt('127.0.0.1', 'root', '123', 'test'); // Veritabanı nesnemizi tanımlayalım
 
$vt->baglan(); // Veritabanı bağlantısını kuralım
 
// SELECT sorgusu
$vt->sorgu_islet(" SELECT * FROM kisi ");
foreach ($vt->kayitlari_getir() as $kayit)
{
    echo $kayit->ad.'<br />';
}
/*
Çıktı:
 
Ahmet
Mehmet
Hasan
*/
 
// UPDATE sorgusu
$vt->sorgu_islet(" UPDATE kisi SET ad = 'Ziya' WHERE id = 1 ");
 
// DELETE sorgusu
$vt->sorgu_islet(" DELETE FROM kisi WHERE id = 1 ");

class sinif {
 
	private static $nesne; // Bellekte sınıfın tek örneğini tutacak olan sınıf özelliği
 
	// Kurucu yöntemler normalde public olarak tanımlanır.
	// Tekilleştirme tasarım deseninin özelliği gereği burada kurucu metod private olarak tanımlanıyor.
	// Burada amaç, nesnenin "new" işleci ile doğrudan oluşturulmasını engellemektir.
	private function __construct()
	{}
 
	// Static olarak tanımlıyoruz ki; nesne oluşmamış olsa bile bu yöntemi çağırabilelim.
	public static function singleton()
    	{
           	if ( ! self::$nesne instanceof self) // Sınıfın daha önceden oluşturulmuş bir örneği (yani nesne) yoksa
           	{
                   	self::$nesne = new self; // Nesneyi oluşturalım ve sınıfımızın tek örneğini tutan özelliğimize atayalım
           	}
           	return self::$nesne;
    	}
 
    	// Örnek bir yöntem tanımlayalım
    	public function yontem()
    	{
    	    	echo 'Merhaba';
    	}
 
    	// "__clone" yöntemini kullanarak dışarıdan bu sınıfın çoğaltılmasını engelliyoruz.
    	public function __clone()
    	{
          	trigger_error('Nesne çoğaltılamaz!', E_USER_ERROR);
    	}
 
}

$nesne = new sinif(); // Ölümcül hata (fatal error) oluşur

$nesne = sinif::singleton();
$nesne->yontem(); // Çıktı: Merhaba
// veya
sinif::singleton()->yontem(); // Çıktı: Merhaba

$nesne2 = clone($nesne); // Ölümcül hata (fatal error) oluşur

class nesne_uret {
 
   // Tüm sınıflarımızın içinde tanımlı olduğu dizinin yolunu tutacak sabit
   const DIZIN_YOLU = './siniflar/';
 
   public static function factory($sinif_adi) /* static olmak zorunda */
   {
       try
       {
           if (file_exists(self::DIZIN_YOLU . $sinif_adi . '.php'))
           {
               // Sınıfın tanımlı olduğu dosyayı dahil edelim 
               include_once(self::DIZIN_YOLU . $sinif_adi . '.php');
 
               // Nesneyi üretip geriye döndürelim 
               return new $sinif_adi();
           }
           else
           {
               throw new Exception('Sınıf Bulunamadı!');
           }            
       }
       catch (Exception $hata)
       {
           echo '<pre>' . print_r($hata, TRUE) . '</pre>';
       }
   }
 
}
 
// "sinif" isimli sınıf, "./siniflar/sinif.php" dosyası içinde tanımlı
$nesne = nesne_uret::factory('sinif');
 
$nesne->yontem(); // Çıktı: 5

class sinif {
 
    private $x = 5;
 
    public function yontem()
    {
           echo $this->x;
    }
 
}

<?php defined('SYSPATH') or die('No direct script access.');
 
class Controller_Deneme extends Controller
{
 
    private $model; // Bu nesne özelliği, model nesnemizi tutacak
    private $view; // Bu nesne özelliği, view nesnemizi tutacak
 
    public function before()
    {
        // Model nesnemizi tanımlayalım
        $this->model = Model::factory('model1');
 
        // View nesnemizi tanımlayalım
        $this->view = View::factory('view1');
    }
 
    public function action_index()
    {
        // View içine model nesnemizin kisi_ad() yönteminin döndürdüğü değeri gönderelim
        $this->view->set('ad', $this->model->kisi_ad($_GET['id']));
 
        // View nesnemizin HTML çıktısını ekrana basalım
        $this->request->response = $this->view->render();
    }
 
}

<?php defined('SYSPATH') or die('No direct script access.');
 
class Model_Model1 extends Model
{
 
    /**
     * ID'si verilen kaydın "ad" kolonundaki değeri döndürür.
     * 
     * @param     integer      Kişi ID'si
     * @return    string       Kişi adı
     */
    public function kisi_ad($id)
    {
        $sonuc = DB::query(Database::SELECT, " SELECT ad FROM kisi WHERE id = :id ")
                    ->param(':id', $id)
                    ->execute()
                    ->get('ad'); // İlgili kaydın "ad" kolonundaki değer
 
        return $sonuc; // Sonucu controller'a geri döndürelim
    }
 
}

<?php defined('SYSPATH') or die('No direct script access.');
 
echo 'Ad: ' . $ad; // Controller'dan gelen değeri ekrana basalım

class sinif
{
    public $isim;
 
    public function __construct($ad)
    {
        $this->isim = $ad;
    }
}
$nesne = new sinif('Bülent'); 
// Nesne oluşturulurken $nesne->isim özelliğinin değeri "Bülent" yapılır

class sinif2 extends sinif1
{
    public function __construct()
    {
        parent::__construct(); // Önce sinif1 sınıfının kurucu yöntemi işletiliyor
        ...
    }
}

class sinif
{
    private $isim;
 
    public function __destruct()
    {
        $this->isim = NULL;
    }
}

class sinif2 extends sinif1
{
    public function __destruct()
    {
        parent::__destruct(); // Önce sinif1 sınıfının yıkıcı yöntemi işletiliyor
        ...
    }
}

public function __call($ad, $parametreler_dizi)
{
    // $ad : tanımsız yöntem adı
    // $parametreler_dizi : yöntem çağrılırken kullanılan parametrelerden oluşan dizi
    echo "{$ad} isminde yöntem yok!";
}
 
// $nesne->yontem() biçiminde olmayan bir yöntem çağrılırsa devreye girer

public function __callStatic($ad, $parametreler_dizi)
{
    // $ad : tanımsız yöntem adı
    // $parametreler_dizi : yöntem çağrılırken kullanılan parametrelerden oluşan dizi
    echo "{$ad} isminde yöntem yok!";
}
 
// sinif::yontem() biçiminde olmayan bir static yöntem çağrılırsa devreye girer

public function __get($ad)
{
    // $ad : tanımsız özellik adı
    echo "{$ad} isminde özellik yok!";
}

public function __set($ad, $deger)
{
    // $ad : tanımsız özellik adı
    // $deger : atanmaya çalışılan değer
    echo "{$ad} isminde özellik yok!";
}

public function __isset($ad)
{
    // $ad : tanımsız özellik adı
    echo "{$ad} isminde özellik yok!";
}

public function __unset($ad)
{
    // $ad : tanımsız özellik adı
    echo "{$ad} isminde özellik yok!";
}

public function __toString()
{
    // Nesnenin içeriğini formatlı olarak ekranda gösterelim
    echo '<pre>' . print_r((array) $this, TRUE) . '</pre>';
}
 
echo $nesne; // şeklinde yazdırılmaya çalışılırsa devreye girecektir

class sinif
{
    public $x = 1;
    public $y = 2;
 
    public function __clone()
    {
        $this->x = 0; // Başka nesneye o anki değeri ile değil de, 0 değeri ile aktarılmasını sağlar
    }
}
 
$nesne1 = new sinif(); // $nesne1->x : 1 , $nesne1->y : 2
$nesne2 = clone $nesne1; // $nesne2->x : 0 , $nesne2->y : 2

class sinif
{
    public $x = 1;
    public $y = 2;
    public $z = 3;
 
    public function __sleep()
    {
        return array('x', 'y'); 
        // Bu durumda sadece "x" ve "y" özellikleri serialize işlemine katılır
    }
}

class sinif
{
    ...
}
$a = new sinif;
var_dump($a instanceof stdClass); // Çıktı: bool(false)
 
$b = (object) NULL;
var_dump($b instanceof stdClass); // Çıktı: bool(true)

if (class_exists('sinif'))
{
    $nesne = new sinif();
}

class sinif {
 
    public static $ozellik = 5;
 
    public static function yontem()
    {
        self::$ozellik++; // static özelliklere "$this->" yerine "self::" ile erişilir
    }
 
}
 
// Nesne oluşturmadan sınıfın static özellik ve yöntemlerini doğrudan kullanabiliriz
sinif::yontem();
echo sinif::$ozellik; // Çıktı : 6

$nesne = new sinif;
 
// Nesne oluşturarak da sınıfın static yöntemlerini kullanabiliriz
$nesne->yontem();
 
// Static özellikler bu şekilde kullanılamaz
echo $nesne->ozellik; // HATA

sinif::yontem(); // 5 değeri 1 arttırılır
 
echo sinif::$ozellik; // Çıktı : 6
 
$nesne = new sinif; // Nesne oluştur
 
echo sinif::$ozellik; // Çıktı : 6 (5 değil)

// Bu fonksiyon sayfa içinde herhangi bir yerde tanımlanır
function __autoload($sinif_adi)
{
    require_once "../sinif/{$sinif_adi}.sinif.php";
}
 
// Nesneyi tanımlayalım
$nesne = new kutu(); // Sınıf çağrıldığı anda, sınıfın tanımlı olduğu dosya otomatik dahil edilir

// Sınıf içinde herhangi bir yerde iken;
echo __CLASS__; // Çıktı: sinif_adi

// Sınıfın herhangi bir yöntemi içinde iken;
echo __METHOD__; // Çıktı: sinif_adi::yontem_adi

var_dump(new stdClass); // stdClass Object () , boş sınıf
var_dump((object) NULL); // stdClass Object () , boş sınıf
var_dump((object) 'a'); // stdClass Object ( [scalar] => a )
var_dump((object) array('a' => 1, 'b' => 2)); // stdClass Object ( [a] => 1 [b] => 2 )

// Aşağıdaki gibi çok boyutlu bir dizimiz olsun
 
$dizi = array(
	'a' => 'Bülent',
	'b' => array( 	/* Elemanları dizi olan dizi */
		        array(
		            'x' => 5,
		            'y' => 10
		        ),
		        array(
		            'q' => 15,
		            'w' => 20
		        )
                )
);
 
echo $dizi['a']; // Çıktı: "Bülent"
echo $dizi['b'][0]['y']; // Çıktı: 10
echo $dizi['b'][1]['q']; // Çıktı: 15
 
// Dizileri nesnelere dönüştürerek kullanalım
 
$nesne = (object) array(
	'a' => 'Bülent',
	'b' => array( 	/* Elemanları nesne olan dizi */
		        (object) array(
		            'x' => 5,
		            'y' => 10
		        ),
	        	(object) array(
	        	    'q' => 15,
	        	    'w' => 20
		        )
    	        )
);
 
echo $nesne->a; // Çıktı: "Bülent"
echo $nesne->b[0]->y; // Çıktı: 10
echo $nesne->b[1]->q; // Çıktı: 15

class sinif
{
    public $var1 = 1;
    protected $var2 = 2;
    private $var3 = 3;
    static public $var4 = 4;
    const SABIT = 5;
 
    public function yontem()
    {
        echo 'merhaba';
    }
}
 
$nesne = new sinif();
echo '<pre>' . print_r((array) $nesne, TRUE) . '</pre>';
 
/*
Çıktı:
 
Array
(
    [var1] => 1
    [ *var2] => 2
    [ sinifvar3] => 3
)
// Protected özellik başında "*" ile gösterilir
// Private özellik başında sınıf adı ile gösterilir
// Static özellik ve sabit, diziye aktarılmaz
// Sınıfın yöntemleri tip dönüşümü ile aktarılamaz
*/

class sinif {
 
    public $x = 5;
    public $y = 6;
    public static $z = 7;
 
    private $q = 8;
 
    protected $w = 9;
 
    public function yontem()
    {
        echo 'merhaba';
    }
 
}
 
$nesne = new sinif;
 
foreach ($nesne as $anahtar => $deger)
{
    echo '<div>'.$anahtar.' = '.$deger.'</div>';
}
 
/*
Çıktı:
 
x = 5
y = 6
// static özellik esgeçilir
// private ve protected özellikler esgeçilir
*/
 
// Burada ise nesneyi önce diziye aktarıp sonra döngüye sokuyoruz
// Bu durumda static özellik dışındaki özellikler diziye aktarılacaktır
foreach ((array) $nesne as $anahtar => $deger)
{
    echo '<div>'.$anahtar.' = '.$deger.'</div>';
}
 
/*
Çıktı:
 
x = 5
y = 6
sinifq = 8
*w = 9
*/

try
{
    if ( ! is_int($x)) // Örnek bir koşul
    {
        throw new Exception('Sayı değil!'); // Hata tetikliyoruz
        // veya
        // trigger_error('Sayı değil!', E_USER_ERROR); // Hata tetikliyoruz
    }
}
catch (Exception $hata)
{
        die($hata->getMessage());
}

function hata($hata)
{
        $mesaj = '<p>Hatanın oluştuğu dosya adı = '
               . $hata->getFile() . '</p>';
        $mesaj .= '<p>Hatanın oluştuğu satır no = '
               . $hata->getLine() . '</p>';
        $mesaj .= '<p>Hata mesajı = ' . $hata->getMessage() . '</p>';
        $mesaj .= '<p>Hata kodu = ' . $hata->getCode() . '</p>';
        return $mesaj;
}
 
try
{
        throw new Exception('Hata oluştu!');
}
catch (Exception $hata)
{
        die(hata($hata));
}

$nesne = new sinif(); // kurucu yöntem ile nesne tanımlandı
// bu kullanımda sınıf tanımlanırken kurucu yönteme parametre de geçirilebilir
$nesne = new sinif(5);
 
//veya
 
$nesne = new sinif; // sınıf adı ile nesne tanımlandı
 
// Not: Türetilen nesnenin, türetildiği sınıfla aynı isimde olmasında sakınca yoktur.
$x = new x();

class sinif
{
    private $ad;
 
    public function ad_ata($x) // Setter method
    {
        $this->ad = $x;
    }
 
    public function ad_getir() // Getter method
    {
        return $this->ad;
    }
}
 
$nesne = new sinif();
$nesne->ad_ata('Bülent');
echo $nesne->ad_getir();

class sinif {
 
    // Sınıfın özellikleri (2 adet)
 
    public $x = 5; // Sınıfın özelliği
    const SABIT = 10; // Sınıfın özelliği
 
    // Sınıfın yöntemleri (2 adet)
 
    public function fonk1() // Sınıfın yöntemi
    {}
 
    public function fonk2() // Sınıfın yöntemi
    {}    
 
}

class sinif {
 
    private $ozellik1 = 3; // Türetilen sınıfa değeri aktarılmaz
    protected $ozellik2 = 5; // Türetilen sınıfa değeri aktarılır
 
}
 
class sinif2 extends sinif {
 
    public function goster()
    {
        echo "ozellik1 = {$this->ozellik1}<br/>";
        echo "ozellik2 = {$this->ozellik2}";
    }
 
}
 
$nesne = new sinif2;
$nesne->goster();
 
/*
Çıktı:
 
ozellik1 =
ozellik2 = 5
*/

class sinif {
 
    public function yontem1()
    {
        $x = 5; // Bu değişken sadece bu yöntem içinde kullanılabilir (sınıf özelliği değil, yerel değişken)
    }
 
    public function yontem2()
    {
        echo $x; // HATA, buradan bu değişkene erişilemez
    }    
 
}

class sinif {
 
    // Sınıf özelliklerini normalde burada tanımlamamız gerekir
    // public $ozellik; // Bu satırı yoruma aldık
 
    public function yontem()
    {
        $this->ozellik = 5; // Üstte tanımlanmadan kullanıldı
        // Bu durumda bu nesne özelliği, public olarak tanımlanmış gibi kabul edilir
 
        echo $this->ozellik;
    }
 
}
 
$nesne = new sinif;
$nesne->yontem(); // Çıktı: 5

class sinif
{
    const SABIT = 5;
 
    public function yontem()
    {
        echo self::SABIT; // Sınıf içinde kullanımı
    }
}
 
$nesne = new sinif;
$nesne->yontem(); // Çıktı: 5
 
// Sınıf dışında kullanımı (nesne oluşturmadan)
echo sinif::SABIT; // Çıktı: 5

class cocuk_sinif extends ata_sinif
{
    ...
}

final class cocuk_sinif extends ata_sinif
{
    ...
}

class ata_sinif {
 
    final public function yontem()
    {
        ...
    }
 
}
 
class cocuk_sinif extends ata_sinif {
 
    public function yontem() // HATA
    {
        ...
    }
 
}

// (1) Doğrudan atama (referans atama ile eşdeğerdir)
// Birbirlerinden eşzamanlı olarak etkilenirler
// Tek fark birine NULL atanırsa diğeri etkilenmez
$nesne2 = $nesne1;
 
// (2) Referans atama
// Birbirlerinden eşzamanlı olarak etkilenirler
// Birine NULL atanırsa ikisi de NULL olur
$nesne_ref = & $nesne1;
 
// (3) Kopyasını çıkarma
// Birbirlerinden bağımsızdırlar ve etkilenmezler
$nesne3 = clone $nesne1;

unset($nesne1); // Sadece $nesne1 nesnesi silinir
 
$nesne1 = NULL; // Bu durumda $nesne_ref nesnesi de NULL olur

class sinif {
 
	public function yontem1()
	{
		…
		return $this; /* Zincirleme için gerekli */
	}
 
	public function yontem2()
	{
		…
		return $this; /* Zincirleme için gerekli */
	}
 
	public function yontem3()
	{
		…
		return $this; /* Zincirleme için gerekli */
	}
 
}
 
$nesne = new sinif;
 
$nesne->yontem1()
      ->yontem2()
      ->yontem3(); // Zincirleyerek 3 yöntemi arka arkaya çalıştırıyoruz
 
// veya
 
$nesne->yontem1(); // Ayrı ayrı çalıştırıyoruz
$nesne->yontem2();
$nesne->yontem3();

// current() ile SELECT işlemi
$dizi = DB::query(Database::SELECT, " SELECT * FROM personel WHERE personel_id = 243 ")
   ->execute()
   ->current(); // Tek bir kayıt (dizi olarak) döndürür
 
// as_array() ile SELECT işlemi
$dizi = DB::query(Database::SELECT, " SELECT * FROM personel WHERE bolum_id = 12 ")
   ->execute()
   ->as_array(); // Birden çok kayıt (dizi olarak) döndürür
 
// get() ile SELECT işlemi
$deger = DB::query(Database::SELECT, " SELECT isim FROM personel WHERE personel_id = 243 ")
   ->execute()
   ->get('isim'); // Tek bir değer  döndürür
 
// INSERT işlemi
DB::query(Database::INSERT, " INSERT bolumler ('bolum_id', 'silindi') VALUES (12, 'H') ")
   ->execute();
 
// UPDATE işlemi
DB::query(Database::UPDATE, " UPDATE bolumler SET silindi = 'H' WHERE bolum_id = 12 ")
   ->execute();
 
// DELETE işlemi
DB::query(Database::DELETE, " DELETE bolumler WHERE bolum_id = 12 ")
   ->execute();

$dizi = DB::query(Database::SELECT, " SELECT * FROM personel WHERE bolum_id = :bolum_id AND silindi = :silindi ")
   ->param(':bolum_id', 12)
   ->param(':silindi', 'H')
   ->execute()
   ->as_array();
 
// veya
 
$dizi = DB::query(Database::SELECT, " SELECT * FROM personel WHERE bolum_id = :bolum_id AND silindi = :silindi ")
   ->parameters(array(':bolum_id' => 12, ':silindi' => 'H'))
   ->execute()
   ->as_array();
 
// veya
 
$dizi = DB::query(Database::SELECT, " SELECT * FROM personel WHERE bolum_id = :bolum_id AND silindi = :silindi ")
   ->bind(':bolum_id', $bolum_id)
   ->bind(':silindi', $silindi)
   ->execute()
   ->as_array();

// SELECT işlemi
$dizi = DB::select('id', array('isim', 'ad'), 'tel')
   ->distinct(TRUE)
   ->from('personel')
   ->where('bolum_id', '=', 12)
   ->or_where('bolum_id', '=', 15)
   ->order_by('tarih', 'DESC')
   ->limit(10)
   ->execute()
   ->as_array();
// Sorgu: "SELECT DISTINCT id, isim AS ad, tel FROM personel WHERE bolum_id = 12 OR bolum_id = 15 ORDER BY tarih DESC LIMIT 10"
 
// INSERT işlemi
DB::insert('personel', array('isim', 'tel'))
   ->values(array($isim, $tel))
   ->execute();
// Sorgu: "INSERT personel ('isim', 'tel') VALUES ($isim, $tel)"
 
// UPDATE işlemi
DB::update('personel')
   ->set(array('silindi' => 'E'))
   ->where('bolum_id', '=', 12)
   ->execute();
// Sorgu: "UPDATE personel SET silindi = 'E' WHERE bolum_id = 12"
 
// DELETE işlemi
DB::delete('personel')
   ->where('bolum_id', '=', 12)
   ->execute();
// Sorgu: "DELETE FROM personel WHERE bolum_id = 12"

// Önce şablon nesnesi tanımlanır
 
public $template = 'v'; // Bu sınıf özelliği, metodların üstünde sınıf özelliği olarak tanımlanır
 
 
// Sınıfın herhangi bir yöntemi içinde;
 
$this->template->bind('deger', $degisken);
// veya
$this->template->set('deger', 5);
// veya
$this->template->deger = 5; // set() yöntemi ile eşdeğer
 
// Şablon dosyasının içinde $deger değişkeni olarak kullanılır
// Şablon içeriği otomatik ekrana yazılacaktır

// Önce view nesnesi tanımlanır
 
public $view_nesnesi = View::factory('v'); // Bu sınıf özelliği, metodların üstünde sınıf özelliği olarak tanımlanır
 
 
// Sınıfın herhangi bir yöntemi içinde;
 
// View içine değer gönderelim
$this->view_nesnesi->bind('deger', $deger);
// veya
$this->view_nesnesi->set('deger', 5);
 
// View içeriğini ekrana yazdıralım
 
$this->request->response = $this->view_nesnesi->render(); // HTML kodu üretilip atanır
// veya
$this->request->response = $this->view_nesnesi; // render() yöntemi kullanılmasa da otomatik render edilip atanır
 
// View dosyasının içinde $deger değişkeni olarak kullanılır

$parametreler['deger1'] = 5;
$parametreler['deger2'] = 10;
$this->request->response = View::factory('v', $parametreler);
// view içinde $deger1 ve $deger2 olarak kullanılır

$this->template->v1 = View::factory('alt1/v1');

echo $v1; // şeklinde çağrılır

$this->view_nesnesi->set('v1', View::factory('alt1/v1'));

echo $v1; // şeklinde çağrılır

echo View::factory('alt1/v1')->render();
// HTML içerik üretilip ekrana basılıyor

class Model_Ornek extends Model // Sınıf adlandırması standarda göre yapılır (hiyerarşi belirtiyor)
{
   // Özellik ve yöntemler
}

class Model_Proje_Deneme extends Model // Sınıf adlandırması standarda göre yapılır (hiyerarşi belirtiyor)
{
   // Özellik ve yöntemler
}

// Controller sınıfının içinde iken, bu sınıfın $model_nesnesi özelliğine atayalım
$this->model_nesnesi = Model::factory('proje_deneme'); 
// "model/" dizini sonrasından itibaren yazılır, hiyerarşi alt çizgi ile belirtilir

// Controller sınıfının içinde iken, bu sınıfın $model_nesnesi özelliğine atayalım
$this->model_nesnesi = new Model_Proje_Deneme;

class Controller_Ornek extends Controller_Template
{
   public $template = 'v'; // view konumu : "application/views/v.php"
 
   public function action_index() // varsayılan yöntem
   {
       $this->template->deger = "selam"; // Ata sınıf "Controller_Template" ise şablona bu şekilde değer gönderilir
       // Şablon içinde $deger değişkeni "selam" değerini tutar
   }
}

class Controller_Ornek extends Controller
{
   public function action_index()
   {
       $this->request->response = "selam"; // Ata sınıf "Controller" olduğu durumda ekrana yazılacak değer bu şekilde atanır.
   }
}

public function before()
{
   parent::before(); // Mutlaka yazılmalı!
 
   // Model ve view nesnelerinin tanımlanması gibi ilk işlemler yapılır
   $this->model1 = Model::factory('dizin_m'); // konum : "application/model/dizin/m.php"
   $this->view1 = View::factory('dizin/v'); // konum : "application/views/dizin/v.php"
}

public function __construct(Request $request) // before() metodu yerine kullanılabilir
{
   parent::__construct($request); // Mutlaka yazılmalı!
 
   $this->model1 = Model::factory('dizin_m'); // konum : "application/model/dizin/m.php"
   $this->view1 = View::factory('dizin/v'); // konum : "application/views/dizin/v.php"
}

public function after()
{
   parent::after(); // Mutlaka yazılmalı!
 
   // Veritabanı sonlandırma gibi işlemler
}

class Sinif_Kutu // Standarda göre
{
   public static $x = 5;
}

echo Sinif_Kutu::$x;

class kutu // Sınıf ismi standarda göre değil (hiyerarşi belirtmiyor)
{
   public static $x = 5;
}

Kohana::auto_load('Sinif_Kutu'); // Sınıfı çağır
echo kutu::$x;

<?php defined('SYSPATH') OR die('No direct access allowed.');

View::factory('profiler/stats');

Kohana::init(array('errors' => FALSE));

$this->request->redirect('test'); 
// http://localhost/kohana/test adresine yönlenir
// veya
$this->request->redirect('http://localhost/kohana/test'); 
// yönlenilecek tam yol yazılır

Route::set('default', '((/(/)))')
   ->defaults(
      array(
         'controller' => 'test', /* varsayılan controller */
         'action' => 'index', /* varsayılan yöntem */
         'id' => 1 /* varsayılan parametre */
      )
);

Route::set(
   'altklasor',
   '<directory>(/<controller>(/<action>(/<id>)))',
   array(
      'directory' => '(alt1(/(alt2))|alt1)')
   );
// Alt klasör daha önce tanımlanmalı (yani alt2, alt1'den daha önce tanımlanmalı)

Route::set('default',
   '(<controller>(/<action>(/<id>)))',
   array('id' => '[0-9a-zA-Z]{1}') /* Parametre 1 basamaklı rakam veya alfabetik karakter olabilir anlamına geliyor */
);

$uri = 'http://localhost/kohana/test'; // Test edilecek URI
foreach (Route::all() as $rota)
{
   echo Kohana::debug($rota->matches($uri));
   // Eşleşmeyen rotalar yerine FALSE, eşleşen rotalarda ise
   // path, controller, action ve içeriklerinden oluşan bir dizi yazar
}

echo '<pre>' . print_r(Request::instance(), TRUE) . '</pre>';

echo Request::instance()->controller; // Çıktı : test

$dizi = array('a', 'b', 'c');
print_r($dizi);

echo '<pre>';
print_r($dizi);
echo '</pre>';
 
// veya
 
echo '</pre>' . print_r($dizi, TRUE) . '</pre>';

SELECT * FROM tablo WHERE id > 100 LIMIT 10

SELECT SQL_CALC_FOUND_ROWS * FROM tablo WHERE id > 100 LIMIT 10

$toplam_kayit_sayisi_s = mysql_query(" SELECT FOUND_ROWS() AS adet ");
$toplam_kayit_sayisi_fa = mysql_fetch_array($toplam_kayit_sayisi_s, MYSQL_ASSOC);
$toplam_kayit_sayisi = $toplam_kayit_sayisi_fa['adet'];