PHP'de Nesne Yönelimli Programlama

[Carissa]

ROHAN2 WORLD 1-120 TR TİPİ OFFICIAL YOHARA, BALATHOR VE AMON! 80. GÜNÜNDE! +10.000 ONLİNE! HİLE VE BOT %100 ENGELLİ HEMEN TIKLA!

Evrenimizi güneş, dünya, ay vb. gibi farklı nesnelerden oluşmuş olarak hayal edebiliriz. Benzer şekilde arabamızı da tekerlek, direksiyon, vites vb. gibi farklı nesnelerden oluşmuş olarak hayal edebiliriz. Aynı şekilde her şeyi bir nesne olarak varsayan ve farklı nesneler kullanarak bir yazılım uygulayan nesne yönelimli programlama kavramları da vardır.

Nesne Yönelimli Kavramlar​

Detaylara girmeden önce Nesne Yönelimli Programlama ile ilgili önemli terimleri tanımlayalım.

• Sınıf − Bu, yerel işlevlerin yanı sıra yerel verileri de içeren programcı tarafından tanımlanan bir veri türüdür. Bir sınıfı, nesnenin aynı türünün (veya sınıfının) birçok örneğini oluşturmak için bir şablon olarak düşünebilirsiniz.
• Nesne − Bir sınıf tarafından tanımlanan veri yapısının bireysel bir örneği. Bir sınıfı bir kez tanımlarsınız ve sonra ona ait birçok nesne yaparsınız. Nesneler örnek olarak da bilinir.
• Üye Değişkeni − Bunlar bir sınıfın içinde tanımlanan değişkenlerdir. Bu veriler sınıfın dışından görülemez ve üye fonksiyonları aracılığıyla erişilebilir. Bu değişkenler, bir nesne oluşturulduğunda nesnenin niteliği olarak adlandırılır.
• Üye fonksiyonu − Bunlar bir sınıfın içinde tanımlanan ve nesne verilerine erişmek için kullanılan fonksiyonlardır.
• Kalıtım − Bir sınıf, bir ebeveyn sınıfının mevcut fonksiyonunu miras alarak tanımlandığında buna kalıtım denir. Burada çocuk sınıf, bir ebeveyn sınıfının tüm veya birkaç üye fonksiyonunu ve değişkenini miras alacaktır.
• Üst sınıf − Başka bir sınıf tarafından miras alınan sınıf. Buna temel sınıf veya üst sınıf da denir.
• Çocuk Sınıfı − Başka bir sınıftan miras alan bir sınıf. Buna alt sınıf veya türetilmiş sınıf da denir.
• Çok biçimlilik − Bu, aynı işlevin farklı amaçlar için kullanılabileceği nesne yönelimli bir kavramdır. Örneğin, işlev adı aynı kalır ancak farklı sayıda argüman alır ve farklı görevler yapabilir.
• Aşırı yükleme − bazı veya tüm operatörlerin argümanlarının türlerine bağlı olarak farklı uygulamalara sahip olduğu bir polimorfizm türü. Benzer şekilde işlevler de farklı uygulamalarla aşırı yüklenebilir.
• Veri Soyutlaması − Uygulama ayrıntılarının gizlendiği (soyutlandığı) herhangi bir veri gösterimi.
• Kapsülleme − tüm verileri ve üye işlevleri bir nesne oluşturmak üzere bir araya getirdiğimiz bir kavramı ifade eder.
• Yapıcı − bir sınıftan nesne oluşumu olduğunda otomatik olarak çağrılacak özel bir fonksiyon türünü ifade eder.
• Yıkıcı − bir nesne silindiğinde veya kapsam dışına çıktığında otomatik olarak çağrılacak özel bir fonksiyon türünü ifade eder.

PHP Sınıflarını Tanımlama​

PHP'de yeni bir sınıf tanımlamanın genel biçimi aşağıdaki gibidir:

<?php
   class phpClass {
      var $var1;
      var $var2 = "constant string";
     
      function myfunc ($arg1, $arg2) {
         [..]
      }
      [..]
   }
?>

Her satırın açıklaması şöyledir:

• Özel form class, ardından tanımlamak istediğiniz sınıfın adı yazılır.
• Herhangi sayıda değişken bildirimi ve fonksiyon tanımını kapsayan bir küme parantezi.
• Değişken bildirimleri var özel biçimiyle başlar ve bunu geleneksel $ değişken adı izler; ayrıca sabit bir değere başlangıçta atanmaları da olabilir.
• Fonksiyon tanımları, bağımsız PHP fonksiyonlarına çok benzer ancak sınıfa özgüdür ve nesne verilerini ayarlamak ve bunlara erişmek için kullanılır.

Örnek​

İşte Books türünde bir sınıf tanımlayan bir örnek:

<?php
   class Books {
      /* Member variables */
      var $price;
      var $title;
     
      /* Member functions */
      function setPrice($par){
         $this->price = $par;
      }
     
      function getPrice(){
         echo $this->price ."<br/>";
      }
     
      function setTitle($par){
         $this->title = $par;
      }
     
      function getTitle(){
         echo $this->title ." <br/>";
      }
   }
?>

$this değişkeni özel bir değişkendir ve aynı nesneye, yani kendisine atıfta bulunur.

PHP'de Nesneler Oluşturma​

Sınıfınızı tanımladıktan sonra, o sınıf türünden istediğiniz kadar nesne yaratabilirsiniz. Aşağıda new operatörü kullanılarak nesne yaratmanın bir örneği verilmiştir.

$physics = new Books;
$maths = new Books;
$chemistry = new Books;

Burada üç nesne oluşturduk ve bu nesneler birbirinden bağımsızdır ve varlıkları ayrı ayrı olacaktır. Şimdi üye fonksiyona ve işlem üye değişkenlerine nasıl erişileceğini göreceğiz.

Üye Fonksiyonlarını Çağırma​

Nesnelerinizi oluşturduktan sonra, o nesneyle ilgili üye fonksiyonları çağırabileceksiniz. Bir üye fonksiyonu yalnızca ilgili nesnenin üye değişkenini işleyebilecektir.

Aşağıdaki örnek, üye fonksiyonlarını çağırarak üç kitap için başlık ve fiyatların nasıl ayarlanacağını göstermektedir.

$physics->setTitle( "Physics for High School" );
$chemistry->setTitle( "Advanced Chemistry" );
$maths->setTitle( "Algebra" );

$physics->setPrice( 10 );
$chemistry->setPrice( 15 );
$maths->setPrice( 7 );

Şimdi yukarıdaki örnekte ayarlanan değerleri almak için başka bir üye fonksiyonunu çağıracaksınız.

$physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();
$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();

Bu, aşağıdaki sonucu üretecektir:

Physics for High School
Advanced Chemistry
Algebra
10
15
7

Yapıcı Fonksiyonlar​

Yapıcı Fonksiyonlar, bir nesne oluşturulduğunda otomatik olarak çağrılan özel tipteki fonksiyonlardır. Bu nedenle, birçok şeyi yapıcı fonksiyonlar aracılığıyla başlatarak bu davranıştan tam olarak yararlanırız.

PHP, bir kurucu tanımlamak için __construct() adlı özel bir fonksiyon sağlar. Kurucu fonksiyonuna istediğiniz kadar argüman geçirebilirsiniz.

Aşağıdaki örnek, Books sınıfı için bir kurucu oluşturacak ve nesne oluşturma sırasında kitap için fiyat ve başlığı başlatacaktır.

function __construct( $par1, $par2 ) {
$this->title = $par1;
$this->price = $par2;
}

Artık fiyat ve başlığı ayarlamak için set fonksiyonunu ayrı ayrı çağırmamıza gerek yok. Bu iki üye değişkenini yalnızca nesne oluşturma sırasında başlatabiliriz. Aşağıdaki örneği inceleyin.

$physics = new Books( "Physics for High School", 10 );
$maths = new Books ( "Advanced Chemistry", 15 );
$chemistry = new Books ("Algebra", 7 );

/* Get those set values */
$physics->getTitle();
$chemistry->getTitle();
$maths->getTitle();

$physics->getPrice();
$chemistry->getPrice();
$maths->getPrice();

Bu, aşağıdaki sonucu üretecektir:

Physics for High School
Advanced Chemistry
Algebra
10
15
7

Yıkıcı​

Bir yapılandırıcı fonksiyon gibi, __destruct() fonksiyonunu kullanarak bir yıkıcı fonksiyon tanımlayabilirsiniz. Bir yıkıcı içindeki tüm kaynakları serbest bırakabilirsiniz.

Miras​

PHP sınıf tanımları, extends ifadesini kullanarak isteğe bağlı olarak bir üst sınıf tanımından miras alabilir. Sözdizimi aşağıdaki gibidir.

class Child extends Parent {
<definition body>
}

Mirasın etkisi, alt sınıfın (veya alt sınıfın ya da türetilmiş sınıfın) aşağıdaki özelliklere sahip olmasıdır:

• Otomatik olarak ana sınıfın tüm üye değişken bildirimlerini içerir.
• Otomatik olarak ebeveyn ile aynı üye işlevlerine sahiptir, bu da (varsayılan olarak) ebeveyndeki işlevlerin yaptığı şekilde çalışacaktır.

Aşağıdaki örnek Books sınıfını devralır ve gereksinime göre daha fazla işlevsellik ekler.

class Novel extends Books {
var $publisher;

function setPublisher($par){
$this->publisher = $par;
}

function getPublisher(){
echo $this->publisher. "<br />";
}
}

Artık miras alınan fonksiyonların dışında Novel sınıfı iki ek üye fonksiyonunu daha tutar.

İşlev Geçersiz Kılma​

Alt sınıflardaki fonksiyon tanımları, ebeveyn sınıflardaki aynı isimli tanımları geçersiz kılar. Bir alt sınıfta, ebeveyn sınıftan miras alınan bir fonksiyonun tanımını değiştirebiliriz.

Aşağıdaki örnekte getPrice ve getTitle fonksiyonları geçersiz kılınarak bazı değerler döndürülmüştür.

function getPrice() {
echo $this->price . "<br/>";
return $this->price;
}

function getTitle(){
echo $this->title . "<br/>";
return $this->title;
}

Kamu Üyeleri​

Aksi belirtilmediği sürece, bir sınıfın özellikleri ve yöntemleri herkese açıktır. Yani, bunlara üç olası durumda erişilebilir:

• Bildirildiği sınıfın dışından
• Bildirildiği sınıfın içinden
• Tanımlandığı sınıfı uygulayan başka bir sınıftan

Şimdiye kadar tüm üyeleri public üyeler olarak gördük. Bir sınıfın üyelerinin erişilebilirliğini sınırlamak istiyorsanız, sınıf üyelerini private veya protected olarak tanımlarsınız.

Özel üyeler​

Bir üyeyi private olarak belirleyerek, erişilebilirliğini bildirildiği sınıfla sınırlandırırsınız. Private üyeye, bildirildiği sınıfı miras alan sınıflardan başvurulamaz ve sınıfın dışından erişilemez.

Bir sınıf üyesi, üyenin önünde private anahtar sözcüğü kullanılarak gizli hale getirilebilir.

class MyClass {
private $car = "skoda";
$driver = "SRK";

function __construct($par) {

// Statements here run every time
// an instance of the class
// is created.
}

function myPublicFunction() {
return("I'm visible!");
}

private function myPrivateFunction() {
return("I'm not visible outside!");
}
}

MyClass sınıfı extends kullanan başka bir sınıf tarafından miras alındığında , myPublicFunction() görünür olacaktır, $driver da öyle. Genişleten sınıf, myPrivateFunction ve $car'ın herhangi bir farkındalığına veya erişimine sahip olmayacaktır, çünkü bunlar private olarak bildirilmiştir.

Korunan üyeler​

Korunan bir özellik veya yöntem, beyan edildiği sınıfta ve o sınıfı genişleten sınıflarda erişilebilirdir. Korunan üyeler, bu iki tür sınıfın dışında kullanılamaz. Bir sınıf üyesi, üyenin önünde protected anahtar sözcüğü kullanılarak korunan hale getirilebilir.

İşte MyClass'ın farklı bir versiyonu:

class MyClass {
protected $car = "skoda";
$driver = "SRK";

function __construct($par) {
// Statements here run every time
// an instance of the class
// is created.
}

function myPublicFunction() {
return("I'm visible!");
}

protected function myPrivateFunction() {
return("I'm visible in child class!");
}
}

Arayüzler​

Arayüzler, uygulayıcılara ortak bir işlev adı sağlamak için tanımlanır. Farklı uygulayıcılar, bu arayüzleri kendi gereksinimlerine göre uygulayabilir. Arayüzlerin, geliştiriciler tarafından uygulanan iskeletler olduğunu söyleyebilirsiniz.

PHP5'ten itibaren, şu şekilde bir arayüz tanımlamak mümkündür:

interface Mail {
public function sendMail();
}

Daha sonra, başka bir sınıf bu arayüzü şu şekilde uygularsa −

class Report implements Mail {
// sendMail() Definition goes here
}

Sabitler​

Bir sabit, bir değeri tutması bakımından bir değişkene benzer, ancak gerçekte daha çok bir fonksiyona benzer çünkü bir sabit değişmezdir. Bir sabiti bildirdiğinizde değişmez.

Bu MyClass sürümünde yapıldığı gibi, bir sabiti bildirmek kolaydır.

class MyClass {
const requiredMargin = 1.7;

function __construct($incomingValue) {

// Statements here run every time
// an instance of the class
// is created.
}
}

Bu sınıfta, requiredMargin bir sabittir. const anahtar sözcüğüyle bildirilir ve hiçbir koşulda 1.7'den başka bir şeye değiştirilemez. Sabitin adının, değişken adlarında olduğu gibi, önünde $ olmadığına dikkat edin.

Soyut Sınıflar​

Soyut bir sınıf, yalnızca miras alınabilen, örneklenemeyen bir sınıftır. Soyut bir sınıfı, abstract anahtar sözcüğüyle şu şekilde bildirirsiniz:

Soyut bir sınıftan miras alındığında, ebeveynin sınıf bildiriminde soyut olarak işaretlenen tüm metotlar çocuk tarafından tanımlanmalıdır; ayrıca, bu metotlar aynı görünürlükle tanımlanmalıdır.

abstract class MyAbstractClass {
abstract function myAbstractFunction() {
}
}

Soyut bir sınıfın içindeki fonksiyon tanımlarının da abstract anahtar sözcüğünden önce gelmesi gerektiğini unutmayın. Soyut olmayan bir sınıfın içinde soyut fonksiyon tanımlarının olması yasal değildir.

Statik Anahtar Kelime​

Sınıf üyelerini veya yöntemlerini statik olarak bildirmek, sınıfın bir örneklemesine ihtiyaç duymadan erişilebilir hale getirir. Statik olarak bildirilen bir üyeye, örnekleme yapılmış bir sınıf nesnesiyle erişilemez (ancak statik bir yöntem erişilebilir).

Aşağıdaki örneği deneyin.

<?php
   class Foo {
      public static $my_static = 'foo';
     
      public function staticValue() {
         return self::$my_static;
      }
   }
   
   print Foo::$my_static . "\n";
   $foo = new Foo();
 
   print $foo->staticValue() . "\n";
?>

Son Anahtar Kelime​

PHP 5, final anahtar sözcüğünü tanıtır, bu da alt sınıfların tanımı final ile önekleyerek bir yöntemi geçersiz kılmasını önler. Sınıfın kendisi final olarak tanımlanıyorsa, genişletilemez.

Aşağıdaki örnek Ölümcül hatayla sonuçlanır: Son yöntem BaseClass::moreTesting() geçersiz kılınamaz.

<?php

   class BaseClass {
      public function test() {
         echo "BaseClass::test() called<br>";
      }
     
      final public function moreTesting() {
         echo "BaseClass::moreTesting() called<br>";
      }
   }
 
   class ChildClass extends BaseClass {
      public function moreTesting() {
         echo "ChildClass::moreTesting() called<br>";
      }
   }
?>

Üst yapılandırıcıları çağırma​

Alt sınıf için tamamen yeni bir kurucu yazmak yerine, bunu ebeveynin kurucusunu açıkça çağırarak ve ardından alt sınıfın örneklenmesi için ek olarak gereken her şeyi yaparak yazalım. İşte basit bir örnek:

class Name {
   var $_firstName;
   var $_lastName;
 
   function Name($first_name, $last_name) {
      $this->_firstName = $first_name;
      $this->_lastName = $last_name;
   }
 
   function toString() {
      return($this->_lastName .", " .$this->_firstName);
   }
}
class NameSub1 extends Name {
   var $_middleInitial;
 
   function NameSub1($first_name, $middle_initial, $last_name) {
      Name::Name($first_name, $last_name);
      $this->_middleInitial = $middle_initial;
   }
 
   function toString() {
      return(Name::toString() . " " . $this->_middleInitial);
   }
}

Bu örnekte, iki argümanlı bir oluşturucuya sahip bir ana sınıfımız (Name) ve üç argümanlı bir oluşturucuya sahip bir alt sınıfımız (NameSub1) var. NameSub1'in oluşturucusu, ana oluşturucusunu açıkça :: sözdizimini kullanarak (iki argümanını ileterek) çağırarak ve ardından ek bir alan ayarlayarak işlev görür. Benzer şekilde, NameSub1, geçersiz kıldığı ana işlev açısından oluşturucu olmayan toString() işlevini tanımlar.

NOT: Bir constructor, bir sınıfın adıyla aynı isimle tanımlanabilir. Yukarıdaki örnekte tanımlanmıştır.