មេរៀនទី៦: PHP- Object

1. What Is an Object ?

Object គឺជា បណ្ដុំនៃ variables និង functions ដែលឋិតនៅក្នុង template ពិសេសមួយដែល គេហៅថា class ។ object លាក់នូវតំណើរការដែលមាននៅខាងក្នុង ពីការប្រើប្រាស់វា ដោយផ្ដល់ជា Interface សំរាប់អោយអ្នកបញ្ជូននូវ បញ្ជារដើម្បីទទួលពត៌មានត្រលប់មកវិញ ។ interface ទាំងនោះ គឺជា Function ពិសេសដែលគេអោយឈោះ methods ហើយរាល់ methods ទាំងអស់នៃ object គឺត្រូវតែ Access ទៅកាន់ special variable ហៅថា properties។ គុណសម្បត្ដិរបស់ object-oriented code គឺផ្ដល់នូវការកាត់បន្ថយការសរសេរកូដ ដដែលៗពីព្រោះ class ដែលបាន

បង្កើត ជា object មានភាពងាយស្រួលយកទៅប្រើប្រាស់ពី project មួយទៅកាន់Project មួយ ផ្សេងទៀត ។ បន្ថែមពីនេះវាមានលទ្ធភាពបង្កើត នូវ child classes ដែល inherit ហើយនឹង Override នូវលក្ខណៈផ្សេងៗពី parents class ។
2. Creating an Object
ដើម្បីបង្កើត object មួយអ្នកត្រូវតែរៀបចំនូវ template មួយដើម្បីអោយវាអាច instantiated ដែល template នេះគឺជា class នៅក្នុងភាសា PHP ដើម្បីប្រកាស class មួយអ្នកត្រូវតែប្រើ class Keyword ។
class Person
{
// a very minimal class
}
Person class គឺជាមូលដ្ឋានដ៏សំខាន់មួយដែលអ្នកអាច instantiate រាល់តំលៃ និមួយៗពី PersonObject ។ ដើម្បីបង្កើត instance មួយនៃ object អ្នកត្រូវតែប្រើ new statement ។
$obj1 = new Person(); .
$obj2 = new Person(); .
print “\$obj1 is an “.gettype($obj1).”
”; .
print “\$obj2 is an “.gettype($obj2).”
”; .
អ្នកអាច test នូវ $obj1 និង $obj2 ជាមួយនឹង gettype() function ។ gettype function ទទួលតំលៃVariable និមួយៗហើយផ្ដល់ជា string មកវិញដែលប្រាប់អ្នកអំពីអ្វីដែលអ្នកកំពុងតែធ្វើការជាមួយ ។
3. Object Properties
Object ដែល access ទៅកាន់ special variable ត្រូវបានគេហៅថា properties ។ អ្នកអាច ប្រកាស នូវ special variable ទាំងនោះបាននៅគ្រប់ទីកន្លែងទាំងអស់នៃ class ប៉ុន្ដែដើម្បីអោយ មានភាពងាយស្រួលអ្នកគួរតែប្រកាស់វានៅខាងលើ ។ សំរាប់ property មួយវាអាចជា value ឬ ជា array ឬ ជាObject ផ្សេងៗ ។
class Person .
{
var $name = “Vichet”; .
}
យើងបាន declared នូវ variable ជាមួយនឹង var keyword ដែលនេះគឺជាវិធីសាស្ដ្រ តែមួយ គត់ដើម្បី declare នូវ property មួយនៅក្នុងភាសា PHP 4 យើងនឹងឃើញពីលក្ខណៈបន្ថែមរបស់ PHP 5 នៅឧទាហរណ៍ក្រោយៗទៀត ។ ដូច្នេះប្រសិនបើអ្នកចង់សរសេរកូដអោយ compatible ជាមួយ PHP 4 នោះ អ្នកត្រូវតែប្រើ var keyword។ ឥឡូវនេះ Person objet ដែលបានបង្កើត គឺមាន ផ្ទុកនូវ property មួយ ដែលអោយឈោះថា $name ជាមួយនឹងតំលៃរបស់វាគឺ “Vichet” ។ អ្នកអាច access នូវ property នេះ ពីខាងក្រៅ object និងធ្វើការផ្លាស់ប្ដូរ តំលៃរបស់វាដោយ ប្រើឧទាហរណ៍ ៣៧ ។
class Person >
{
var $name = “Vichet”; >
}
$obj1 = new Person(); >
$obj2 = new Person(); >
$obj1->name = “Soporn”; >
print “$obj1->name
”; >
print “$obj2->name
”; >
?>
( -> ) operator នេះអនុញ្ញាតអោយអ្នកធ្វើការ access ឬ ផ្លាស់ប្ដូរនូវតំលៃរបស់ properties នៃObject ។ យើងបានផ្ដល់នូវតំលៃ “Soporn” ទៅអោយ $name property តាមរយៈ $obj1->name ។
4. Object Methods . Method គឺជា function ដែល defined នៅក្នុង class ។ គ្រប់ object ដែលបាន instantiatedពី class តែងតែមាន method‟s ជានិច្ច យើងនឹងបន្ថែមនូវ method មួយទៅអោយ Person class នៅ
ឧទាហរណ៍ ៣៨ ។
 
  class Person
  {
  var $name = “Vichet”;
  function getName()   {
 return “Ratana”;
  }

  }

 $person = new Person();
  print $person->getName();
  // outputs “Ratana”
  ?>

ដូចដែលអ្នកបានជួបប្រទះមកហើយអំពី method នៃឧទាហរណ៍ ៣៧ ដែលមើលទៅវាមានលក្ខណៈ ដូចគ្នាទៅនឹង function ធមμតាដែរ ។ អ្នកអាច call object method ដោយការប្រើប្រាស់និមិត្ដ សញ្ញា ( -> )។ method ដែលបាន access ទៅកាន់ member variables នៃ class ខាងលើបាន return នូវ string “Ratana” ដែលនេះមិនមែនជាការអនុវត្ដន៍ដែលត្រឹមត្រូវ នោះទេ method គួរតែ return តំលៃដែល copy ពី $name property នឹង មិនមែនជា string literal។ អ្នកក៏បានស្គាល់ រួច មកហើយអំពីការaccess a property ពីខាងក្រៅ object ប៉ុន្ដែតើត្រូវធ្វើយ៉ាងណាដើម្បី refer វានៅខាងក្នុង class ខ្លួនឯង? សូមពិនិត្យមើលឧទាហរណ៍ ៣៩ ។

5. Accessing a Property from Within a Method .
ឧទាហរណ៍ ៣៩
 
  Accessing a property from within a method

 
 

Accessing a property from within a method

 
  class Person
  {
 var $name = “Thary”;

 function getName()
  {
  return $this->name;
  }
  }

  $person = new Person();
  $person->name = “Bopha”;
  print $person->getName();
  //outputs “Bopha”
  ?>
 
 
Class ដែលបានបង្កើតក្នុងឧទាហរណ៍ ៣៩ យើងបានប្រើប្រាស់នូវ special variable $this ដើម្បី refer ទៅកាន់ current instantiated object នៅបន្ទាត់ទី ១៥ គឺ $name ។ object ដែល refer ទៅ កាន់ ខ្លួនឯងត្រូវតែប្រើ $this variable ភ្ជាប់ជាមួយសញ្ញា ( -> ) ដោយការប្រើវិធីនេះអ្នកអាច accessរាល់ property ឬ method ដែលឋិតនៅក្នុង class ខ្លួនឯង។ អ្នកអាចគិតថាចង់អោយ object មាននូវតំលៃនៃ $name property ផ្សេងៗគ្នា ដោយអ្នកអាចធ្វើការរៀបចំនូវតំលៃរបស់ $name property ដូចដែលបានអនុវត្ដន៍នៅក្នុងឧទាហរណ៍ ៣៩ ឬ អ្នកអាចបង្កើតជាmethod សំរាប់ធ្វើការជាមួយវាដូចមានបង្ហាញក្នុង ឧទាហរណ៍ ៤០ ។
6. Changing the Value of a Property from Within a Method .
ឧទាហរណ៍ ៤០
 
 
 
 
 
 

A Class with a Construct

 
 class Person
 {
  var $name;

  function Person($name=”tepy”)
  {
  $this->name = $name;
  }
  function setName( $n)
  {
 $this->name = $n;
  }

 function getName()
 {
  return $this->name;
  }
  }

  $person = new Person(“darya”);
  print $person->getName ();
  // outputs “Darya”

  ?>

 
 
Person() constructor method បន្ទាត់ទី14គឺត្រូវបានហៅដោយស្វ័យប្រវត្ដិនៅពេលដែលយើងInstantiate នូវ Person object បន្ទាត់ទី២៩ យើងក៏បានរៀបចំនូវតំលៃ default មួយជា string “tepy” ផ្ដល់ទៅអោយ parameter ផងដែរ វាគឺជាការជំនួសអោយ ខណៈដែលយើងមិនបានផ្ដល់ជា argument នៅពេលដែលយើងបង្កើត Object។ PHP 5 បានបង្ហាញនូវ syntax ថីមួយដើម្បីបង្កើត constructor methods ដោយជំនួស អោយ ការប្រើប្រាស់នូវ function ដែលមានឈោះដូច class មកជាការប្រើ special syntax ថីគឺ__construct()ដូច្នេះយើងអាចធ្វើការផ្លាស់ប្ដូរបន្ទាត់ទី៥នៃ
ឧទាហរណ៍ខាងលើ មកប្រើនូវ syntax ថដោយធ្វើការជំនួសនូវ function Person() មកប្រើ __construct() វិញ។
function __construct( $name=”tepy”) .
{
………….
}
8. Limiting Access to Object Properties .
PHP 4 មិនបានផ្ដល់នូវការ ការពារសំរាប់ object properties នោះទេ Client code អាច getឬ set objectproperties បានទៅតាមការគិតរបស់ពួកគេ។មានសំនួរសួរថាតើមានបញ្ហាអ្វីទេក្នុងការ អនុវត្ដន៍ បែបនេះ? វាមិនមានជាបញ្ហាក្នុងការប្រើ
ប្រាស់នូវ Public accessible properties នោះទេ ដែល ជាទូទៅ វាជាការអនុវត្ដន៍សំរាប់ការ access ទៅកាន់ object ដែលមានលក្ខណៈតូច។ នៅឧទាហរណ៍ខាង ក្រោមយើងនឹងបានឃើញ នូវលក្ខ័ណ្ឌមួយដែលកំណត់នូវព្រំដែននៃការ access ទៅកាន់ $name propertyរបស់ Person class ។
ឧទាហរណ៍ ៤២ Class with Public Properties
   class Person
 {
  var $name;
 var $pid;
  var $personStr;

  function Person( $name=”somphy”, $pid=0 )
  {
 $this->name = $name;
  $this->pid = $pid;
  }

  function setName( $n )
  {
  $this->name = $n;
  $this->$personStr=$this->name.” “.$this->pid;
  }

  function getName ()
  {
  return $this->name;
  }
  }
  $person = new Person(“sovan”,5233);
  print $person->PersonStr();
  // outputs “sovan 5233″
 print “
”;
 $person->name = “makara”;
 ?>
PHP 5 ផ្ដល់នូវវិធីសាស្ដ្រផ្សេងដើម្បី declare នូវ properties របស់យើងដោយការជំនួសនូវ Var keyword មកប្រើនូវ keywords ថីមួយក្នុងចំណោម keyword ទាំងបី ដែលមានលក្ខណៈ ស្រដៀង ទៅនឹង programming Java យើងនឹងបង្ហាញពីការ declareនូវ property ថីនេះនៅក្នុងតារាងខាងក្រោម

ដូច្នេះយើងអាចផ្លាស់ប្ដូរ properties របស់យើងដែលមាននៅក្នុងឧទាហរណ៍ខាងលើដោយប្រើprivate ជំនួស ដោយ var keyword វិញ ។
ex.
private $name; .
private $pid; .
ឥឡូវនេះការព្យាយាមផ្លាស់ប្ដូរនូវតំលៃរបស់ $name property នៃ Person object នៅបន្ទាត់ទី ៣០ នឹងបង្ហាញនូវ error message ដូចខាងក្រោម ។
Fatal error: Cannot access private property Person::$name in c:\Inetpub\wwwroot\ classPrivateProperty.php on line 30 .

ដូច្នេះ Client coders ត្រូវតែប្រើប្រាស់នូវ setName() method ដើម្បីធ្វើការកែប្រែទៅលើ តំលៃ របស់ $name property ។ មានពេលណាមួយអ្នកប្រហែលជាចង់អោយ child classes អាច accsess ទៅកាន់ property ដែលនៅក្នុងពេលនោះអ្នកគួរតែប្រើនូវ protected keyword ព្រោះវា អនុញ្ញាត អោយអ្នក accesse វាពClass ដែលអ្នកបាន derived ហើយយើងនឹង បានឃើញ វានៅក្នុងផ្នែកមួយដែលនិយាយពី Inheritance ។

9. Limiting Access to Object Methods .លក្ខណៈសំខាន់នៃ object-oriented code គឺជា class ។ Object ត្រូវតែកំណត់នូវមុខងារនិង Public interface អោយបានច្បាស់លាស់ នៅពេលអ្នកបង្កើតនូវ methods ផ្សេងៗ ។បំណែកដែលមាននៅក្នុង classគឺផ្ទុកនូវមុខងារ ផ្សេងៗ សំរាប់តំ

ណើរការដូច្នេះអ្នកគួរតែលាក់នូវមុខងារទាំងនោះពីពិភពខាងក្រៅ។ សំរាប់ជាឧទាហរណ៍ខាងលើយើង គួរតែ បង្កើតនូវ method សំរាប់ $personStr property ពីព្រោះរាល់តំណើរការទាំងអស់របស់ $personStr ត្រូវបានផ្ទុកនៅក្នុង setName() method ។
function setName( $n )
{
$this->name = $n;
$this->$personStr=$this->name.” “.$this->pid;
} .
អ្នកប្រហែលជាត្រូវការនូវ method ដើម្បី reset នូវ string របស់ $personStr ដូច្នេះយើងនឹងបង្កើតនូវ
Method ថីមួយសំរាប់ ផ្ដល់តំលៃទៅអោយ $personStr property ។
function setName( $n )
{
$this->name = $n;
$this->makePersonStr( $n, $this->code );
}
function makePersonStr( $string , $code)
{
return $this->personStr = “$string $code”;
}

ឥឡូវនេះយើងនៅតែមានបញ្ហានៅឡើយជាមួយនឹង method របស់យើង ពីព្រោះ client code នៅតែអាចAccess នូវ makePersonStr() method ហើយវាអាចធ្វើឱៀ ទិន្នន័យរបស់ យើងមាន ការពិបាក គ្រប់គ្រង ។ យើងចង់អោយត្រឹមតែ object ដែលជាអ្នកបង្កើតនូវ property តែមួយគត់ ដែល មានសិទ្ធ Access មក កាន់ property នេះ នៅក្នុងជំនាន់របស់ PHP 5 យើងអាចផ្ដល់នូវ លក្ខណៈ  pravicy ទៅអោយ methods ដូចដែលយើងបានអនុវត្ដន៍ជាមួយនឹង private property ពីឧទាហរណ៍មុន ។

private function makePersonStr($string , $code) .
{
// …
}
ឥឡូវនេះ makePersonStr() function អាច access បានតែនៅក្នុង method ទាំងឡាយណាដែលឋិតក្នុង Person class ប៉ុណ្ណោះ ។
Public, protected ហើយនឹង private វាតំណើរបានតែជាមួយនឹង PHP 5 តែប៉ុណ្ណោះ ដូច្នេះប្រសិនបើអ្នកព្យាយាម
ប្រើនូវ keyword ទាំងបីនេះជាមួយ PHP 4 នោះ script របស់អ្នកនឹងត្រូវបរាជ័យទាំងស្រុង ។
10.Inheritance . ដើម្បីបង្កើត class មួយដែលអាច inherits function ពី parent class យើងប្រហែលជាត្រូវកែប្រែនូវការ declare class របស់យើងបន្ដិចបន្ដួច ។ ឧទាហរណ៍ថ្មីខាងក្រោមនេះ គឺជាការបង្ថើតនូវ Item Class ហើយនិង បង្ថើតនូវ inheriting class ដែលផ្ដល់ឈោះថា PriceItem ។
ឧទាហរណ៍ ៤៣
Creating a Class That Inherits from Another >

 
 

Creating Class That Inherits from Another

 
  class Item
  {
var $name;

  function Item( $name=”item”, $code=0)
  {
  $this->name = $name;
  $this->code = $code;
  }

  function getName()
  {
  return $this->name;
  }
  }
  class PriceItem extends Item
  {
  ………………………………
  ………………………………
  }
 $item = new PriceItem( “Angkor”, 4545 );
 print $item->getName ();
  // outputs “Angkor”
 ?>
 

យើងបានបង្កើតនូវ class មួយទៀតដែលមានឈោះថា PriceItem នៅបន្ទាត់ទី ២១ ។ គួរចំនាំ
ថា extends clause ដែលប្រើប្រាស់នៅខាងក្នុងការ declare class នៅបន្ទាត់ទី២១ នេះមានន័យថា PriceItem object inherits រាល់ function ទាំងអស់ដែលមាននៅក្នុង Item class ដូច្នេះ PricteItem Object និមួយៗគឺមានលទ្ធភាព access ទៅកាន់ getName() method ឬ $name property ប៉ុន្ដែ ក៏អាស្រ័យទៅលើការប្រើប្រាស់នូវ privacy settings ផងដែរ ។ ដោយសារតែយើង ពុំបានបង្កើតនូវ Constructor method សំរាប់ PriceItem class ដូច្នេះតើ $name property វាអាចធ្វើការផ្លាស់ផ្ដូរតំលៃ ពី default “item” ទៅជា “Angkor” ដោយបញ្ជូនទៅតាម PriceItem បានយ៉ាងដូចម្ដេច ? ពីព្រោះយើង
ពុំបានផ្ដល់នូវ contructor នៅក្នុង PriceItem នោះទេ ដូច្នេះប្រសិនបើ class ដែល extend ពី class ដទៃ
ទៀតមិនមាននូវ constructor method នោះ contructor ដែលជារបស់ parent class នឹងត្រូវបាន
ហៅដោយស្វ័យប្រវត្ដិនៅពេលដែល child object ចាប់ផ្ដើមបង្កីតឡើង ។
11. Overriding the Method of a Parent Class .
នៅក្នុងលក្ខណៈនៃ object-oriented កូដរបស់ child classes អាច override methods ពី Parents class នឹងអនុញ្ញតិអោយ objects អាច instantiated ពី parent class ។
The Method of a Child Class Overriding That of Its Parent >.
ឧទាហរណ៍ ៤៤
    class Item
  {
 var $name;

  function Item( $name=”item”, $code=0)
  {
  $this->name = $name;
  $this->code = $code;
 }

  function getName()
  {
  return $this->name;
  }
  }

 class PriceItem extends Item
  {
  function getName()
  {
  return “(price).”$this->name;
 }
 }

  $item = new PriceItem( “widget”, 5442 );
 print $item->getName();
  // outputs “(price) Angkor”
 ?>
getName() method ដែលបង្កើតនៅក្នុង PriceItem class នៅបន្ទាត់ទី ២០ ត្រូវបានហៅ
ដោយប្រើប្រាស់នូវ $name property របស់ parent class ដែលនៅចំនុចនេះយើងគួរតែធ្វើការសំរេចចិត្ដ
បង្កើតនូវ $name property ដែលមាននៅក្នុង Item class ជា private ។
class Item
{
private $name;
// …
}
ការផ្លាស់ប្ដូរនូវឧទាហរណ៍ខាងលើធ្វើអោយលទ្ធផលមានភាពប្រែប្រួលដូចខាងក្រោម-
លទ្ធផលដែលទទួលបានមុនពេលធ្វើការផ្លាស់ប្ដូរ គឺ (price) Angkor លទ្ធផលថដែល នឹងទទួល បានគឺ (price) ឥឡូវនេះ PriceItem class មិនអាច access ទៅកាន់ $name property