20. பொருள் நோக்கு நிரலாக்கம் (Object Oriented Programming)
பொருள்நோக்கு நிரலாக்கத்திற்கு PHP நன்கு ஆதரவு தருகிறது. பொருள்நோக்கு நிரலாக்கம் என்பது ஒரு பெரிய பகுதி இந்த தொடரில் மட்டுமே அதை பார்த்து விட முடியாது. இதற்கென தனியாக ஒரு புத்தகமே எழுதினாலும் போதாது அந்தளவிற்கு நிறைய செய்திகள் பொருள்நோக்கு நிரலாக்கத்தில் உள்ளது. PHP -யில் அனைத்தும் இருக்கிறது என்ற வகையில் OOP தொடர்பானவற்றையும் பார்த்து விடவேண்டும் என்ற நோக்கில் இதை எழுதியுள்ளேன். PHP யில் பொருள் நோக்கு நிரலாக்கம் எப்படி செய்வது? என்பது தொடர்பான அடிப்படை செய்திகளை இங்கு காண்போம்.
Object என்றால் என்ன?
Object என்பது செயல்கூறுகளின் பகுதிகளை சுயமாக கொண்டுள்ள ஒன்றாகும். இதை நாம் எளிமையாக பயன்படுத்திக்கொள்ளலாம் மற்றும் மறுசுழற்சியும் செய்துகொள்ளலாம்.
Objects தகவல் மாறிலிகள் மற்றும் செயல்கூறுகளைக் கொண்டிருக்கும். Object ஐ பொறுத்தமட்டிலே செயல்கூறுகள்(functions) methods என அழைக்கப்படுகிறது. இவைகளை நமது பணிகளை முடிப்பதற்காக Object மூலமாக அழைத்துக்கொள்ளலாம். இவைகளனைத்தும் மொத்தமாக உறுப்பினர்கள்(members) என்று அழைக்கப்படுகிறது.
Class என்றால் என்ன?
Class என்பது, ஒரு கட்டிடத்தை கட்டுவதற்கு முன் அந்த கட்டிடத்திற்கான வரைபடத்தை தயாரிப்பதைப் போன்றது. கட்டிடம் கட்டப்படும் போது ஒவ்வொரு பொருளும் எப்படி தோற்றமளிக்க வேண்டும்? என வரைபடத்தில் சொல்லப்படுகிறது இல்லையா? அதுபோல Object உருவாக்கும் போது அது எப்படி தோற்றமளிக்க வேண்டும் என்பதை Class வரையறை செய்கிறது. உதாரணமாக methods கள் என்ன செய்ய வேண்டும், உறுப்பினர்கள்(members) எப்படி இருக்க வேண்டும் போன்றவற்றை வரையறை செய்கிறது.
Class –லிருந்து Object ஐ உருவாக்குவது எப்படி?
வரைபடத்திலிருந்து கட்டிடம் கட்ட ஆரம்பிப்பதைப் போன்றதுதான் object உருவாக்குவதும். வரைபடத்தை வைத்துக்கொண்டு என்ன செய்வது, அதை பயன்பாட்டிற்கு கொண்டுவரவேண்டுமல்லவா, அது போலவே Class லிருந்து Object உருவாக்குவதும். வெறும் Class வைத்துக்கொண்டு என்ன செய்வது, அதை பயன்பாட்டிற்கு கொண்டு வர Object தேவை. ஒரு Class லிருந்து எத்தனை Object ஐ வேண்டுமானாலும் உருவாக்கிக்கொள்ளலாம். ஒருவரைபடத்தைக் கொண்டு எத்தனைக் கட்டிடத்தை வேண்டுமானாலும் கட்டலாம் அல்லவா அதுபோலத்தான்.
Object ஐக் கொண்டு Class இல் இருக்கும் methods மற்றும் மாறிலிகளை நான் அணுக முடியும் மற்றும் பயன்படுத்திக்கொள்ள முடியும். உதாரணமாக bankAccount எனும் class இன் Object ஐ கீழ்காணுமாறு உருவாக்க முடியும்.
$accountObject = new bankAcccount();
sub-classing என்றால் என்ன?
ஒரு class லிருந்து இன்னொரு class ஐ உருவாக்குவதை sub-class என்கிறோம். இதன்மூலமாக ஏற்கனவே உள்ள ஒரு class இன் variables மற்றும் methods நான் புதிதாக உருவாக்கும் ஒரு class க்கும் கொண்டுவர முடியும். புதிதாக உருவாக்கப் போகும் class க்குத் தேவையானவைகள் 50% ஏற்கனவே உள்ள class இல் இருக்கும் போது, ஏற்கனவே உள்ளவற்றையே நாம் பயன்படுத்திக்கொண்டால் என்ன? 50% வேலைகள் மிச்சப்படுமில்லையா.
car எனும் class ஐ நீங்கள் உருவாக்குவதாக வைத்துகொள்வோம், அதற்கென்று சிறப்பாக உள்ளவற்றைத் தவிர்த்து மற்றவையெல்லாம் vechile எனும் class இல் ஏற்கனவே உள்ளதென்றால் அதை நாம் பயன்படுத்திக்கொள்ளலாம். இதுதான் sub-class. இங்கு vechile class ஆனது Parent class எனவும், car class ஆனது child class அல்லது sub-class எனவும் அழைக்கப்படுகிறது.
PHP class ஐ வரையறை செய்தல்
கட்டிடம் கட்டுவதெல்லாம் சரி அதற்கு வரைபடம் வேண்டுமல்லவா? Object ஐ உருவாக்குவதற்கு முன்பு Class வேண்டுமல்லவா? PHP யில் class ஐ உருவாக்க class எனும் முதன்மைச்சொல்(keyword) பயன்படுத்தப்படுகிறது. Class இன் உடலை(body) வரையறை செய்ய curly braces ({}) பயன்படுத்தப்படுகிறது.
<?php
class bankAccount {
}
?>
இப்பொழுது நாம் புதிதாக ஒரு class ஐ உருவாக்கிவிட்டோம். அடுத்து அதில் சில செயல்கூறுகளை சேர்ப்பது பற்றிப் பார்ப்போம்.
PHP class உருவாக்குதல் மற்றும் சிதைத்தல் (class constructors and destructors)
அடுத்தபடி என்னவென்றால், Object ஐ உருவாக்கும் போது என்ன நடக்க வேண்டும் என்பதை வரையறை செய்வது. இறுதியில் Object ஐ சிதைப்பது. இந்த இரண்டு செயல்களும் constructor மற்றும் destructor method களை பயன்படுத்தி வரையறை செய்யப்படுகிறது.
Constructor மற்றும் destructor இரண்டும் செயல்கூறுகள்தான்(functions) function எனும் முதன்மைச் சொல்லை பயன்படுத்தி அழைக்கப்படுகிறது. Function முதன்மைச் சொல்லுக்கு முன் public எனும் qualifier பயன்படுத்த வேண்டும். public qualifier பயன்படுத்துவதால் object க்கு வெளியேயும் function ஐ நாம் பயன்படுத்த முடியும்.
constructor மற்றும் destructor ஆகிய இரண்டுக்கும் இருப்பியல்பான பெயர்கள் __construct மற்றும் __destruct ஆகும். function -னில் argument கொடுப்பதுபோல __construct and __destruct இரண்டுக்கும் கொடுத்துக்கொள்ளலாம்.
உதாரண நிரலைப் பாருங்கள்
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
|
<?phpclass myProfile {public function __construct($myName, $myAge) {echo '<b style="color:green;">Object was just instatiated</b><br>';echo '<b>Name: </b>'.$myName.'<br>';echo '<b>Age: </b>'.$myAge.'<br>';echo '<hr>';}public function __destruct() {echo '<b style="color:red;">Object was destroyed. Bye</b><br>';}}$myProfileObject_one = new myProfile('KATHIRVEL RAJENDRAN', 26);// Create another object$myProfileObject_two = new myProfile('LINUX KATHIRVEL', 26);?> |
PHP class இல் உறுப்பினர்கள்(members) உருவாக்குதல்
class -க்குள் இருக்கும் அத்தியாவசியமான மாறிலிகள் மற்றும் செயல்கூறுகள் class members எனப்படுகின்றன. Members public அல்லது private ஆக இருக்கலாம், static அல்லது variable ஆக இருக்கலாம்.
public members ஐ object க்கு வெளியிலும் பயன்படுத்த முடியும். private members ஐ அதனுடைய class க்குள் மட்டுமே பயன்படுத்த முடியும். இதுவே data encapsulation என்று அழைக்கப்படுகிறது.
Static member இன் மதிப்பை மாற்றமுடியாது, வரையறை மட்டும்தான் செய்ய முடியும். Members மற்றும் செயல்கூறுகளை(functions) class உள்ளே வரையறை செய்யும்போது, இவைகள் public, private மற்றும் static ஆகிய முதன்மைச்சொல்லினை முன்இணைப்பாக கொண்டு இருக்கும். Default ஆக public என்று இருக்கும்.
உதாரண நிரலைப் பாருங்கள்:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
|
<?phpclass LinuxProfile {public $creator;public $kernel;public $icon;// This variable is private.private $os;public function __construct($creator, $kernel, $icon, $os) {$this->creator = $creator;$this->kernel = $kernel;$this->icon = $icon;$this->os = $os;echo $this->os;echo '<br>';}}// Create object for LinuxProfile class$linux = new LinuxProfile('Linus', '3.13', 'Tux', 'Ubuntu 14.04.2 LTS');// Access members using objectsecho 'Creator of GNU/Linux Kernel :'.$linux->creator;echo '<br>';echo 'Kernel version :'.$linux->kernel;echo '<br>';echo 'Icon of GNU/Linux :'.$linux->icon;// This variable will not print due to private.echo $linux->os;?> |
மேலே உள்ள நிரலில் நாம் public எனும் முதன்மைச்சொல்லை பயன்படுத்தியுள்ளேன். அதனால் class க்கு வெளியிலும் $creator, $kernel, $icon variable களை அணுக முடிந்துள்ளது. Private ஆக வரையறுத்துள்ள $os ஐ class -க்கு வெளியில் அணுக முடியவில்லை.
Methods ஐ வரையறை செய்தல் மற்றும் அழைத்தல்(Defining and Calling Methods)
நாம் ஏற்கனவே constructor மற்றும் destructor method களை உருவாக்கியதுபோல, நாம் நம்முடைய சொந்த methods களை அதே வழியில் உருவாக்கிக்கொள்ளலாம். நாம் விரும்பிய பெயரையும் methods களுக்கு கொடுத்துக்கொள்ளலாம். உதாரண நிரலை பாருங்கள்.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
<?phpclass User {private $firstName;private $lastName;public function __construct($fname, $lname) {$this->firstName = $fname;$this->lastName = $lname;echo '<h1>This name come from constructor function.</h1><br>';echo $this->firstName.' '.$this->lastName;echo '<br>';}public function __destruct() {echo '<h1>destructor function</h1>';echo 'Object was destroyed <br>';}public function setUserDetails($userName, $fatherName) {$this->firstName = $userName;$this->lastName = $fatherName;}public function getUserDetails() {return $this->firstName.' '.$this->lastName;}}// Create object to access methods$user1 = new User('Kathirvel', 'Rajendran');$user2 = new User('Linux', 'Kathirvel');$user1->setUserDetails('Richard Matthew', 'Stallman');echo '<h1>This name from getUserDetails function.</h1>';echo $user1->getUserDetails();?> |
Object ஐத் தொடர்ந்து ‘->’ ஐப் பயன்படுத்தி getUserDetails method ஐ அழைத்துள்ளோம்.
Subclassing in PHP
ஒரு class லிருந்து இன்னொரு class ஐ உருவாக்குதல் subclass எனப்படும். ஒரு class ஐ உருவாக்கிவிட்டாலே, அதிலிருந்து நம்மால் புதியதாக ஒரு class ஐ உருவாக்கிக்கொள்ள முடியும். இந்த முறைக்கு Inheritence என்று பெயர். Extends எனும் முதன்மைச்சொல்லைப் பயன்படுத்தி நாம் subclass ஐ உருவாக்கிக்கொள்ளலாம்.
கீழே உள்ள நிரலில் ParentClass இல் உள்ள name, email விபரங்களை, childclass object ஐ பயன்படுத்தி print செய்துள்ளோம். அதாவது ParentClass variables களை ChildClass பயன்படுத்தியுள்ளது. Methods களையும் இதுபோல பயன்படுத்திக்கொள்ளலாம்.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
<?phpclass ParentClass {public $name = 'Kathirvel';public $email = 'linuxkathirvel.info@gmail.com';}class ChildClass extends ParentClass {public $mobile = '9988776655';}$childclass = new ChildClass();// print name, email using child classecho $childclass->name;echo '<br>';echo $childclass->email;echo '<br>';echo $childclass->mobile;?> |
ChildClass மூலமாக ParentClass இன் method ஐ பயன்படுத்திக்கொள்ளுதல்
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
<?phpclass ParentClass {public $message1 = 'GNU/Linux is rule the world.<br>';public function printMessage() {echo $this->message1;}}class ChildClass extends ParentClass {public $message2 = 'I am ChildClass.<br>';}// Create ChildClass object$child = new ChildClass();// call printMessage method through ChildClass$child->printMessage();echo $child->message2;?> |
PHP Object Serialization
object ஐ serialize செய்வதற்கு serialize() எனும் செயல்கூறு பயன்படுத்தப்படுகிறது. Unserialize செய்ய unserialize() செயல்கூறு பயன்படுத்தப்படுகிறது.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
<?phpclass UserProfile {public $firstName;public $lastName;public $email;public $mobile;public function __construct($name, $fatherName, $email, $mob) {$this->firstName = $name;$this->lastName = $fatherName;$this->email = $email;$this->mobile = $mob;}}// Create object$profile = new UserProfile('Kathirvel', 'Rajendran', 'linuxkathirvel.info@gmail.com', '9988776655');// Serialize using serialize() function$ser = serialize($profile);// print serialized valuesecho $ser;?> |
PHP Object பற்றிய தகவல்களைப் பெறுதல்
get_declared_classes() – Declare செய்துள்ள class பெயர்களை array வடிவில் கொடுக்கும்.
class_exists() – Class பெயரை உள்ளீடாக கொடுத்தால், இருக்கிறதொன்றால் 1 என்று வெளியீடு வரும். இல்லையென்றால் எதுவும் வெளியீடாக வராது.
get_class_methods() – பயன்படுத்தியுள்ள methods களின் பெயர் பட்டியலைக் கொடுக்கும்.
get_parent_class() – Parent class களின் பட்டியல் கொடுக்கும் இல்லையென்றால் empty stringஐ வெளியிடும்.
method_exists() – method பெயரைக் argument ஆக கொடுத்தால் இருக்கிறதென்றால் true எனவும், இல்லையென்றால் false எனவும் வெளியீட்டைக்கொடுக்கும்.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
|
<?phpclass ParentClass {public $message1 = 'GNU/Linux is rule the world.<br>';public function printMessage() {echo $this->message1;}}class ChildClass extends ParentClass {public $message2 = 'I am ChildClass.<br>';}// Create ChildClass object$child = new ChildClass();// call printMessage method through ChildClass$child->printMessage();echo $child->message2;// Get declared class names, It will print as Array.echo '<br><hr>';echo '<b>Declared Classes List<br></b>';print_r(get_declared_classes());// Find Class Exist or notecho '<br><hr>';echo '<b>Class Exist or not. (1=YES, otherwise=NO)</b><br>';echo "ChildClass Exist:".class_exists('ChildClass').'<br>';echo "ParentClass Exist:".class_exists('ParentClass').'<br>';echo "KathirvelClass Exist:".class_exists('KathirvelClass').'<br>';?> |
