Cara menggunakan php getproperty

Untuk banyak pemrogram PHP, pemrograman berorientasi objek adalah sebuah konsep yang menakutkan, penuh dengan sintaks rumit dan hambatan lain. Seperti yang dijelaskan dalam buku saya, Pro PHP and jQuery, Anda akan mempelajari konsep-konsep di belakang pemrograman berorientasi objek (OOP), sebuah gaya mengkode di mana tindakan yang terkait dikelompokkan ke dalam kelas untuk membantu menciptakan kode yang lebih kompak, yang efektif.

Memahami Pemrograman Berorientasi Objek

Pemrograman berorientasi objek adalah gaya mengkode yang memungkinkan pengembang untuk mengelompokkan tugas-tugas serupa ke dalam kelas. Ini membantu menjaga kode mengikuti prinsip "jangan mengulangi dirimu sendiri" (DRY) dan mudah-untuk-memelihara.

"Pemrograman berorientasi objek adalah gaya mengkode yang memungkinkan pengembang untuk mengelompokkan tugas-tugas serupa ke dalam kelas."

Salah satu manfaat utama dari pemrograman DRY adalah bahwa, jika sepotong informasi berubah dalam program Anda, biasanya hanya satu perubahan yang diperlukan untuk memperbarui kode. Salah satu mimpi buruk bagi para pengembang adalah menjaga kode dimana data dinyatakan berulang-ulang, yang berarti setiap perubahan pada program menjadi permainan seperti Where's Waldo? yang jauh lebih membuat frustasi ketika mereka berburu untuk data dan fungsi yang digandakan.

OOP menakutkan bagi banyak pengembang karena memperkenalkan sintaks baru dan, sekilas tampaknya jauh lebih kompleks daripada kode prosedural sederhana, atau inline. Namun, setelah pemeriksaan lebih dekat, OOP adalah sebenarnya sangat sederhana dan pada akhirnya pendekatan yang lebih sederhana untuk pemrograman.

Pengertian Objek dan Kelas

Sebelum Anda dapat masuk terlalu jauh ke dalam poin-poin penting dari OOP, pemahaman dasar tentang perbedaan antara objek dan kelas ini diperlukan. Bagian ini akan membahas blok bangunan kelas, kemampuan mereka yang berbeda, dan beberapa kegunaan dari mereka.

Mengenali Perbedaan Antara Objek dan Kelas

Foto oleh Instant Jefferson dan John Wardell

Pengembang mulai berbicara tentang objek dan kelas, dan mereka muncul menjadi istilah dipertukarkan. Namun, hal ini tidak terjadi.

Secara langsung, ada kebingungan dalam OOP: pengembang berpengalaman mulai berbicara tentang objek dan kelas, dan mereka tampaknya menjadi istilah yang dipertukarkan. Hal ini tidak terjadi, namun, meskipun perbedaan dapat menjadi sulit untuk mengingatnya di kepala Anda pada awalnya.

Kelas, misalnya, adalah seperti denah sebuah rumah. Ia mendefinisikan bentuk rumah di atas kertas, dengan hubungan antara bagian-bagian yang berbeda dari rumah yang jelas dan direncanakan, meskipun rumahnya belum terwujud.

Sebuah objek, kemudian, adalah seperti rumah yang sebenarnya dibangun sesuai dengan denahnya. Data yang tersimpan dalam objek seperti kayu, kawat, dan beton yang membentuk rumah: tanpa dirakit sesuai dengan denah, itu hanyalah tumpukan barang-barang. Namun, ketika itu semua dikumpulkan bersama-sama, menjadi rumah yang terorganisir, yang berguna.

Kelas membentuk struktur dari data dan tindakan, dan menggunakan informasi tersebut untuk membangun objek. Lebih dari satu objek yang dapat dibangun dari kelas yang sama pada waktu yang sama, masing-masing independen dari yang lainnya. Melanjutkan dengan analogi konstruksi kami, ini mirip dengan cara seluruh bagian dapat dibangun dari denah yang sama: bahwa 150 rumah yang berbeda semua terlihat sama, namun berbeda
keluarga dan dekorasi di dalamnya.

Struktur Class

Sintaks untuk membuat kelas ini cukup sederhana: mendeklarasikan kelas menggunakan kata kunci class, diikuti oleh nama kelas dan satu set kurung kurawal ({}):

<?php

class MyClass
{
  // Class properties and methods go here
}

?>

Setelah membuat kelas, kelas baru dapat diturunkan dan disimpan dalam variabel menggunakan kata kunci new:

$obj = new MyClass;

Untuk melihat isi kelas, menggunakan var_dump():

var_dump($obj);

Cobalah proses ini dengan menempatkan semua kode sebelumnya dalam sebuah file baru yang disebut test.php di folder pengujian [lokal Anda]:

<?php

class MyClass
{
  // Class properties and methods go here
}

$obj = new MyClass;

var_dump($obj);

?>

Load halaman di browser Anda di http://localhost/test.php dan akan menampilkan berikut ini:

object(MyClass)#1 (0) { }

Dalam bentuk yang paling sederhana, Anda baru saja menyelesaikan skrip OOP pertama Anda.

Mendefinisikan Properti Kelas

Untuk menambahkan data ke dalam kelas, properti, atau variabel kelas-tertentu, digunakan. Ini bekerja persis seperti variabel biasa, kecuali mereka terikat ke objek dan karena itu hanya dapat diakses menggunakan objek.

Untuk menambahkan properti ke MyClass, tambahkan kode berikut ke skrip Anda:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";
}

$obj = new MyClass;

var_dump($obj);

?>

Kata kunci public menentukan visibilitas dari properti, yang Anda akan belajar tentangnya sedikit dalam bab ini kemudian. Selanjutnya, properti dinamai menggunakan sintaks variabel standar, dan nilainya ditetapkan (meskipun properti kelas tidak memerlukan nilai awal).

Untuk membaca properti ini dan output ke browser, referensikan objek dari mana yang akan dibaca dan properti yang harus dibaca:

echo $obj->prop1;

Karena beberapa contoh kelas dapat ada, jika objek individu tidak direferensikan, skrip akan mampu untuk menentukan objek mana untuk membaca darinya. Penggunaan panah (->) adalah membangun OOP yang mengakses properti dan metode yang terkandung dari objek tersebut.

Mengubah skrip di test.php untuk membacakan properti daripada dumping seluruh kelas dengan memodifikasi kode seperti yang ditunjukkan:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";
}

$obj = new MyClass;

echo $obj->prop1; // Output the property

?>

Refresh browser Anda sekarang akan menghasilkan output berikut:

I'm a class property!

Mendefinisikan Metode Kelas

Methods adalah fungsi kelas-tertentu. Tindakan individu yang akan mampu dilakukan objek didefinisikan dalam kelas sebagai metode.

Misalnya, untuk membuat metode yang akan mengatur dan mendapatkan nilai properti kelas $prop1, tambahkan baris berikut ke kode Anda:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

$obj = new MyClass;

echo $obj->prop1;

?>

Catatan — OOP memungkinkan untuk mereferensikan objeknya sendiri menggunakan $this. Ketika bekerja dalam sebuah metode, menggunakan $this dengan cara yang sama Anda akan menggunakan nama objek di luar kelas.

Untuk menggunakan metode tersebut, panggil mereka seperti fungsi biasa, tapi pertama-tama, referensikan objek yang memiliki mereka. Membaca properti dari MyClass, ubah nilainya, dan membacanya lagi dengan membuat perubahan di bawah ini:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

$obj = new MyClass;

echo $obj->getProperty(); // Get the property value

$obj->setProperty("I'm a new property value!"); // Set a new one

echo $obj->getProperty(); // Read it out again to show the change

?>

Reload browser Anda, dan Anda akan melihat hal berikut:

I'm a class property!
I'm a new property value!

"Kekuatan OOP menjadi jelas ketika menggunakan beberapa contoh
kelas yang sama."

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

// Create two objects
$obj = new MyClass;
$obj2 = new MyClass;

// Get the value of $prop1 from both objects
echo $obj->getProperty();
echo $obj2->getProperty();

// Set new values for both objects
$obj->setProperty("I'm a new property value!");
$obj2->setProperty("I belong to the second instance!");

// Output both objects' $prop1 value
echo $obj->getProperty();
echo $obj2->getProperty();

?>

Ketika Anda me-load hasil di browser Anda, mereka terbaca sebagai berikut:

I'm a class property!
I'm a class property!
I'm a new property value!
I belong to the second instance!

Seperti yang Anda lihat, OOP membuat objek-objek sebagai entitas yang terpisah, yang membuatnya memudahkan untuk pemisahan dari potongan-potongan kode yang berbeda menjadi bundel terkait yang kecil.

Metode Magic dalam OOP

Untuk membuat penggunaan objek-objek lebih mudah, PHP juga menyediakan sejumlah metode magic, atau metode khusus yang dipanggil pada saat tindakan umum tertentu terjadi dalam objek-objek. Ini memungkinkan pengembang untuk melakukan sejumlah tugas-tugas yang berguna dengan relatif mudah.

Menggunakan Constructor dan Destructor

Ketika sebuah objek dibuat, hal ini sering diinginkan untuk mengatur beberapa hal secara langsung. Untuk menangani hal ini, PHP menyediakan metode magic __construct(), yang dipanggil secara otomatis setiap kali sebuah objek baru
dibuat.

Untuk tujuan menggambarkan konsep constructor, tambahkan constructor untuk MyClass yang akan menampilkan pesan setiap kali sebuah instance baru dari kelas dibuat:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

// Create a new object
$obj = new MyClass;

// Get the value of $prop1
echo $obj->getProperty();

// Output a message at the end of the file
echo "End of file.<br />";

?>

Catatan — __CLASS__ mengembalikan nama kelas yang dipanggil; ini adalah apa yang dikenal sebagai konstanta magic. Ada beberapa konstanta magic yang tersedia, yang Anda dapat membaca lebih lanjut tentangnya di manual PHP.

Reload file di browser Anda akan menghasilkan hasil sebagai berikut:

The class "MyClass" was initiated!
I'm a class property!
End of file.

Untuk memanggil fungsi ketika objek dihancurkan, disediakan metode magic __destruct(). Berguna untuk pembersihan kelas (menutup koneksi database, misalnya).

Output sebuah pesan ketika objek dihancurkan dengan mendefinisikan metode magic
__destruct() di MyClass:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

// Create a new object
$obj = new MyClass;

// Get the value of $prop1
echo $obj->getProperty();

// Output a message at the end of the file
echo "End of file.<br />";

?>

Setelah mendefinisikan sebuah destructor, reload file tes yang menghasilkan output berikut:

The class "MyClass" was initiated!
I'm a class property!
End of file.
The class "MyClass" was destroyed.

"Ketika mencapai akhir dari file, PHP secara otomatis melepas semua sumber daya."

Untuk secara eksplisit memicu destructor, Anda dapat menghancurkan objek yang menggunakan
fungsi unset():

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

// Create a new object
$obj = new MyClass;

// Get the value of $prop1
echo $obj->getProperty();

// Destroy the object
unset($obj);

// Output a message at the end of the file
echo "End of file.<br />";

?>

Sekarang hasilnya berubah menjadi berikut ketika di-load di browser Anda:

The class "MyClass" was initiated!
I'm a class property!
The class "MyClass" was destroyed.
End of file.

Mengkonversi ke String

Untuk menghindari kesalahan jika skrip berupaya untuk meng-output MyClass sebagai sebuah string, metode magic lain yang digunakan disebut __toString().

Tanpa __toString(), mencoba untuk output objek sebagai string mengakibatkan kesalahan fatal. Cobalah menggunakan echo untuk output objek tanpa metode magic di tempatnya:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

// Create a new object
$obj = new MyClass;

// Output the object as a string
echo $obj;

// Destroy the object
unset($obj);

// Output a message at the end of the file
echo "End of file.<br />";

?>

Hasilnya sebagai berikut:

The class "MyClass" was initiated!

Catchable fatal error: Object of class MyClass could not be converted to string in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 40

Untuk menghindari kesalahan ini, tambahkan metode __toString():

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function __toString()
  {
      echo "Using the toString method: ";
      return $this->getProperty();
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

// Create a new object
$obj = new MyClass;

// Output the object as a string
echo $obj;

// Destroy the object
unset($obj);

// Output a message at the end of the file
echo "End of file.<br />";

?>

Dalam hal ini, mencoba untuk mengkonversi objek ke string menghasilkan panggilan ke metode getProperty(). Load skrip test di browser Anda untuk melihat hasilnya:

The class "MyClass" was initiated!
Using the toString method: I'm a class property!
The class "MyClass" was destroyed.
End of file.

Tips — Selain metode magic yang dibahas dalam bagian ini, beberapa lainnya juga tersedia. Untuk daftar lengkap dari metode magic, lihatlah halaman manual PHP.

Menggunakan Pewarisan Kelas

Kelas dapat mewarisi metode dan properti dari kelas lain menggunakan kata kunci extends. Misalnya, untuk membuat kelas kedua itu meluaskan MyClass dan menambahkan sebuah metode, Anda akan menambahkan kode berikut ke file tes:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function __toString()
  {
      echo "Using the toString method: ";
      return $this->getProperty();
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

class MyOtherClass extends MyClass
{
  public function newMethod()
  {
      echo "From a new method in " . __CLASS__ . ".<br />";
  }
}

// Create a new object
$newobj = new MyOtherClass;

// Output the object as a string
echo $newobj->newMethod();

// Use a method from the parent class
echo $newobj->getProperty();

?>

Setelah reload file tes di browser Anda, berikut adalah outputnya:

The class "MyClass" was initiated!
From a new method in MyOtherClass.
I'm a class property!
The class "MyClass" was destroyed.

Menimpa Properti dan Metode yang Diwariskan

Untuk mengubah perilaku properti yang sudah ada atau metode di kelas yang baru, Anda hanya dapat menimpanya dengan menyatakannya lagi di kelas yang baru:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function __toString()
  {
      echo "Using the toString method: ";
      return $this->getProperty();
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

class MyOtherClass extends MyClass
{
  public function __construct()
  {
      echo "A new constructor in " . __CLASS__ . ".<br />";
  }

  public function newMethod()
  {
      echo "From a new method in " . __CLASS__ . ".<br />";
  }
}

// Create a new object
$newobj = new MyOtherClass;

// Output the object as a string
echo $newobj->newMethod();

// Use a method from the parent class
echo $newobj->getProperty();

?>

Ini perubahan output di browser:

A new constructor in MyOtherClass.
From a new method in MyOtherClass.
I'm a class property!
The class "MyClass" was destroyed.

Menjaga Fungsi Metode Asli Sementara Menimpa Metode

Untuk menambah fungsionalitas baru ke metode yang diwariskan sementara menjaga metode yang asli tetap utuh, gunakan kata kunci parent dengan scope resolution operator (::):

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function __toString()
  {
      echo "Using the toString method: ";
      return $this->getProperty();
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  public function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

class MyOtherClass extends MyClass
{
  public function __construct()
  {
      parent::__construct(); // Call the parent class's constructor
      echo "A new constructor in " . __CLASS__ . ".<br />";
  }

  public function newMethod()
  {
      echo "From a new method in " . __CLASS__ . ".<br />";
  }
}

// Create a new object
$newobj = new MyOtherClass;

// Output the object as a string
echo $newobj->newMethod();

// Use a method from the parent class
echo $newobj->getProperty();

?>

Ini output hasil dari konstruktor induk dan konstruktor kelas yang baru:

The class "MyClass" was initiated!
A new constructor in MyOtherClass.
From a new method in MyOtherClass.
I'm a class property!
The class "MyClass" was destroyed.

Menetapkan Visibilitas dari Properti dan Metode

Untuk menambahkan kontrol atas objek, metode dan properti maka ditugaskan visibilitas. Ini mengontrol bagaimana dan dari mana properti dan metode dapat diakses. Ada tiga kata kunci visibilitas: public, protected, dan private. Selain visibilitasnya, metode atau properti dapat dinyatakan sebagai static, yang memungkinkan mereka untuk dapat diakses tanpa instansiasi dari kelas.

"Untuk menambahkan kontrol atas objek, metode dan properti maka ditugaskan visibilitas."

Catatan — Visibilitas adalah fitur baru dari PHP 5. Untuk informasi tentang kompatibilitas OOP dengan PHP 4, lihat halaman manual PHP.

Properti dan Metode Public

Semua metode dan properti yang telah Anda digunakan sejauh ini adalah public. Ini berarti bahwa mereka dapat diakses di mana saja, baik di dalam kelas maupun secara eksternal.

Properti dan Metode Protected

Ketika sebuah properti atau metode dinyatakan protected, ia hanya dapat diakses di dalam kelas itu sendiri atau di kelas-kelas turunannya (kelas yang meng-extend kelas yang berisi metode protected).

Menyatakan metode getProperty() sebagai protected di MyClass dan coba untuk mengaksesnya secara langsung dari luar kelas:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function __toString()
  {
      echo "Using the toString method: ";
      return $this->getProperty();
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  protected function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

class MyOtherClass extends MyClass
{
  public function __construct()
  {
      parent::__construct();
echo "A new constructor in " . __CLASS__ . ".<br />";
  }

  public function newMethod()
  {
      echo "From a new method in " . __CLASS__ . ".<br />";
  }
}

// Create a new object
$newobj = new MyOtherClass;

// Attempt to call a protected method
echo $newobj->getProperty();

?>

Setelah mencoba untuk menjalankan skrip ini, error berikut muncul:

The class "MyClass" was initiated!
A new constructor in MyOtherClass.

Fatal error: Call to protected method MyClass::getProperty() from context '' in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 55

Sekarang, buat metode baru dalam MyOtherClass untuk memanggil metode getProperty():

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function __toString()
  {
      echo "Using the toString method: ";
      return $this->getProperty();
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  protected function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

class MyOtherClass extends MyClass
{
  public function __construct()
  {
      parent::__construct();
echo "A new constructor in " . __CLASS__ . ".<br />";
  }

  public function newMethod()
  {
      echo "From a new method in " . __CLASS__ . ".<br />";
  }

  public function callProtected()
  {
      return $this->getProperty();
  }
}

// Create a new object
$newobj = new MyOtherClass;

// Call the protected method from within a public method
echo $newobj->callProtected();

?>

Ini menghasilkan hasil yang diinginkan:

The class "MyClass" was initiated!
A new constructor in MyOtherClass.
I'm a class property!
The class "MyClass" was destroyed.

Properti dan Metode Private

Properti atau method yang dideklarasikan private ini dapat diakses hanya dari dalam kelas yang mendefinisikannya. Ini berarti bahwa bahkan jika kelas baru meng-extend kelas yang mendefinisikan properti private, properti atau metode tersebut tidak akan tersedia di semua kelas anak.

Untuk menunjukkan hal ini, nyatakan getProperty() sebagai private di MyClass, dan berusaha untuk memanggil callProtected() dari
MyOtherClass:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function __toString()
  {
      echo "Using the toString method: ";
      return $this->getProperty();
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  private function getProperty()
  {
      return $this->prop1 . "<br />";
  }
}

class MyOtherClass extends MyClass
{
  public function __construct()
  {
      parent::__construct();
      echo "A new constructor in " . __CLASS__ . ".<br />";
  }

  public function newMethod()
  {
      echo "From a new method in " . __CLASS__ . ".<br />";
  }

  public function callProtected()
  {
      return $this->getProperty();
  }
}

// Create a new object
$newobj = new MyOtherClass;

// Use a method from the parent class
echo $newobj->callProtected();

?>

Reload browser Anda, dan muncul error berikut:

The class "MyClass" was initiated!
A new constructor in MyOtherClass.

Fatal error: Call to private method MyClass::getProperty() from context 'MyOtherClass' in /Applications/XAMPP/xamppfiles/htdocs/testing/test.php on line 49

Properti dan Metode Static

Metode atau properti yang dinyatakan static dapat diakses tanpa instantiasi kelas pertama kali; Anda hanya memberikan nama kelas, scope resolution operator, dan nama properti atau metode.

"Salah satu manfaat utama menggunakan properti static adalah bahwa mereka menyimpan nilai-nilai yang disimpan dalam durasi skrip."

Untuk menunjukkan hal ini, tambahkan properti static yang disebut $count dan metode static yang disebut plusOne() ke MyClass. Kemudian atur loop do...while untuk output nilai bertambah dari $count selama nilainya adalah kurang dari 10:

<?php

class MyClass
{
  public $prop1 = "I'm a class property!";

  public static $count = 0;

  public function __construct()
  {
      echo 'The class "', __CLASS__, '" was initiated!<br />';
  }

  public function __destruct()
  {
      echo 'The class "', __CLASS__, '" was destroyed.<br />';
  }

  public function __toString()
  {
      echo "Using the toString method: ";
      return $this->getProperty();
  }

  public function setProperty($newval)
  {
      $this->prop1 = $newval;
  }

  private function getProperty()
  {
      return $this->prop1 . "<br />";
  }

  public static function plusOne()
  {
      return "The count is " . ++self::$count . ".<br />";
  }
}

class MyOtherClass extends MyClass
{
  public function __construct()
  {
      parent::__construct();
      echo "A new constructor in " . __CLASS__ . ".<br />";
  }

  public function newMethod()
  {
      echo "From a new method in " . __CLASS__ . ".<br />";
  }

  public function callProtected()
  {
      return $this->getProperty();
  }
}

do
{
  // Call plusOne without instantiating MyClass
  echo MyClass::plusOne();
} while ( MyClass::$count < 10 );

?>

Catatan — Saat mengakses properti static, tanda dolar
($) datang setelah scope resolution operator.

Ketika Anda me-load script ini di browser Anda, berikut adalah outputnya:

The count is 1.
The count is 2.
The count is 3.
The count is 4.
The count is 5.
The count is 6.
The count is 7.
The count is 8.
The count is 9.
The count is 10.

Mengomentari dengan DocBlocks

"Mengomentari bergaya DocBlock adalah metode yang diterima
secara luas dari mendokumentasikan kelas."

Sementara bukan merupakan bagian resmi dari OOP, mengomentari bergaya DocBlock adalah metode pendokumentasian kelas yang diterima secara luas. Selain menyediakan standar untuk
pengembang untuk menggunakannya ketika menulis kode, ini juga telah diadopsi oleh banyak kit pengembangan perangkat lunak (SDK) yang paling populer, seperti Eclipse dan NetBeans, dan akan digunakan untuk menghasilkan petunjuk kode.

Sebuah DocBlock didefinisikan dengan menggunakan blok komentar yang dimulai dengan tambahan tanda bintang:

/**
 * This is a very basic DocBlock
 */

Kekuatan sebenarnya dari DocBlock adalah dilengkapi dengan kemampuan untuk menggunakan tags, yang dimulai dengan simbol (@) yang segera diikuti oleh nama tag dan nilai dari tag. Tag DocBlock memungkinkan pengembang untuk menentukan penulis dari sebuah file, lisensi dari kelas, informasi properti atau metode, dan informasi berguna lainnya.

Tag yang paling umum digunakan:

@author: Penulis dari elemen saat ini (yang mungkin adalah kelas, file, metode, atau setiap bit kode) terdaftar menggunakan tag ini. Beberapa tag penulis dapat digunakan di dalam DocBlock yang sama jika lebih dari satu penulis dikreditkan. Format untuk nama penulis adalah John Doe <>.
@copyright: Ini menandakan tahun hak cipta dan nama pemegang hak cipta untuk elemen saat ini. Formatnya 2010 Pemegang Hak Cipta.
@license: Ini link untuk lisensi elemen saat ini. Format untuk informasi lisensi adalah
http://www.example.com/path/to/license.txt Nama Lisensi.
@var: Ini memegang jenis dan keterangan dari variabel atau properti kelas. Formatnya jenis elemen deskripsi.
@param: Tag Ini menunjukkan jenis dan deskripsi dari parameter fungsi atau metode. Formatnya jenis $nama_element elemen deskripsi.
@return: Jenis dan deskripsi dari nilai yang dikembalikan dari fungsi atau metode yang diberikan dalam tag ini. Formatnya jenis pengembalian elemen deskripsi.

Sampel kelas yang dikomentari dengan DocBlocks mungkin terlihat seperti ini:

<?php

/**
 * A simple class
 *
 * This is the long description for this class,
 * which can span as many lines as needed. It is
 * not required, whereas the short description is
 * necessary.
 *
 * It can also span multiple paragraphs if the
 * description merits that much verbiage.
 *
 * @author Jason Lengstorf <>
 * @copyright 2010 Ennui Design
 * @license http://www.php.net/license/3_01.txt PHP License 3.01
 */
class SimpleClass
{
  /**
   * A public variable
   *
   * @var string stores data for the class
   */
  public $foo;

  /**
   * Sets $foo to a new value upon class instantiation
   *
   * @param string $val a value required for the class
   * @return void
   */
  public function __construct($val)
  {
      $this->foo = $val;
  }

  /**
   * Multiplies two integers
   *
   * Accepts a pair of integers and returns the
   * product of the two.
   *
   * @param int $bat a number to be multiplied
   * @param int $baz a number to be multiplied
   * @return int the product of the two parameters
   */
  public function bar($bat, $baz)
  {
      return $bat * $baz;
  }
}

?>

Setelah anda memindai kelas sebelumnya, manfaat DocBlock yang jelas: segala sesuatu yang didefinisikan secara jelas sehingga pengembang berikutnya dapat mengambil kode dan tidak perlu harus bertanya-tanya potongan kode melakukan apa atau apa yang harus dikandungnya.

Membandingkan Kode Berorientasi Objek dan Prosedural

Tidak ada benar-benar yang benar dan salah untuk menulis kode. Seperti yang dikatakan, bagian ini menguraikan argumen yang kuat untuk mengadopsi pendekatan berorientasi objek dalam pengembangan perangkat lunak, terutama pada aplikasi yang besar.

Alasan 1: Kemudahan Pelaksanaan

"Sementara itu dapat menjadi sesuatu yang membingungkan pada awalnya, OOP benar-benar menyediakan pendekatan yang lebih mudah untuk berurusan dengan data."

Sementara itu dapat menjadi sesuatu yang membingungkan pada awalnya, OOP benar-benar menyediakan pendekatan yang lebih mudah untuk berurusan dengan data. Karena objek dapat menyimpan data secara internal, variabel tidak perlu diteruskan dari fungsi ke fungsi untuk bekerja dengan baik.

Juga, karena beberapa instance dari kelas yang sama dapat berwujud secara bersamaan, berurusan dengan set data yang besar adalah jauh lebih mudah. Sebagai contoh, bayangkan Anda memiliki informasi dua orang yang sedang diproses dalam file. Mereka membutuhkan nama, pekerjaan, dan usia.

Pendekatan Prosedural

Berikut adalah pendekatan prosedural untuk contoh kita:

<?php

function changeJob($person, $newjob)
{
  $person['job'] = $newjob; // Change the person's job
  return $person;
}

function happyBirthday($person)
{
  ++$person['age']; // Add 1 to the person's age
  return $person;
}

$person1 = array(
  'name' => 'Tom',
  'job' => 'Button-Pusher',
  'age' => 34
);

$person2 = array(
  'name' => 'John',
  'job' => 'Lever-Puller',
  'age' => 41
);

// Output the starting values for the people
echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";

// Tom got a promotion and had a birthday
$person1 = changeJob($person1, 'Box-Mover');
$person1 = happyBirthday($person1);

// John just had a birthday
$person2 = happyBirthday($person2);

// Output the new values for the people
echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";

?>

Ketika dijalankan, kode menghasilkan output berikut:

Person 1: Array
(
  [name] => Tom
  [job] => Button-Pusher
  [age] => 34
)
Person 2: Array
(
  [name] => John
  [job] => Lever-Puller
  [age] => 41
)
Person 1: Array
(
  [name] => Tom
  [job] => Box-Mover
  [age] => 35
)
Person 2: Array
(
  [name] => John
  [job] => Lever-Puller
  [age] => 42
)

Sementara kode ini tidak selalu buruk, ada banyak yang perlu diingat saat mengkode. Array dari orang yang terkena atribut harus disampaikan dan dikembalikan dari masing-masing panggilan fungsi, yang meninggalkan margin untuk kesalahan.

Untuk membersihkan contoh ini, akan diinginkan untuk meninggalkan beberapa hal untuk pengembang sesedikit mungkin. Hanya informasi yang benar-benar penting untuk operasi saat ini harus perlu dilewatkan ke fungsi.

Ini adalah di mana langkah-langkah OOP datang dan membantu Anda membersihkannya.

Pendekatan OOP

Berikut adalah pendekatan OOP untuk contoh kita:

<?php

class Person
{
  private $_name;
  private $_job;
  private $_age;

  public function __construct($name, $job, $age)
  {
      $this->_name = $name;
      $this->_job = $job;
      $this->_age = $age;
  }

  public function changeJob($newjob)
  {
      $this->_job = $newjob;
  }

  public function happyBirthday()
  {
      ++$this->_age;
  }
}

// Create two new people
$person1 = new Person("Tom", "Button-Pusher", 34);
$person2 = new Person("John", "Lever Puller", 41);

// Output their starting point
echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";

// Give Tom a promotion and a birthday
$person1->changeJob("Box-Mover");
$person1->happyBirthday();

// John just gets a year older
$person2->happyBirthday();

// Output the ending values
echo "<pre>Person 1: ", print_r($person1, TRUE), "</pre>";
echo "<pre>Person 2: ", print_r($person2, TRUE), "</pre>";

?>

Ini adalah output berikut di browser:

Person 1: Person Object
(
  [_name:private] => Tom
  [_job:private] => Button-Pusher
  [_age:private] => 34
)

Person 2: Person Object
(
  [_name:private] => John
  [_job:private] => Lever Puller
  [_age:private] => 41
)

Person 1: Person Object
(
  [_name:private] => Tom
  [_job:private] => Box-Mover
  [_age:private] => 35
)

Person 2: Person Object
(
  [_name:private] => John
  [_job:private] => Lever Puller
  [_age:private] => 42
)

Ada sedikit pengaturan yang lebih banyak terlibat untuk membuat pendekatan berorientasi objek, tapi setelah kelas didefinisikan, membuat dan memodifikasi orang adalah mudah sekali; informasi orang tidak perlu diteruskan atau dikembalikan dari metode, dan hanya benar-benar informasi penting yang dilewatkan pada masing-masing metode.

"OOP akan secara signifikan mengurangi beban kerja Anda jika diterapkan dengan benar."

Pada skala kecil, perbedaan ini mungkin tidak tampak banyak, tetapi ketika aplikasi Anda tumbuh dalam ukurannya, OOP akan secara signifikan mengurangi beban kerja Anda jika dilaksanakan dengan baik dan benar.

Tips — Tidak semuanya harus berorientasi objek. Fungsi cepat yang menangani sesuatu yang kecil di satu tempat di dalam aplikasi tidak selalu harus dibungkus dalam kelas. Gunakan penilaian terbaik Anda ketika memutuskan antara pendekatan berorientasi objek dan prosedural.

Alasan 2: Pengorganisasian yang Lebih Baik

Manfaat lain dari OOP adalah seberapa baik ini cocok untuk menjadi mudah dikemas dan dikatalog. Setiap kelas umumnya dapat disimpan dalam file terpisah sendiri, dan jika konvensi penamaan yang seragam digunakan, mengakses kelas-kelas ini sangat mudah.

Misalnya Anda punya sebuah aplikasi dengan 150 kelas yang dipanggil secara dinamis melalui file kontroler pada root dari filesystem aplikasi Anda. Semua 150 kelas mengikuti konvensi penamaan class.classname.inc.php dan berada di folder inc dari aplikasi Anda.

Kontroler dapat melaksanakan fungsi PHP __autoload() untuk secara dinamis menarik hanya kelas-kelas yang dibutuhkan sebagaimana mereka dipanggil, bukannya memasukkan semua 150 di file kontroler untuk berjaga-jaga atau datang dengan beberapa cara pintar termasuk file dalam kode Anda sendiri:

<?php
  function __autoload($class_name)
  {
      include_once 'inc/class.' . $class_name . '.inc.php';
  }
?>

Memiliki masing-masing kelas dalam file terpisah juga membuat kode lebih portabel dan lebih mudah untuk menggunakannya kembali di aplikasi baru tanpa benyak-banyak meng-copy dan mem-paste.

Alasan 3: Pemeliharaan Lebih Mudah

Karena sifat lebih kompak dari OOP ketika dilakukan dengan benar, perubahan dalam kode yang biasanya jauh lebih mudah untuk ditemukan dan membuat dari pada implementasi kode prosedural sepanjang spaghetti.

Jika serangkaian informasi tertentu memperoleh atribut baru, potongan perangkat lunak prosedural mungkin diperlukan (dalam skenario terburuk) bahwa atribut baru ditambahkan ke masing-masing fungsi yang menggunakan array.

Aplikasi OOP berpotensi dapat diperbarui semudah menambahkan properti baru dan kemudian menambahkan metode yang menangani properti itu.

Banyak manfaat yang dibahas dalam bagian ini merupakan hasil OOP dalam kombinasi dengan praktek-praktek pemrograman DRY. Itu pasti mungkin untuk membuat kode prosedural yang mudah-untuk-mempertahankan yang tidak menimbulkan mimpi buruk, dan sama-sama mungkin dapat membuat kode berorientasi obyek mengerikan. [Pro PHP and jQuery] akan mencoba untuk menunjukkan kombinasi dari kebiasaan mengkode yang baik dalam hubungannya dengan OOP untuk menghasilkan kode yang mudah dibaca dan dipelihara.

Ringkasan

Pada titik ini, Anda seharusnya merasa nyaman dengan gaya pemrograman berorientasi objek. Belajar OOP adalah cara yang bagus untuk meningkatkan pemrograman Anda ke tingkat berikutnya. Bila dilaksanakan dengan baik, OOP akan membantu Anda menghasilkan kode portabel yang mudah-untuk-dibaca, mudah-untuk-dijaga, yang akan menghematkan Anda (dan pengembang yang bekerja dengan Anda) jam kerja ekstra. Apakah Anda terjebak pada sesuatu yang tidak dibahas di artikel ini? Apakah Anda sudah menggunakan OOP dan memiliki beberapa tips untuk para pemula? Berbagilah di komentar!

Catatan Penulis — Tutorial ini adalah kutipan dari Pro PHP and jQuery (Apress, 2010).