• Şuradasınız
  • Anasayfa
  • PHP
  • PHP : Sınıf, Nesne Kavramları ve Sarmalama

PHP : Sınıf, Nesne Kavramları ve Sarmalama

Nesneye yönelik programlamada bir sınıf modeli ve bu sınıfı örnek alan nesneler mevcuttur. Yani sınıflar nesneler için birer şablon niteliğindedir.

Sınıflar, eleman sahalardan ve eleman fonksiyonlardan oluşurlar. Daha basit bir deyişle, değişkenlerden ve fonksiyonlardan oluşan bir pakettir. Eleman sahalara ve eleman fonksiyonlara genel olarak sınıfın elemanları diyebiliriz.

Basit bir sınıf örneğini şu şekilde gösterebiliriz;

class uye {
	/* Eleman sahalar */
	public $kullaniciAdi;
	protected $mailAdresi;
	private $sifre;
	/* Eleman fonksiyonlar */
	public function uyeKaydet() { /* Fonksiyonun içeriği */ }
	public function uyeGoster() { /* Fonksiyonun içeriği */ }
}

Gördüğünüz gibi sınıf 3 adet eleman sahadan ve 2 adet eleman fonksiyondan oluşuyor.

Her eleman; public, protected veya private olabilen birer erişim belirtecine sahiptir. Buna daha sonra bakarız.

Nesne yaratma ve this operatörü

Yukarıdaki sınıfı biraz daha geliştirelim.

class uye {
	public $kullaniciAdi;
	protected $mailAdresi;
	private $sifre;
	public function uyeKaydet($a, $b, $c) {
		$this->kullaniciAdi = $a;
		$this->mailAdresi = $b;
		$this->sifre = $c;
	}
	public function uyeGoster() {
		echo "Kullanıcı Adı : " . $this->kullaniciAdi . "<br/>";
		echo "Mail Adresi : " . $this->mailAdresi . "<br/>";
		echo "Şifre : " . $this->sifre . "<br/><br/>";
	}
}

Burada this operatörüne bir parantez açmamız gerekebilir. this operatörü, bir sınıf içinde işlem yaparken o sınıfın eleman sahalarına veya eleman fonksiyonlarına erişmek için kullanılan bir işaretçidir.

Şimdi de new operatörü ile bir nesne üretelim ve o nesnenin eleman sahaları üzerinde, eleman fonksiyonlar yardımıyla işlem yapalım.

$nesne = new uye();
$nesne->uyeKaydet("cem", "cem@hotmail.com", 10910);
$nesne->uyeGoster();

Nesneye yönelik programlamada genel olarak, eleman fonksiyonlar yardımıyla eleman sahalar üzerinde işlem yapılmaktadır.

Sarmalama ve Erişim metodları

Nesneye yönelik programlamanın en önemli esaslarından birisi olan sarmalama, adında da anlaşılacağı gibi, erişim belirteçleri ile sınıf elemanlarını korumayı gerektirir. Bu işlemin yegane amacı güvenliktir.

public $kullaniciAdi;
protected $mailAdresi;
private $sifre;

Yukarıdaki sınıf için konuşursak;

$a = new uye();
$a->kullaniciAdi = "cem";
echo $a->kullaniciAdi;

Bu kod bloğu ekrana “cem” yazacaktır. Fakat aşağıdaki kod bloğu hata verir;

$a = new uye();
$a->sifre = 10910;
echo $a->sifre;

Aradaki tek fark ise erişim yöntemidir. private olarak tanımlanmış eleman sahalara sınıfın dışından erişmek mümkün değildir.

Erişim belirteci Açıklama
public programın her yerinden erişilebilir
protected sınıf içerisinden veya türetilmiş sınıflar üzerinden erişilebilir
private sadece sınıf içerisinden erişilebilir

private ve protected belirteçleri, bir sınıfa ait elemanlara sınıf dışından erişmeyi engeller. Doğal olarak bu elemanlara sınıf içerisinde erişmek gerekir.

Yukarıdaki sınıfta $sifre değişkeni private olarak tanımlandığı için, o sınıf içerisindeki bir başka eleman olan uyeKaydet fonksiyonu yardımıyla atama işlemi yapılmıştır.

Şimdi yukarıdaki sınıfa private olarak tanımlanmış aşağıdaki fonksiyonu ekleyelim;

private function uyeDegistir() {
	$this->kullaniciAdi .= " - xx";
	$this->mailAdresi .= " - xx";
	$this->sifre .= " - 00";
}

Sonra da bu fonksiyona bir nesne üzerinden erişmeye çalışalım;

$nesne = new uye();
$nesne->uyeKaydet("cem", "cem@hotmail.com", 10911);
$nesne->uyeDegistir();
$nesne->uyeGoster();

Yukarıdaki kod uyeDegistir fonksiyonunun private olarak tanımlanmasından kaynaklı olarak hata verecektir. Dolayısıyla private fonksiyona erişmek için sınıf içerisinde puclic olarak tanımlanmış bir başka fonksiyon kullanmalıyız.

public function uyeGuncelle() {
	$this->uyeDegistir();
}

Bu işleme genel olarak sarmalama adı verilmektedir. Hem eleman sahalar, hem de eleman fonksiyonlar sarmalanarak dışarıdan erişime kapatılabilir.

Yapıcı ve yıkıcı fonksiyonlar

Bir nesne yaratıldığında herşeyden önce yapıcı fonksiyon çağrılır. Genellikle sınıfın yapması gereken ilk işlemler bu fonksiyon içerisinde tanımlanır.

Mesela yukarıdaki sınıfı biraz daha geliştirerek, yapıcı fonksiyon yardımıyla değişkenlere ilk değer ataması yapalım.

public function __construct() {
	$this->kullaniciAdi = "Default";
	$this->mailAdresi = "None";
	$this->sifre = "Password";
}

Bir nesne oluşturup uyeKaydet fonksiyonunu kullanmaksızın, uyeGoster fonksiyonunu çağırırsak yapıcı fonksiyon ile yaptığımız ilk değer atamaları gösterilecektir.

$nesne = new uye();
$nesne->uyeGoster();

Yıkıcı fonkiyon ise bir nesne ile yapılacak işler bittiğinde veya nesne yok edildiğinde otomatik olarak çağrılan metoddur.

public function __desturct() {
	/* Yıkıcı fonksiyon */
}

Kapsama operatörü

Kapsama operatörü, bir sınıfın public elemanlarına sınıf içinden veya nesne yaratmadan sınıf dışından erişebilmeyi sağlayan bir operatördür.

Sınıfa bir helloWorld fonksiyonu ekleyelim ve kapsama operatörü ile nesne yaratmadan bu fonksiyonu çağıralım.

/* Hello world fonksiyonu*/
public static function helloWorld() {
	echo "Hello World";
}
/* Kapsama operatörü */
uye::helloWorld();

Sınıf sabitleri, self ve parent seçicileri

Sınıf sabitleri, define fonsiyonu ile tanımlanan sabitlere benzemektedir. const anahtar kelimesiyle tanımlanır ve bir kez tanımlandıktan sonra içeriği değişmez.

Sınıfımızı biraz daha geliştirerek, const olan yeni eleman sahalar ekleyelim ve __construct fonksiyonunda biraz değişiklik yapalım.

/* Yeni eleman sahalar - Sınıf sabitleri */
const VARSAYILAN_K_A = "Default";
const VARSAYILAN_M_A = "None";
const VARSAYILAN_SIFRE = "Password";
/* Yeni yapıcı fonksiyon */
public function __construct() {
	$this->kullaniciAdi = uye::VARSAYILAN_K_A;
	$this->mailAdresi = self::VARSAYILAN_M_A;
	$this->sifre = uye::VARSAYILAN_SIFRE;
}

Yapıcı fonksiyon yine ilk değer ataması yapıyor, fakat bu sefer sınıf sabitlerini kullanıyor. Sınıf sabitlerine ulaşmak için kapsama operatörü (::) kullanıldı.

Sınıf sabitlerine sınıfın içinde erişmek için sınıf ismi yerine self seçicisini de kullanabilirsiniz. Türetilmiş bir sınıftayken ise o türetilen sınıfın sabitlerine erişmek için parent seçicisini kullanabilirsiniz. Yani self ve parent seçicileri, “bu sınıftaki” gibi bir anlama gelmektedir.

Ayrıca sınıf sabitlerine aşağıdaki gibi bir nesne üzerinden erişilemez;

$nesne = new uye();
echo $nesne->VARSAYILAN_K_A; // Yanlış - Nesne üzerinden erişilemez
echo uye::VARSAYILAN_K_A; // Doğru - Nesne kullanmadan erişilir

Static değişkenler

Static elemanlar, const elemanlar gibi nesne kullanmadan erişilmesi gereken elemanlardır. Fakat const elemanların aksine içeriği değişkendir.

Sınıfımıza, oluşturulan nesne sayısını yani üye sayısını tutan bir static değişken ekleyelim. Amaç, her nesne oluşturulduğunda static değişkenin içeriğini 1 arttırarak yaratılan nesne sayısını bulmaktır.

Bunu yapmanın en iyi yolu ise static nesneyi yapıcı fonksiyonun içerisinde arttırmaktır. Dolayısıyla her nesne oluşturmada static değişken otomatik olarak 1 arttırılacaktır.

/* Static değişken */
public static $uyeSayisi = 0;
/* Yapıcı fonksiyon */
public function __construct() {
	self::$uyeSayisi++; // Static değişken 1 arttırıldı
	$this->kullaniciAdi = uye::VARSAYILAN_K_A;
	$this->mailAdresi = self::VARSAYILAN_M_A;
	$this->sifre = uye::VARSAYILAN_SIFRE;
}

Şimdi 3 adet nesne oluşturup, static değişkenin içeriğinin nasıl değiştiğine bakalım;

$nesne1 = new uye();
$nesne2 = new uye();
$nesne3 = new uye();
echo uye::$uyeSayisi; // 3 çıktısını verecektir.

Static değişkenlere, nesne üzerinden erişilemez. Dolayısıyla “->” işareti ile kullanılamaz.

Fonksiyonlarda static olabilir fakat static bir fonksiyonun içerisinde static olmayan bir değişkene erişemezsiniz.

Son olarak

Yazı oldukça uzun oldu, bunun için kusuruma bakmayın. :)

Ayrıca, kullandığım terimler konusunda (eleman saha, eleman fonksiyon, değişken vs.) bir açıklama yapmak istiyorum. Herkes farklı bir terim kullanıyor fakat işin içine sınıflar girince değişkenler, eleman sahalar veya sınıf özellikleri, fonksiyonlar ise eleman fonksiyon veya method olarak isimlendiriliyor. Eğer kafa karıştırıyorsa değişken ve fonksiyon olarak isimlendirmekte hiçbir sakınca yoktur diye düşünüyorum.

Son olarak bu yazıda yazdığımız sınıfa buradan erişebilirsiniz.

Benzer Yazılar

Yorumlar

  • hakan , 23 Mayıs 2013 - 21:18:43

    tebrik ederim çok güzel ve yalın bir anlatım olmuş ayrıca web siteniz çok iyi…

    Cevapla
  • Necati Yılmaz , 24 Ağustos 2013 - 02:35:00

    Çok güzel bir makale olmuş, teşekkürler.

    Cevapla
  • ahmet , 19 Ekim 2013 - 12:16:14

    Merhaba anlatim güzel olmuş teşekkürler fakat sormak istediğim bir. Konu var.

    Class BLogZ {
        Public function blog_listeler()
        {
            Global $db;
            $sorgu = $db -> query(vs vs);
        }
    }
    

    Örnek yukarıda ki sorgunun dosyasi blog.class.PHP
    Bunu blog.anasayfa.PHP dosyama include ettim
    Buradaki $sorgu yu blog.anasayfa.PHP
    Cekemiyorum cektigimde gelen veriyi dondurcem
    Bunu class icindede yapiyorum fakat tasarim acisindan ana sayfa blog dosyasina cekmem geewkiyor tek tek verileri içinden alamiyorum

    Cevapla
    • Cem Demir , 19 Ekim 2013 - 13:33:37

      Merhaba,
      blog.class.php adlı dosyada $sorgu değişkenine erişebilmek için BLogZ sınıfından bir nesne türetmeniz gerekiyor.

      $nesne = new BlogZ;
      $nesne->blog_listeler;
      

      Eğer amacınız $sorgu değişkenini alıp kullanmaksa, fonksiyonun içinde $sorgu değişkenini döndürmeniz de gerekecektir.

      return $sorgu;
      
      Cevapla
      • ahmet , 19 Ekim 2013 - 15:47:59

        Tesekkur ederim sorunu cozdum
        Soylediginiz gibi return $sorgu; yaptim

        $blogz = blogz();
        $listele = blogz-> blog_listeler();
        foreach ($listele as $veri ){
            echo $veri->baslik;
        }
        

        Yaptim sorunum çözüldü
        Kirlilik yapmak istemiyorum fakat bir şey farkettim opencart isimli acik kaynak e-ticaret scripti var onu inceledim yazar öyle yazmiski değişkenleri istediği gibi istediği yerde kullanıyor benim gibin new blogz filan işlemler yapmiyor. Bilginiz varsa beni aydinlata bilirseniz sevinirim.

        Not; tel yaziyorum yazim hatalari için kusura bakmayin.

        Cevapla
        • Cem Demir , 19 Ekim 2013 - 18:48:20

          Eğer değişkenleri bir nesne yaratmadan (new kullanmadan) kullanmak istiyosanız onları static olarak tanımlamalısınız. Bu yazının sonlarında nasıl kullanabileceğinizi bulabilirsiniz.

        • ahmet , 19 Ekim 2013 - 21:56:05

          Konuyu bastan sona inceledim onun yaptigi statik değildi statin sinif oluşturmadan rahatlıkla çeke biliyordu sanirim bunun için ayri bir sistem yazmis incelemeye koyuldum cok ilgimi çekti 4saatir inceliyorum

  • Mert Aslan , 05 Temmuz 2014 - 12:46:30

    Kapsama operatörünü hatalı yazmışsınız.

    Nesne yaratmadan fonksiyonlara erişim static anahtar sözcüğünü kullanmanız gereklidir.

    public static function helloWorld() {
        echo "Hello World";
    }
    uye::helloWorld();
    
    Cevapla

Yorum Yazın

Su elementleri kullanabilirsiniz : <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong>

Arama
RSS
Beni yukari isinla