PHP'de Nesne Yönelimli Programlama (OOP) Rehberi: Temellerden İleri Seviyeye

LydexCoding · 13 Ağu 2025

Giriş: Nesne Yönelimli Programlama (OOP) Nedir?

Modern yazılım geliştirmenin temel taşlarından biri olan Nesne Yönelimli Programlama (OOP), kodun daha düzenli, yeniden kullanılabilir ve bakımı kolay olmasını sağlayan bir programlama paradigmasıdır. PHP, 5. sürümünden itibaren OOP'yi tam anlamıyla desteklemeye başlamış ve günümüzdeki çoğu PHP framework'ü (Laravel, Symfony, CodeIgniter vb.) bu yaklaşıma dayanmaktadır. OOP, gerçek dünyadaki varlıkları (nesneleri) yazılım içinde modellemeyi amaçlar. Bu rehberde, PHP'de OOP'nin temel prensiplerinden başlayarak ileri düzey konulara kadar geniş bir yelpazede bilgi edineceksiniz. Amacımız, sadece teorik bilgiyi vermekle kalmayıp, bol örneklerle konuyu pekiştirmenizi sağlamaktır.

Neden OOP Kullanmalıyız?

Modülerlik: Kod parçalarını bağımsız modüller halinde düzenlemeyi sağlar.
Yeniden Kullanılabilirlik: Bir kere yazılan kodu farklı yerlerde tekrar kullanma imkanı sunar.
Bakım Kolaylığı: Hata ayıklama ve kodda değişiklik yapma süreçlerini basitleştirir.
Ölçeklenebilirlik: Büyük ve karmaşık projelerin yönetimini kolaylaştırır.
Esneklik: Yeni özellikler eklemeyi veya mevcutları değiştirmeyi daha az riskli hale getirir.

1. Sınıflar ve Nesneler

OOP'nin temel yapı taşları sınıflar ve nesnelerdir.

Sınıf (Class): Nesnelerin bir şablonu, planı veya prototipidir. Bir sınıf, nesnelerin sahip olacağı özellikleri (özellikler/properties) ve davranışları (metotlar/methods) tanımlar. Örneğin, bir 'Araba' sınıfı, tüm arabaların ortak özelliklerini (marka, model, renk) ve davranışlarını (hızlan, fren yap) içerebilir.

Nesne (Object): Bir sınıfın somutlaştırılmış halidir. Sınıf bir kalıpken, nesne o kalıptan üretilmiş bir örnektir. 'Araba' sınıfından 'bmw', 'mercedes' gibi nesneler oluşturabiliriz.

Kod:

<?php
class Araba {
    public $marka;
    public $model;
    public $renk;

    public function hizlan() {
        return $this->marka . ' ' . $this->model . ' hızlanıyor.';
    }

    public function frenYap() {
        return $this->marka . ' ' . $this->model . ' fren yapıyor.';
    }
}

// Nesne oluşturma
$bmw = new Araba();
$bmw->marka = 'BMW';
$bmw->model = 'M5';
$bmw->renk = 'Siyah';

echo $bmw->hizlan(); // Çıktı: BMW M5 hızlanıyor.

$mercedes = new Araba();
$mercedes->marka = 'Mercedes';
$mercedes->model = 'C200';
$mercedes->renk = 'Beyaz';

echo $mercedes->frenYap(); // Çıktı: Mercedes C200 fren yapıyor.
?>

2. Özellikler (Properties) ve Metotlar (Methods)

Özellikler: Bir nesnenin durumunu veya verisini temsil eden değişkenlerdir. Yukarıdaki örnekte `marka`, `model` ve `renk` birer özelliktir.

Metotlar: Bir nesnenin yapabileceği eylemleri veya davranışları temsil eden fonksiyonlardır. `hizlan()` ve `frenYap()` birer metottur. Metotlar genellikle nesnenin özelliklerini manipüle eder veya o özelliklere göre işlemler yapar.

`$this` anahtar kelimesi, sınıf içindeki metotlardan sınıfın mevcut örneğine (nesnesine) erişmek için kullanılır. Örneğin, `$this->marka` mevcut nesnenin `marka` özelliğine erişir.

3. Kurucular (Constructors) ve Yıkıcılar (Destructors)

Kurucu Metot (__construct): Bir nesne oluşturulduğunda otomatik olarak çağrılan özel bir metottur. Genellikle nesnenin başlangıç durumunu ayarlamak ve özelliklere ilk değerlerini atamak için kullanılır.

Kod:

<?php
class Kisi {
    public $ad;
    public $yas;

    public function __construct($ad, $yas) {
        $this->ad = $ad;
        $this->yas = $yas;
        echo $this->ad . ' nesnesi oluşturuldu. \n';
    }

    public function bilgiVer() {
        return $this->ad . ' ' . $this->yas . ' yaşındadır.';
    }
}

$kisi1 = new Kisi('Ali', 30); // Çıktı: Ali nesnesi oluşturuldu.
echo $kisi1->bilgiVer(); // Çıktı: Ali 30 yaşındadır.
?>

Yıkıcı Metot (__destruct): Bir nesneye referans kalmadığında veya betik sonlandığında otomatik olarak çağrılan özel bir metottur. Genellikle kaynakları (dosya bağlantıları, veritabanı bağlantıları vb.) serbest bırakmak için kullanılır.

Kod:

<?php
class Baglanti {
    public $kaynak;

    public function __construct($kaynak) {
        $this->kaynak = $kaynak;
        echo $this->kaynak . ' bağlantısı kuruldu.\n';
    }

    public function __destruct() {
        echo $this->kaynak . ' bağlantısı kapatıldı.\n';
    }
}

$db = new Baglanti('Veritabanı'); // Çıktı: Veritabanı bağlantısı kuruldu.
// ... İşlemler ...
unset($db); // Çıktı: Veritabanı bağlantısı kapatıldı. (veya betik sonlandığında)
?>

4. Görünürlük (Visibility - Erişim Belirleyiciler)

PHP'de özelliklere ve metotlara erişimi kontrol etmek için üç temel görünürlük belirleyicisi vardır:

public: Her yerden erişilebilir (sınıf içinden, miras alan sınıflardan, sınıf dışından).
protected: Sadece sınıfın kendisi ve miras alan (alt) sınıflar tarafından erişilebilir.
private: Sadece sınıfın kendisi tarafından erişilebilir. Miras alan sınıflar bile erişemez.

Kod:

<?php
class Urun {
    public $adi;
    protected $fiyat;
    private $kod;

    public function __construct($adi, $fiyat, $kod) {
        $this->adi = $adi;
        $this->fiyat = $fiyat;
        $this->kod = $kod;
    }

    public function getFiyat() {
        return $this->fiyat;
    }

    private function getKod() {
        return $this->kod;
    }

    public function urunBilgisi() {
        return $this->adi . ' (Fiyat: ' . $this->getFiyat() . ', Kod: ' . $this->getKod() . ')';
    }
}

class DijitalUrun extends Urun {
    public function indirimliFiyat() {
        return $this->fiyat * 0.9; // protected'a erişim var
        // return $this->kod; // Hata verir: private'a erişim yok
    }
}

$kitap = new Urun('PHP Kitabı', 50, 'PHPKITAP001');
echo $kitap->adi; // Çıktı: PHP Kitabı (public)
// echo $kitap->fiyat; // Hata verir: protected
// echo $kitap->kod; // Hata verir: private
echo $kitap->urunBilgisi(); // Çıktı: PHP Kitabı (Fiyat: 50, Kod: PHPKITAP001)

$yazilim = new DijitalUrun('OOP Yazılım', 200, 'OOPYAZILIM001');
echo $yazilim->indirimliFiyat(); // Çıktı: 180
?>

5. Kalıtım (Inheritance)

Kalıtım, bir sınıfın (alt sınıf/child class) başka bir sınıfın (üst sınıf/parent class) özelliklerini ve metotlarını miras almasını sağlar. Bu, kod tekrarını azaltır ve hiyerarşik bir yapı oluşturulmasına olanak tanır. PHP'de `extends` anahtar kelimesi ile kalıtım sağlanır.

Kod:

<?php
class Hayvan {
    protected $tur;

    public function __construct($tur) {
        $this->tur = $tur;
    }

    public function yemekYe() {
        return $this->tur . ' yemek yiyor.';
    }
}

class Kopek extends Hayvan {
    public function havla() {
        return 'Hav hav!';
    }

    // Üst sınıf metodunu geçersiz kılma (override)
    public function yemekYe() {
        return $this->tur . ' kemik kemiriyor.';
    }
}

class Kedi extends Hayvan {
    public function miyavla() {
        return 'Miyav miyav!';
    }
}

$kopek = new Kopek('Köpek');
echo $kopek->yemekYe(); // Çıktı: Köpek kemik kemiriyor.
echo $kopek->havla(); // Çıktı: Hav hav!

$kedi = new Kedi('Kedi');
echo $kedi->yemekYe(); // Çıktı: Kedi yemek yiyor.
echo $kedi->miyavla(); // Çıktı: Miyav miyav!
?>

6. Çok Biçimlilik (Polymorphism)

Çok biçimlilik, farklı sınıflardan gelen nesnelerin aynı arayüz üzerinden farklı şekillerde davranabilmesidir. Yani, aynı metodu çağırdığınızda, nesnenin tipine göre farklı çıktılar alabilirsiniz. Kalıtım ve arayüzler (interfaces) çok biçimliliğin temelini oluşturur.

Kod:

<?php
interface Sekil {
    public function alanHesapla();
}

class Kare implements Sekil {
    public $kenar;

    public function __construct($kenar) {
        $this->kenar = $kenar;
    }

    public function alanHesapla() {
        return $this->kenar * $this->kenar;
    }
}

class Daire implements Sekil {
    public $yaricap;

    public function __construct($yaricap) {
        $this->yaricap = $yaricap;
    }

    public function alanHesapla() {
        return M_PI * $this->yaricap * $this->yaricap;
    }
}

function sekilBilgisi(Sekil $sekil) {
    return 'Şeklin alanı: ' . $sekil->alanHesapla() . '\n';
}

$kare = new Kare(5);
$daire = new Daire(3);

echo sekilBilgisi($kare); // Çıktı: Şeklin alanı: 25
echo sekilBilgisi($daire); // Çıktı: Şeklin alanı: 28.27... (yaklaşık)
?>

7. Soyut Sınıflar (Abstract Classes) ve Arayüzler (Interfaces)

Soyut Sınıflar: En az bir soyut metot içeren ve doğrudan nesnesi oluşturulamayan sınıflardır. `abstract` anahtar kelimesi ile tanımlanır. Soyut metotlar, alt sınıflar tarafından uygulanması zorunlu olan metotlardır. Soyut sınıflar, genellikle bir grup ilişkili sınıf için ortak bir iskelet sağlar.

Kod:

<?php
abstract class Cihaz {
    public $marka;

    public function __construct($marka) {
        $this->marka = $marka;
    }

    abstract public function ac();
    abstract public function kapat();

    public function bilgiVer() {
        return $this->marka . ' marka cihaz.';
    }
}

class Telefon extends Cihaz {
    public function ac() {
        return $this->marka . ' telefon açılıyor.';
    }

    public function kapat() {
        return $this->marka . ' telefon kapanıyor.';
    }
}

$iphone = new Telefon('Apple');
echo $iphone->ac();
?>

Arayüzler: Sadece metot imzalarını (parametreleri ve dönüş tipleri) tanımlayan, ancak metot gövdelerini içermeyen yapılardır. `interface` anahtar kelimesi ile tanımlanır. Bir sınıf bir arayüzü `implements` ettiğinde, o arayüzdeki tüm metotları kendi içinde tanımlamak zorundadır. PHP'de bir sınıf birden fazla arayüzü implement edebilir (çoklu kalıtımın yerini tutar).

Kod:

<?php
interface Yuklenebilir {
    public function yukle();
}

interface Calistirilebilir {
    public function calistir();
}

class Uygulama implements Yuklenebilir, Calistirilebilir {
    public function yukle() {
        return 'Uygulama indiriliyor...';
    }

    public function calistir() {
        return 'Uygulama başlatılıyor...';
    }
}

$myApp = new Uygulama();
echo $myApp->yukle();
echo $myApp->calistir();
?>

8. Trait'ler

PHP, tekli kalıtımı destekler; yani bir sınıf sadece tek bir sınıftan miras alabilir. Ancak bazen farklı sınıflarda aynı metot veya özellik setini kullanma ihtiyacı doğar. İşte bu noktada Trait'ler devreye girer. Trait'ler, metot gruplarını sınıflara eklemek için esnek bir mekanizma sunar. `use` anahtar kelimesi ile sınıfa dahil edilirler.

Kod:

<?php
trait Loglama {
    public function logla($mesaj) {
        return '[' . date('Y-m-d H:i:s') . '] ' . $mesaj . '\n';
    }
}

class Kullanici {
    use Loglama;
    public $ad;

    public function __construct($ad) {
        $this->ad = $ad;
    }

    public function kaydet() {
        return $this->logla($this->ad . ' kaydedildi.');
    }
}

class UrunYonetimi {
    use Loglama;

    public function sil($urunAdi) {
        return $this->logla($urunAdi . ' silindi.');
    }
}

$user = new Kullanici('Mehmet');
echo $user->kaydet();

$product = new UrunYonetimi();
echo $product->sil('Laptop');
?>

9. İsim Alanları (Namespaces)

İsim alanları, aynı isimdeki sınıfların, fonksiyonların veya sabitlerin çakışmasını önlemek için kullanılır. Özellikle büyük projelerde veya üçüncü taraf kütüphanelerle çalışırken çok önemlidir. Bir nevi dosya sistemindeki klasörlere benzerler; kodunuzu mantıksal gruplara ayırmanıza yardımcı olurlar.

Kod:

<?php
namespace App\Models;

class Kullanici {
    public function selamla() {
        return 'Merhaba, ben bir App\Models\Kullanici nesnesiyim.';
    }
}

namespace App\Controllers;

use App\Models\Kullanici as UserModel;

class KullaniciController {
    public function goster() {
        $user = new UserModel();
        return $user->selamla();
    }
}

$controller = new App\Controllers\KullaniciController();
echo $controller->goster(); // Çıktı: Merhaba, ben bir App\Models\Kullanici nesnesiyim.
?>

10. Statik Özellikler ve Metotlar

Statik özellikler ve metotlar, bir sınıfın nesnesi oluşturulmadan doğrudan sınıfın kendisi üzerinden erişilebilen özellikler ve metotlardır. `static` anahtar kelimesi ile tanımlanır ve `self::` veya `ClassName::` ile erişilir. Genellikle yardımcı fonksiyonlar veya sınıfın tüm örnekleri için geçerli olan ortak verileri tutmak için kullanılırlar.

Kod:

<?php
class Ayarlar {
    public static $siteAdi = 'Benim Web Sitem';

    public static function getSiteAdi() {
        return self::$siteAdi;
    }

    public static function setSiteAdi($yeniAd) {
        self::$siteAdi = $yeniAd;
    }
}

echo Ayarlar::$siteAdi; // Çıktı: Benim Web Sitem
Ayarlar::setSiteAdi('Yeni Site Adı');
echo Ayarlar::getSiteAdi(); // Çıktı: Yeni Site Adı
?>

11. Sihirli Metotlar (Magic Methods)

PHP'de `__` (iki alt çizgi) ile başlayan özel metotlara sihirli metotlar denir. Bu metotlar, belirli olaylar tetiklendiğinde otomatik olarak çağrılır ve OOP'de esneklik sağlar. Daha önce gördüğümüz `__construct` ve `__destruct` da birer sihirli metottur. Diğer bazı önemli sihirli metotlar:

__get($name): Tanımlanmamış veya erişilemeyen bir özelliğe erişmeye çalışıldığında çağrılır.
__set($name, $value): Tanımlanmamış veya erişilemeyen bir özelliğe değer atamaya çalışıldığında çağrılır.
__call($name, $arguments): Tanımlanmamış veya erişilemeyen bir metot çağrıldığında çağrılır.
__toString(): Bir nesne string'e dönüştürülmeye çalışıldığında çağrılır. (örneğin `echo $nesne;`)
__sleep(): `serialize()` metodu çağrıldığında nesnenin hangi özelliklerinin saklanacağını belirler.
__wakeup(): `unserialize()` metodu çağrıldığında nesneyi yeniden yapılandırır.

Kod:

<?php
class VeriSaklama {
    private $data = [];

    public function __get($name) {
        if (array_key_exists($name, $this->data)) {
            return $this->data[$name];
        } else {
            trigger_error('Özellik ' . $name . ' bulunamadı.', E_USER_WARNING);
            return null;
        }
    }

    public function __set($name, $value) {
        $this->data[$name] = $value;
    }

    public function __toString() {
        return 'Bu bir VeriSaklama nesnesidir. İçerik: ' . json_encode($this->data);
    }
}

$depo = new VeriSaklama();
$depo->isim = 'Deneme';
$depo->yas = 42;

echo $depo->isim; // Çıktı: Deneme
echo $depo; // Çıktı: Bu bir VeriSaklama nesnesidir. İçerik: {"isim":"Deneme","yas":42}
?>

12. Kapsülleme (Encapsulation)

Kapsülleme, bir nesnenin iç durumunu (özelliklerini) dışarıdan doğrudan erişime kapatarak, bu duruma sadece nesnenin kendi metotları aracılığıyla kontrollü bir şekilde erişilmesini sağlama prensibidir. Bu, veri bütünlüğünü korur ve kodun daha güvenli ve tutarlı olmasını sağlar. Genellikle `private` veya `protected` erişim belirleyicileri kullanılarak ve bu özelliklere erişim için `getter` ve `setter` metotları (erişimci ve değiştirici metotlar) tanımlanarak uygulanır.

Kod:

<?php
class BankaHesabi {
    private $bakiye; // Dışarıdan doğrudan erişim engellendi

    public function __construct($ilkBakiye) {
        if ($ilkBakiye >= 0) {
            $this->bakiye = $ilkBakiye;
        } else {
            $this->bakiye = 0;
            trigger_error('İlk bakiye negatif olamaz, sıfır olarak ayarlandı.', E_USER_WARNING);
        }
    }

    // Getter metot
    public function getBakiye() {
        return $this->bakiye;
    }

    // Setter metot
    public function paraYatir($miktar) {
        if ($miktar > 0) {
            $this->bakiye += $miktar;
            return true;
        }
        return false;
    }

    public function paraCek($miktar) {
        if ($miktar > 0 && $this->bakiye >= $miktar) {
            $this->bakiye -= $miktar;
            return true;
        }
        return false;
    }
}

$hesap = new BankaHesabi(1000);
echo 'Başlangıç bakiyesi: ' . $hesap->getBakiye() . '\n';

$hesap->paraYatir(500);
echo 'Yatırım sonrası bakiye: ' . $hesap->getBakiye() . '\n';

$hesap->paraCek(200);
echo 'Çekim sonrası bakiye: ' . $hesap->getBakiye() . '\n';

$hesap->paraCek(2000); // Bakiye yetersiz
echo 'Yetersiz çekim sonrası bakiye: ' . $hesap->getBakiye() . '\n';

// $hesap->bakiye = -500; // Hata verir veya doğrudan erişimi engelleriz
?>

13. İstisna Yönetimi (Exception Handling)

PHP'de hata durumlarını daha düzenli ve OOP prensiplerine uygun bir şekilde yönetmek için istisnalar (exceptions) kullanılır. Bir hata oluştuğunda normal akışı kesmek ve bu hatayı belirli bir kod bloğunda yakalayıp işlemek için `try-catch-finally` blokları kullanılır.

Kod:

<?php
function bolme($bolunen, $bolen) {
    if ($bolen === 0) {
        throw new Exception('Sıfıra bölme hatası!');
    }
    return $bolunen / $bolen;
}

try {
    echo bolme(10, 2) . '\n';
    echo bolme(5, 0) . '\n'; // Hata fırlatılacak, sonraki satır çalışmayacak
    echo bolme(20, 4) . '\n';
} catch (Exception $e) {
    echo 'Hata yakalandı: ' . $e->getMessage() . '\n';
} finally {
    echo 'İşlem tamamlandı (hata olsun veya olmasın).\n';
}

// Kendi özel istisna sınıfınızı oluşturma
class GecersizMiktarException extends Exception {}

function miktarKontrol($miktar) {
    if ($miktar <= 0) {
        throw new GecersizMiktarException('Miktar sıfırdan büyük olmalı.');
    }
    return 'Miktar geçerli: ' . $miktar;
}

try {
    echo miktarKontrol(100) . '\n';
    echo miktarKontrol(-5) . '\n';
} catch (GecersizMiktarException $e) {
    echo 'Özel Hata: ' . $e->getMessage() . '\n';
} catch (Exception $e) {
    echo 'Genel Hata: ' . $e->getMessage() . '\n';
}
?>

"İyi tasarım, sadece bir şeyin iyi görünmesini sağlamakla kalmaz, aynı zamanda iyi çalışmasını da sağlar." - Steve Jobs

Sonuç

PHP'de Nesne Yönelimli Programlama, modern ve ölçeklenebilir uygulamalar geliştirmek için vazgeçilmez bir araçtır. Bu rehberde, sınıflar ve nesnelerden başlayarak kalıtım, çok biçimlilik, soyut sınıflar, arayüzler, trait'ler, isim alanları, statik elemanlar, sihirli metotlar, kapsülleme ve istisna yönetimi gibi önemli OOP kavramlarını inceledik. Bu prensipleri uygulamak, daha temiz, anlaşılır, bakımı kolay ve yeniden kullanılabilir kod yazmanıza yardımcı olacaktır. PHP ekosistemindeki popüler framework'lerin tamamı OOP üzerine inşa edildiği için, bu konulara hakim olmak profesyonel PHP geliştiriciliği kariyerinizde size büyük avantaj sağlayacaktır. Bol pratik yaparak bu konuları pekiştirmenizi şiddetle tavsiye ederiz. Daha fazla bilgi ve örnek için PHP resmi dokümantasyonuna başvurabilirsiniz.

Umarız bu kapsamlı rehber, PHP'de Nesne Yönelimli Programlama bilginizi derinleştirmenize yardımcı olmuştur.