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();