មេរៀនទី៦: 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).”<br />”; .
print “\$obj2 is an “.gettype($obj2).”<br />”; .
អ្នកអាច 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<br />”; >
print “$obj2->name<br />”; >
?>
( -> ) operator នេះអនុញ្ញាតអោយអ្នកធ្វើការ access ឬ ផ្លាស់ប្ដូរនូវតំលៃរបស់ properties នៃObject ។ យើងបានផ្ដល់នូវតំលៃ “Soporn” ទៅអោយ $name property តាមរយៈ $obj1->name ។
4. Object Methods . Method គឺជា function ដែល defined នៅក្នុង class ។ គ្រប់ object ដែលបាន instantiatedពី class តែងតែមាន method‟s ជានិច្ច យើងនឹងបន្ថែមនូវ method មួយទៅអោយ Person class នៅ
ឧទាហរណ៍ ៣៨ ។
01: <?php
02:
03: class Person
04: {
05: var $name = “Vichet”;
06:
07: function getName()
08: {
09: return “Ratana”;
10: }
11:
12: }
13:
14: $person = new Person();
15: print $person->getName();
16: // outputs “Ratana”
17: ?>
ដូចដែលអ្នកបានជួបប្រទះមកហើយអំពី 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 .ឧទាហរណ៍ ៣៩
01: <html>
02: <head><titile>Accessing a property from within a method</title>
03: </head>
04: <body>
05: <h2>Accessing a property from within a method</h2>
06:
07: <?php
08:
09: class Person
10: {
11: var $name = “Thary”;
12:
13: function getName()
14: {
15: return $this->name;
16: }
17: }
18:
19: $person = new Person();
20: $person->name = “Bopha”;
21: print $person->getName();
22: //outputs “Bopha”
23: ?>
24: </body>
25: </html>
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 .
ឧទាហរណ៍ ៤០
01: <html>
02: <body>
03: <head><title>Changing the value of a property from within a method</tile>
04: </head>
05: <body>
06: <h2>Changing the value of a property from within a method</h2>
07:
08: <?php
09:
10: class Person
11: {
12: var $name = “tepy”;
13:
14: function setName( $n )
15: {
16: $this->name = $n;
17: }
18:
19: function getName()
20: {
21: return $this->name;
22: }
23: }
24:
25: $person = new Person();
26: $person->setName(“darya”);
27: print $person->getName();
28: // outputs “darya”
29:
30: ?>
31:
32: </body>
33: </html>
$name propertyនៃ object ចាប់ផ្ដើមដោយតំលៃ
string “tepy”នៅបន្ទាត់ទី១២ ប៉ុន្ដែបន្ទាប់ពី setName() method
ត្រូវបានហៅនៅបន្ទាត់ទី 26 តំលៃរបស់វាត្រូវបានប្ដូរទៅជា “darya” វិញ ។
Object គឺមានលទ្ធភាពផ្លាស់ប្ដូរនូវ property របស់ខ្លួនឯងបាន
ហើយសំរាប់ការបញ្ជូននូវ arguments ទៅកាន់ method វិញគឺអ្នកអាចប្រើនូវវិធី
ដូចដែលអ្នកអនុវត្ដន៍វាជាមួយ function ធមតាដែរ ។
7. Object Constructors .
នៅឧទាហរណ៍មុនយើងបានប្រើប្រាស់ method មួយឈោះថា setName()
ដើម្បីធ្វើការផ្លាស់ប្ដូរតំលៃរបស់ $name property ម្យ៉ាងវិញទៀត
ការផ្ដល់នូវតំលៃ តំបូងសំរាប់ $name property នៅក្នុង Class គឺ hard-code
។var $name = “tepy”; . ប្រសិនបើយើងគិតថា $name property
ផ្ទុកនូវតំលៃផ្សេងៗគ្នា រាល់ពេលដែល instance នៃ Person class
យើងអាចធ្វើអោយកាន់តែប្រសើរជាងមុនដោយការ set $name property នៅពេលដែល Object
ត្រូវបាន initialize។ យើងអាចប្រើប្រាស់ special function ដែលគេ អោយឈោះថា
constructor ដើម្បី set properties និងបំពេញការងារផ្សេងៗ ទៅតាម តំរូវការ
នៃការងារ។ constructor គឺត្រូវហៅដោយ ស្វ័យប្រវត្ដិនៅពេលដែល object ត្រូវបាន
instantiated ដោយការប្រើប្រាស់ new keyword ។
អ្នកអាចបង្កើតនូវ constructor តាមវិធីសាស្ដ្រពីរយ៉ាង ទី១ គឺ constructor
ដែលជា function មានឈោះដូច class ។ ឧទាហរណ៍ ៤១ នឹងបន្ថែមនូវ constructor
សាមញ្ញមួយទៅអោយ Person Class ដែលកូដខាងក្រោមនេះប្រើប្រាស់បានសំរាប់តែ PHP 5
ប៉ុណ្ណោះ ។ឧទាហរណ៍ ៤១ A Class with a Constructor
01: <html>
02: <head>
03: <title>A Class with a Construct</title>
04: </head>
05: <body>
06: <h2>A Class with a Construct</h2>
07:
08: <?php
09:
10: class Person
11: {
12: var $name;
13:
14: function Person($name=”tepy”)
15: {
16: $this->name = $name;
17: }
18: function setName( $n)
19: {
20: $this->name = $n;
21: }
22:
23: function getName()
24: {
25: return $this->name;
26: }
27: }
28:
29: $person = new Person(“darya”);
30: print $person->getName ();
31: // outputs “Darya”
32:
33: ?>
34:
35: </body>
36: </html>
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
01: <?php
02: class Person
03: {
04: var $name;
05: var $pid;
06: var $personStr;
07:
08: function Person( $name=”somphy”, $pid=0 )
09: {
10: $this->name = $name;
11: $this->pid = $pid;
12: }
13:
14: function setName( $n )
15: {
16: $this->name = $n;
17: $this->$personStr=$this->name.” “.$this->pid;
18: }
19:
20: function getName ()
21: {
22: return $this->name;
23: }
24: }
25: $person = new Person(“sovan”,5233);
26: print $person->PersonStr();
27: // outputs “sovan 5233″
28: print “<br />”;
29: $person->name = “makara”;
30: ?>
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 >
01: <html>
02: <body>
03: <h1>Creating Class That Inherits from Another</h1>
04: <?php
05:
06: class Item
07: {
var $name;
09:
10: function Item( $name=”item”, $code=0)
11: {
12: $this->name = $name;
13: $this->code = $code;
14: }
15:
16: function getName()
17: {
18: return $this->name;
19: }
20: }
21: class PriceItem extends Item
22: {
23: ………………………………
24: ………………………………
25: }
26: $item = new PriceItem( “Angkor”, 4545 );
27: print $item->getName ();
28: // outputs “Angkor”
29: ?>
30: </body>
31: </html>
យើងបានបង្កើតនូវ 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 >.
ឧទាហរណ៍ ៤៤
01: <?php
02: class Item
03: {
04: var $name;
05:
06: function Item( $name=”item”, $code=0)
07: {
08: $this->name = $name;
09: $this->code = $code;
10: }
11:
12: function getName()
13: {
14: return $this->name;
15: }
16: }
17:
18: class PriceItem extends Item
19: {
20: function getName()
21: {
22: return “(price).”$this->name;
23: }
24: }
25:
26: $item = new PriceItem( “widget”, 5442 );
27: print $item->getName();
28: // outputs “(price) Angkor”
29: ?>
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 ទៀតបានទេ ប៉ុន្ដែប្រសិនបើ Child class ត្រូវការ access ទៅកាន់ methods ឬ property នៃ ancestor classes យើគួរតែប្រើនូវ Protected keyword ជំនួសអោយ private វិញ ។
12. Calling an Overridden Method .
មានពេលខ្លះ function ដែលមាននៅក្នុង parent class អាចមានផលប្រយោជន៍សំរាប់អ្នក ដូច្នេះ
សំរាប់ Object-oriented-programmingអនុញ្ញាតិអោយអ្នក refer ទៅកាន់ parent class ដោយប្រើនូវ
parent keyword ។ ឧទាហរណ៍ខាងក្រោមនេះ getName() method ដែលឋិតនៅខាងក្នុង PriceItem
Class នឹង call នូវ method នៅក្នុង Item class ដែលបានត្រូវ override។
Calling an Overridden Method (PHP 5 Syntax)
ឧទាហរណ៍ ៤៥
01: <?php
02: class Item {
03: private $name;
04:
05: function __construct( $name=”item”, $code=0 ) {
06: $this->name = $name;
07: $this->code = $code;
08: }
09:
10: function getName() {
11: return $this->name;
12: }
13: }
14:
15: class PriceItem extends Item {
16: function getName() {
17: return “(price) “.parent::getName ();
18: }
19: }
20:
21: $item = new PriceItem (“widget”, 5442);
22: print $item->getName();
23: // outputs “(price) widget”
24:
25: ?>
យើងបានធ្វើការជាមួយនឹង getName() method នៅក្នុង PriceItem class បន្ទាត់ទី ១៧ ។
PriceItem class មិនធ្វើការផ្ទាល់ជាមួយនឹង $name property របស់ Item class នោះទេ ដូច្នេះនៅចំនុច នេះយើងអាច declare $name property ជា private ដែលមិនធ្វើអោយ មាន ផលប៉ះពាល់ជាមួយនឹង លទ្ធផលនោះទេ ហើយប្រសិនបើយើងប្រើវាជាមួយនឹង PHP 5 ទៀតនោះ វាគឺជាការអនុត្ដន៍ដ៏ល្អ ដើម្បី Lock នូវ methods និង property របស់យើង ។
13. Working with Constructors .
យើងធ្លាប់បានឃើញមកហើយថា constructor របស់ parent class នឹងត្រូវ called ដោយស្វ័យ
ប្រវត្ដិប្រសិនបើ child class មិនបានបង្កើតនូវ constructor សំរាប់ខ្លួនវានោះទេ ។ យើងនឹងបន្ថែមនូវ
Constructor method ទៅអោយ PriceItem class របស់យើងជាមួយនឹងឧទារហណ៍ខាងក្រោម ។
ឧទាហរណ៍ ៤៦ Adding a Constructor to PriceItem
01: <?php
02: class Item
03 {
04: private $name;
05: function __construct( $name=”item”, $code=0 ) {
06: $this->name = $name;
07: $this->code = $code;
08: }
09: function getName () {
10: return $this->name;
11: }
12: }
13: class PriceItem extends Item
14: {
15: private $price;
16: function __construct( $name, $code, $price ) {
17: parent::__construct( $name, $code );
18: $this->price = $price;
19: }
20:
21: function getName() {
22: return “(price) “.parent::getName ();
23: }
24: }
25:
26: $item = new PriceItem (“widget”, 5442, 5.20);
27: print $item->getName ();
28: // outputs “(price) widget”
29:
30: ?>
យើងបានបង្កើតនូវ constructor method នៅបន្ទាត់ទី១៦ ដើម្បីទទួល argument សំរាប់
$name និង $codeព្រមជាមួយនឹង argument ថីសំរាប់ price។ យើងបានប្រើប្រាស់ parent keyword
ដើម្បី call constructor របស់ Item class នៅបន្ទាត់ទី២២ មុនពេលដែលយើងធ្វើការរៀបចំតំលៃអោយ
$price property ដែលនេះបង្ហាញអោយយើងឃើញពីហេតុផលមួយសំរាប់ប្រើនូវ syntax ថីរបស់ PHP5 ដើម្បីបង្កើត contructor ។
parent::__construct( $name, $code );
Post a Comment