PHP Դասեր - Դաս 13 - ՕՕԾ-ի (օբյեկտ-ориենտացված ծրագրավորման) հիմունքները

Եթե դուք կարդացել եք PHP դասերի նախորդ դասերը, ուրեմն արդեն ծանոթ եք հետևյալ տվյալների տիպերին՝ բուլյան, ամբողջ թվային, կոտորակային, տեքստային, զանգվածներ։ Այս դասում ես կպատմեմ ևս մեկ տվյալների տիպի մասին, որը հասանելի է PHP-ում՝ օբյեկտ:
Օբյեկտները ինչ-որ չափով նման են զանգվածներին, դրանք նույնպես կարող են պարունակել տարբեր տեսակի տվյալներ՝ թվեր, տեքստ, զանգվածներ, նույնիսկ այլ օբյեկտներ։

Օբյեկտները կարող են պարունակել այլ տվյալներ, ինչպես զանգվածները։ Այդ դեպքում այդ տվյալները մենք անվանում ենք հատկություններ (դաշտեր)։ Բացի այդ, օբյեկտները կարող են պարունակել նաև ֆունկցիաներ իրենց ներսում, որոնք կոչվում են մեթոդներ։

Բայց օբյեկտներն ունեն երկու կարևոր տարբերություն զանգվածներից՝

1. Օբյեկտները կարող են պարունակել մեթոդներ։

Մեթոդները այն ֆունկցիաներն են, որոնք կանչվում են օբյեկտի անունից։ Ֆունկցիաների կապակցումը օբյեկտին թույլ է տալիս որոշել, թե ինչ գործողություններ է կատարում օբյեկտը և ինչ գործողություններ կարելի է կատարել այդ օբյեկտի հետ։

2. Օբյեկտները ստեղծվում են դասերից։

Մինչև օբյեկտ ստեղծելը մենք պետք է սահմանենք դաս։ Դասի մեջ նկարագրում ենք, թե ինչ դաշտեր և մեթոդներ պետք է ունենա օբյեկտը։ Սա թույլ է տալիս սահմանել օբյեկտի կառուցվածքը և պարզեցնել հասկանալը, թե ինչ տվյալներ պետք է պահի օբյեկտը և ինչ գործողություններ պետք է կատարի։ Երբ մենք ստեղծում ենք օբյեկտ դասից, կարող ենք այն լրացնել սկզբնական տվյալներով՝ ապահովելով, որ նոր ստեղծված օբյեկտները դատարկ չլինեն։

Օբյեկտը, հավանաբար, ամենահարմար կոնտեյներ է տվյալներ պահելու համար։ Օբյեկտները PHP-ում օգնում են համեմատել իրական աշխարհի օբյեկտների հետ։ Օրինակ՝ ունենք տվյալների բազա, որտեղ պահվում են գրքերի մասին տվյալներ։ Գրքի տվյալներն են՝ հեղինակ, էջերի քանակ, հրատարակիչ, թողարկման համարը, գրախոսություն, տպագրական տվյալներ։ Ուստի՝ տվյալների հետ հարմար աշխատելու համար դրանք խմբավորում ենք «Գիրք» դասում, որը ներառում է հատկություններ՝ Հեղինակ, Էջերի քանակ, Հրատարակիչ, Թողարկման համար, Գրախոսություն, Տպագրական տվյալներ և այլն։ Այդպես մենք ստեղծում ենք օբյեկտներ, որոնք նման են իրական գրքերին։ Սա հատկապես հարմար է, քանի որ կայքի տվյալները պահվում են աղյուսակներում՝ դաշտերով, այնպես որ աղյուսակների անունները կարող ենք դարձնել դասերի անուններ, իսկ դաշտերը՝ դասի հատկություններ։ Արդյունքում տվյալների հետ աշխատանքը զգալիորեն կհեշտանա։

Ավելի մանրամասն մենք կդիտարկենք զանգվածների և օբյեկտների տարբերությունները օրինակների միջոցով։

PHP 5.2 և ավելի բարձր տարբերակների հնարավորությունները՝

Եկեք սկսենք մեր օբյեկտների դասի սահմանումից։ Ուշադրություն դարձրեք՝ «դաս» բառը միավանկ է, իսկ օբյեկտները՝ հոգնակի։ Սա ընդգծում է, որ մեկ դասից կարելի է ստեղծել բազմաթիվ օբյեկտներ՝

<?php
class book{

}
?>

class բառով մենք սահմանում ենք ապագա օբյեկտների դասը։ Այժմ ստեղծենք օբյեկտներ՝

<?php
class book{
  
}

$book1 = new book;
$book2 = new book;
print_r($book1);
print_r($book2);
?>

new բանալի բառով մենք ստեղծում ենք նոր օբյեկտներ book դասից։ Դասի յուրաքանչյուր օբյեկտ անվանվում է դասի օրինակը։ Այսպիսով՝ մենք ունենք book դասի երկու օրինակ՝ $book1 և $book2։ Մենք նաև օգտագործեցինք print_r ֆունկցիաները՝ այդ փոփոխականների պարունակությունը արտածելու համար, և տեսնում ենք՝

Ինչպես տեսնում եք՝ PHP-ն ցույց է տալիս, թե որ դասից է ստեղծվել օբյեկտը։ Եթե օբյեկտում լինեին տվյալներ, դրանք նույնպես կարտածվեին։ Եկեք հիմա ավելացնենք այդ տվյալները։ Նախ պետք է սահմանենք դասի հատկությունները։ Սկսած PHP 5.2-ից՝ հատկությունները սահմանվում են հետևյալ բառերով՝ public, protected, private (հասանելի է նաև հին՝ var գրառումը՝ դրա մասին՝ ստորև)։ Եթե աշխատել եք Delphi կամ C++-ով, ապա հեշտ կլինի, քանի որ այս բառերը նույն կերպ են աշխատում։

public – բաց (հանրային) հատկություններ և մեթոդներ։ Դրանք հասանելի են օբյեկտի ստեղծումից հետո՝ օբյեկտի միջոցով։ Գրքի տվյալները մուտքագրելու համար կօգտագործենք այս բառը։

protected – պաշտպանված հատկություններ և մեթոդներ։ Դրանք կարելի է կանչել միայն դասի ներսում և ժառանգվող (զավակ) դասերում։ Եթե protected մեթոդին փորձենք դիմել դրսից, կստանանք սխալ։ Երբ ուսումնասիրենք ժառանգումը, կխոսենք protected-ի մասին ավելի մանրամասն։

private – փակ (մասնավոր) հատկություններ և մեթոդներ։ Դրանք կարելի է կանչել միայն դասի ներսում, նույնիսկ ժառանգվող դասերում չեն աշխատի։

Եկեք առայժմ չբարդացնենք protected և private-ով և մեր բոլոր հատկությունները և մեթոդները սահմանենք որպես public։

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
}

Այժմ մեր դասում կան հատկություններ, որոնք թույլ են տալիս դասի օրինակներում դիմել այդ հատկություններին՝

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;
$book2 = new book;
print '<pre>';
print_r($book1);
print_r($book2);
print '</pre>';

Արդյունքում ունենք մեկ լրացված օբյեկտ և մեկ դատարկ՝

 

Կարծում եմ այժմ արդեն պարզ է՝ ինչպես կարելի է գրանցել տվյալներ օբյեկտում։ Այժմ եկեք հասկանանք դասի մեթոդները։ Ինչպես նախկինում նշեցի՝ մեթոդները սովորական ֆունկցիաներ են, որոնք կանչվում են օբյեկտի կամ դասի անունից։ Եկեք ավելացնենք մեթոդներ՝ դասի յուրաքանչյուր հատկության արտածման համար՝

<?php

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;

  public function getAuthor(){
    return $this->author;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;

$book2 = new book;

print '<pre>';
print $book1->getAuthor() . '<br />';
print $book1->getNumberOfPages() . '<br />';
print $book1->getYear() . '<br />';
print $book1->getPublishingOffice() . '<br />';
print $book1->getEditionNumber() . '<br />';
print '</pre>';
?>

Այս կերպ մենք կարող ենք դիմել օբյեկտին ոչ թե ուղղակի հատկությունների միջոցով, այլ մեթոդների։ Ուշադրություն դարձրեք $this փոփոխականին։ Այն ներկայացնում է ընթացիկ օբյեկտի ներսում օգտագործվող օբյեկտը։ Այսինքն՝ եթե օբյեկտը $book1 է, ապա դասի ներսում $this->author-ը հավասար է $book1->author։ Դասից դուրս $this փոփոխականը չի աշխատում։ Այժմ եկեք ավելացնենք ևս երկու մեթոդ՝ գրքի ցուցադրումը աղյուսակի և div տարրի տեսքով։

class book{
  public $author;
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;

  public function getAuthor(){
    return $this->author;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }

  public function displayTable(){
    $content = '<table style="border: 1px solid #000">';
    $content .= '<tr><td>Author</td><td>'. $this->getAuthor() . '</td></tr>';
    $content .= '<tr><td>Number of pages</td><td>'. $this->getNumberOfPages() . '</td></tr>';
    $content .= '<tr><td>Year</td><td>'. $this->getYear() . '</td></tr>';
    $content .= '<tr><td>Publishing office</td><td>'. $this->getPublishingOffice() . '</td></tr>';
    $content .= '<tr><td>Edition number</td><td>'. $this->getEditionNumber() . '</td></tr>';
    $content .= '</table>';
    return $content;
  }

  public function displayUnformatted(){
    $content = '<div style="border:1px solid #ddd">';
    $content .= '<label>Author:</label><div>'. $this->getAuthor() . '</div>';
    $content .= '<label>Number of pages:</label><div>'. $this->getNumberOfPages() . '</div>';
    $content .= '<label>Year:</label><div>'. $this->getYear() . '</div>';
    $content .= '<label>Publishing office:</label><div>'. $this->getPublishingOffice() . '</div>';
    $content .= '<label>Edition number:</label><div>'. $this->getEditionNumber() . '</div>';
    $content .= '</div>';
    return $content;
  }
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;

$book2 = new book;
$book2->author = 'Leshkina S.O.';
$book2->numberOfPages = 200;
$book2->year = 2013;
$book2->publishinOffice = 'Moscow';
$book2->editionNumber = 1;

print $book1->displayTable();
print $book2->displayUnformatted();

Մենք արդեն ունենք բավականին ծավալուն կոդ, որը, ինչպես տեսնում եք, հեշտ է կարդալ։ Օ՜, գրքի անվանումը մոռացանք։ Եկեք ավելացնենք name դաշտ և դրա արտածման մեթոդը։

<?php

class book{
  public $author;
  public $name; // ահա ավելացվում է գրքի անունը
  public $numberOfPages;
  public $year;
  public $publishingOffice;
  public $editionNumber;

  public function getAuthor(){
    return $this->author;
  }
  public function getName(){
    return $this->name;
  }
  public function getNumberOfPages(){
    return $this->numberOfPages;
  }
  public function getYear(){
    return $this->year;
  }
  public function getPublishingOffice(){
    return $this->publishingOffice;
  }
  public function getEditionNumber(){
    return $this->editionNumber;
  }

  public function displayTable(){
    $content = '<table style="border: 1px solid #000">';
    $content .= '<tr><td>Author</td><td>'. $this->getAuthor() . '</td></tr>';
    $content .= '<tr><td>Name</td><td>'. $this->getName() . '</td></tr>';
    $content .= '<tr><td>Number of pages</td><td>'. $this->getNumberOfPages() . '</td></tr>';
    $content .= '<tr><td>Year</td><td>'. $this->getYear() . '</td></tr>';
    $content .= '<tr><td>Publishing office</td><td>'. $this->getPublishingOffice() . '</td></tr>';
    $content .= '<tr><td>Edition number</td><td>'. $this->getEditionNumber() . '</td></tr>';
    $content .= '</table>';
    return $content;
  }

  public function displayUnformatted(){
    $content = '<div style="border:1px solid #ddd">';
    $content .= '<label>Author:</label><div>'. $this->getAuthor() . '</div>';
    $content .= '<label>Name:</label><div>'. $this->getName() . '</div>';
    $content .= '<label>Number of pages:</label><div>'. $this->getNumberOfPages() . '</div>';
    $content .= '<label>Year:</label><div>'. $this->getYear() . '</div>';
    $content .= '<label>Publishing office:</label><div>'. $this->getPublishingOffice() . '</div>';
    $content .= '<label>Edition number:</label><div>'. $this->getEditionNumber() . '</div>';
    $content .= '</div>';
    return $content;
  }
}

$book1 = new book;
$book1->author = 'Abramenko I.A';
$book1->name = 'Drupal: User guide';
$book1->numberOfPages = 192;
$book1->year = 2013;
$book1->publishingOffice = 'Moscow';
$book1->editionNumber = 1;

$book2 = new book;
$book2->author = 'Leshkina S.O.';
$book2->name = 'Drupal: Fields, Images, Views';
$book2->numberOfPages = 200;
$book2->year = 2013;
$book2->publishinOffice = 'Moscow';
$book2->editionNumber = 1;

print $book1->displayTable();
print $book2->displayUnformatted();

?>

PHP 5.1.3 և ավելի հին տարբերակների հնարավորություններ՝

Եթե ցանկանում ենք դասում հատկություններ (փոփոխականներ) հայտարարել հին եղանակով, ապա օգտագործում ենք var բառը։

<?php

class myClass{

 

}

?>

 

Դիտարկենք զանգվածների և ֆունկցիաների օրինակ՝

<?php
$newArray = array(1,2,3,4,5);

function _increment_all_elements($customArray){
  foreach($customArray as $key){
    $customArray[] = $key+1;
  }
  return $customArray;
}

$newArray  = _increment_all_elements($newArray);
print_r($newArray);
?>

Օրինակը ինքնին հատուկ իմաստ չունի։ Մենք պարզապես գոյություն ունեցող զանգվածին ավելացրինք այդ տարրերի արժեքներն՝ մեծացնելով մեկով։ Բայց կարևորը՝ ինչպես դա արվեց․ ֆունկցիայի միջոցով։ Իսկ մենք գիտենք՝ ֆունկցիաները PHP-ում ֆունկցիոնալ ծրագրավորման հիմքն են։ Իսկ օբյեկտները՝ ավելի բարձր մակարդակի գործիք, որոնց միջոցով ստեղծվում է օբյեկտակենտրոն ծրագրավորում։
Հետագայում կվերադառնանք այս օրինակին՝ արդեն օբյեկտի օգնությամբ։ Բայց նախ պետք է հասկանանք՝ ի՞նչ է օբյեկտը։
Օբյեկտներն էլ, ինչպես ֆունկցիաները, թույլ են տալիս միավորել ֆունկցիաներ և տվյալներ, բայց դրանք ավելի մոտ են իրական աշխարհի մոդելավորմանը։ Օրինակ՝ «ապրանք» օբյեկտը կարող է ունենալ հատկություններ՝ գին, քաշ, լայնություն, երկարություն։ Այս նմանությունը իրականությանը հեշտացնում է կոդի ըմբռնումը։
Օբյեկտները սովորաբար ստեղծվում են որպես ինչ-որ դասի օրինակ։ Օրինակ՝ «գնդակ» օբյեկտը կարող է լինել «ապրանք» դասի օրինակ։ Դասը ընդհանրացում է՝ հատկությունների և մեթոդների նկարագրությամբ, իսկ օբյեկտը՝ այդ դասի իրականացումը։
Եկեք արդեն ստեղծենք մեր առաջին դասն ու օբյեկտը՝

<?php
class WorkWithArray{

}
?>

class բառով մենք ստեղծում ենք դաս։ Ֆիգուր փակագծերի մեջ գրում ենք դասի հատկություններն ու մեթոդները։ Ի դեպ, դասերի ֆունկցիաներն արդեն կոչվում են մեթոդներ, և ես այսուհետ այդպես էլ կանվանեմ։ Նույնը վերաբերում է փոփոխականներին՝ դասի ներսում դրանք կոչվում են հատկություններ։
Հիմա ավելացնենք առաջին հատկությունը՝ զանգված։

<?php
class WorkWithArray{
  var $myArray = array();
}
?>

Այժմ մեր զանգվածների հետ աշխատող դասը ունի հատկություն՝ զանգված։ Դասերի հատկությունները երբեմն անվանում են նաև օրինակի փոփոխականներ կամ տվյալների անդամներ։ Դրանք ավելացվում են var բառով։
Կցանկանայինք նաև ավելացնել մեթոդ՝

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key+1;
    }
    return $newArray;
  }
}
?>

Ինչպես տեսնում եք՝ մեթոդն ավելացվում է սովորական ֆունկցիայի նման։ Այժմ, երբ մենք ունենք դաս, կարող ենք ստեղծել դրա օբյեկտը և աշխատել դրա հետ։

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key+1;
    }
    return $newArray;
  }
}

$myObject = new WorkWithArray;
print_r($myObject);
?>

Օբյեկտը էկրանին արտածում ենք print_r() ֆունկցիայի միջոցով, ինչպես անում էինք զանգվածների դեպքում։ Այժմ, երբ օբյեկտը ստեղծված է, կարող ենք դիմել նրա հատկություններին և մեթոդներին։ Դասի հայտարարումից պարզ է, որ մենք ունենք myArray հատկություն և increment_all_elements() մեթոդ։

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key+1;
    }
    return $newArray;
  }
}

$myObject = new WorkWithArray;
$myObject->myArray = array(2,4,6,7);
print_r($myObject);
?>

Մենք դիմում ենք օբյեկտի հատկություններին -> օպերատորի միջոցով։ Այս գրությունը կարդացվում է որպես «օբյեկտին պատկանում է»։ Այսինքն՝ «$myObject-ին պատկանում է myArray հատկությունը»։ Այժմ կարող ենք կատարել գործողություն այդ հատկության վրա՝ օգտագործելով մեթոդը։

<?php
class WorkWithArray{
  var $myArray = array();
  function increment_all_elements($newArray){
    foreach($newArray as $key){
      $newArray[] = $key+1;
    }
    return $newArray;
  }
}

$myObject = new WorkWithArray;
$myObject->myArray = array(2,4,6,7);
$myObject->myArray = $myObject->increment_all_elements($myObject->myArray);
print_r($myObject);
?>

Մեթոդներին նույնպես դիմում ենք -> օպերատորի միջոցով։ Մեթոդին դիմելն անվանում ենք «կանչ»։ Մենք կանչում ենք increment_all_elements մեթոդը՝ փոխանցելով օբյեկտի myArray հատկությունը որպես պարամետր և նույն հատկությունը վերագրում ենք վերադարձվող արդյունքին։ Արդյունքում՝ մենք ունենք փոփոխված զանգված՝ տարրերը ավելացված մեկով։

Սա բավականին պարզ օրինակ է, որը ցույց է տալիս՝ ինչպես են ստեղծվում օբյեկտներ, ինչպես կարելի է կանչել դրանց հատկություններն ու մեթոդները։ Հաջորդիվ ավելի խորությամբ կուսումնասիրենք օբյեկտակենտրոն ծրագրավորման սկզբունքները։