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

មេរៀនទី៦: 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 ថីនេះនៅក្នុងតារាងខាងក្រោម

a

ដូច្នេះយើងអាចផ្លាស់ប្ដូរ 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 );