PHP: კლასები და ობიექტები. PHP-ის სწავლა რა არის ობიექტზე ორიენტირებული პროგრამირება

ვინაიდან ეს არის კლასები, რომლებიც აღწერენ ობიექტებს, ჩვენ დავიწყებთ აღწერას კლასების განმარტებით.

კლასის განმარტება

კლასი არის კოდის ნიმუში, რომელიც გამოიყენება ობიექტების შესაქმნელად. კლასი განისაზღვრება კლასის საკვანძო სიტყვის გამოყენებით, რასაც მოჰყვება კლასის თვითნებური სახელი. კლასის სახელს შეუძლია გამოიყენოს ასოებისა და რიცხვების ნებისმიერი კომბინაცია, მაგრამ ისინი არ უნდა იწყებოდეს რიცხვით. კლასთან დაკავშირებული კოდი უნდა იყოს ჩასმული ხვეული ბრეკეტებით, რომლებიც გამოჩნდება სახელის შემდეგ. კლასის განმარტება აღწერს რა ელემენტებს შეიცავს ამ კლასის ყოველი ახალი ინსტანცია. მიღებული მონაცემების საფუძველზე, მოდით შევხედოთ კლასის განმარტების სინტაქსს მაგალითის გამოყენებით:

ზემოთ მოყვანილი მაგალითიდან პირველი კლასი უკვე სრულფასოვანი კლასია, თუმცა ჯერ არ არის ძალიან სასარგებლო. მაგრამ მიუხედავად ამისა, ჩვენ გავაკეთეთ რაღაც ძალიან მნიშვნელოვანი. ჩვენ განვსაზღვრეთ ტიპი, ე.ი. შევქმენით მონაცემთა კატეგორია, რომელიც შეგვიძლია გამოვიყენოთ ჩვენს სკრიპტებში. ამის მნიშვნელობა ცხადი გახდება თქვენთვის, როგორც კი წაიკითხავთ ამ თავში.

ობიექტის შექმნა

ვინაიდან კლასი არის ობიექტების შექმნის შაბლონი, შესაბამისად, ობიექტი არის მონაცემები, რომლებიც იქმნება და სტრუქტურირებულია კლასში განსაზღვრული შაბლონის მიხედვით. ობიექტს ასევე უწოდებენ კლასის ინსტანციას, რომლის ტიპი განისაზღვრება კლასით. კლასის ახალი ინსტანციის შესაქმნელად, ჩვენ გვჭირდება ახალი ოპერატორი. იგი გამოიყენება კლასის სახელთან ერთად შემდეგნაირად:

ახალი ოპერატორის შემდეგ მითითებულია კლასის სახელი, რომლის საფუძველზეც შეიქმნება ობიექტი. ახალი ოპერატორი ქმნის კლასის მაგალითს და აბრუნებს მითითებას ახლად შექმნილ ობიექტზე. ეს მითითება ინახება შესაბამისი ტიპის ცვლადში. ამ კოდის შესრულების შედეგად შეიქმნება პირველი ტიპის ორი ობიექტი. მიუხედავად იმისა, რომ ისინი ფუნქციურად იდენტურია (ანუ ცარიელი), $obj1 და $obj2 არის ერთი და იგივე ტიპის ორი განსხვავებული ობიექტი, შექმნილი ერთი კლასის გამოყენებით.

თუ ჯერ კიდევ დაბნეული ხართ, მოდით გამოვიყენოთ რეალური ანალოგი. წარმოიდგინეთ, რომ კლასი არის ჩამოსხმის ფორმა, რომელიც გამოიყენება პლასტმასის მანქანების დასამზადებლად. ობიექტები მანქანებია. შექმნილი ობიექტების ტიპი განისაზღვრება ჩამოსხმის ფორმის მიხედვით. მანქანები ყველანაირად ერთნაირად გამოიყურება, მაგრამ მაინც განსხვავებული ობიექტებია. სხვა სიტყვებით რომ ვთქვათ, ისინი ერთი და იგივე ტიპის სხვადასხვა ინსტანციაა.

მოდით გავხადოთ ეს ობიექტები ცოტა უფრო საინტერესო პირველი კლასის შეცვლით, რათა შეიცავდეს მონაცემთა სპეციალურ ველებს, რომლებსაც თვისებები ეწოდება.

თვისებების განსაზღვრა

ცვლადები შეიძლება განისაზღვროს კლასში. ცვლადებს, რომლებიც განსაზღვრულია კლასში, ეწოდება თვისებები (ან მონაცემთა ველები). ისინი განისაზღვრება ერთ-ერთი დაცული, საჯარო ან კერძო საკვანძო სიტყვით, რომელიც ახასიათებს წვდომის კონტროლს. ამ საკვანძო სიტყვებს დეტალურად განვიხილავთ შემდეგ თავში. ახლა მოდით განვსაზღვროთ რამდენიმე თვისება საჯარო საკვანძო სიტყვის გამოყენებით:

როგორც ხედავთ, ჩვენ განვსაზღვრეთ ორი თვისება, თითოეულ მათგანს მივანიჭებთ მნიშვნელობას. ახლა ნებისმიერ ობიექტს, რომელსაც ჩვენ ვქმნით პირველი კლასის გამოყენებით, ექნება ორი თვისება მითითებული მნიშვნელობებით.

შენიშვნა: თვისებების მნიშვნელობების ინიციალიზაცია უნდა იყოს ლიტერალი (მუდმივი მნიშვნელობები), არ არის აუცილებელი კლასში თვისებების ინიციალიზაცია (თუ მნიშვნელობა არ არის მითითებული, ის ნაგულისხმევად იქნება NULL).

ობიექტის თვისებებზე წვდომა შესაძლებელია " -> " სიმბოლოების გამოყენებით, ობიექტის და ქონების სახელის მითითებით. ვინაიდან ობიექტების თვისებები განისაზღვრა როგორც საჯარო, ჩვენ შეგვიძლია წავიკითხოთ მათი მნიშვნელობები და ასევე მივცეთ ახალი მნიშვნელობები, რითაც შევცვალოთ კლასში განსაზღვრული საწყისი მნიშვნელობები:

ქ; // ობიექტის თვისებას მივანიჭოთ ახალი მნიშვნელობა $obj->str = "new line"; ექო"
$obj->str"; ?>

სინამდვილეში, PHP-ში არ არის აუცილებელი კლასში ყველა თვისების გამოცხადება. თვისებები შეიძლება დაემატოს ობიექტს დინამიურად:

newprop = "ახალი ქონება"; echo $obj->newprop; ?>

უნდა აღინიშნოს, რომ ობიექტებისთვის თვისებების მინიჭების ეს მეთოდი ობიექტზე ორიენტირებულ პროგრამირებაში ცუდ ფორმად ითვლება და თითქმის არასოდეს გამოიყენება.

მეთოდებთან მუშაობა

მეთოდები არის ჩვეულებრივი ფუნქციები, რომლებიც განსაზღვრულია კლასში, ისინი საშუალებას აძლევს ობიექტებს შეასრულონ სხვადასხვა ამოცანები. მეთოდის დეკლარაცია ჰგავს რეგულარულ ფუნქციის განმარტებას, გარდა იმისა, რომ მას წინ უძღვის ერთ-ერთი დაცული, საჯარო ან კერძო საკვანძო სიტყვა. თუ მეთოდის განსაზღვრაში გამოტოვებთ ხილვადობის საკვანძო სიტყვას, მეთოდი გამოცხადდება იმპლიციურად საჯარო. ობიექტის მეთოდებზე წვდომა შესაძლებელია " -> " სიმბოლოების გამოყენებით, სადაც მითითებულია ობიექტი და მეთოდის სახელი. მეთოდის გამოძახებისას, ისევე როგორც ფუნქციის გამოძახებისას, თქვენ უნდა გამოიყენოთ ფრჩხილები.

ქ; ) ) $obj = new first(); // ობიექტის მეთოდის გამოძახება $obj->getstr(); ?>

პირველ კლასს დავამატეთ getstr() მეთოდი. გაითვალისწინეთ, რომ მეთოდის განსაზღვრისას ჩვენ არ გამოგვიყენებია სკოპის საკვანძო სიტყვა. ეს ნიშნავს, რომ getstr() მეთოდი საჯარო ტიპისაა და მისი გამოძახება შესაძლებელია კლასის გარეთ.

მეთოდის განსაზღვრაში ჩვენ გამოვიყენეთ სპეციალური ფსევდო ცვლადი $this. იგი გამოიყენება კლასში მეთოდებზე ან თვისებებზე წვდომისთვის და აქვს შემდეგი სინტაქსი:

$this->ცვლადი ან მეთოდის სახელი

კლასი პირველი ( public $str = "ზოგიერთი ტექსტი"; // კლასში მეთოდის განსაზღვრისას $this ცვლადს არ აქვს მნიშვნელობის ფუნქცია getstr() ( echo $this->str; ) ) // შექმენით ობიექტი $obj = პირველი ახალი (); // ჩვენ მიერ შექმნილ ობიექტს აქვს თვისება და მეთოდი // ახლა ობიექტის მეთოდში ცვლადს $this აქვს // ბმული მიმდინარე ობიექტთან, კერძოდ, $obj // ე.ი. თუ მეთოდში $this ჩავანაცვლებთ $this->str ობიექტის მიმდინარე ინსტანციით; // ეს გამოიყურება როგორც მარტივი // წვდომა მიმდინარე ობიექტის თვისებაზე $obj->str;

შენიშვნა: $ამ არ შეიძლება რაიმეს მინიჭება. გახსოვდეთ, რომ $ეს ყოველთვის ეხება მიმდინარე ობიექტს.

სპეციალური მეთოდი - კონსტრუქტორი

კლასს შეიძლება ჰქონდეს განსაზღვრული სპეციალური მეთოდი - კონსტრუქტორი, რომელიც გამოიძახება ყოველ ჯერზე, როდესაც იქმნება კლასის (ობიექტის) ახალი ეგზემპლარი, რათა მოხდეს მისი ინიციალიზაცია, მაგალითად, დააყენოს თვისებების მნიშვნელობები. კონსტრუქტორს, ისევე როგორც ნებისმიერ სხვა მეთოდს, შეიძლება ჰქონდეს პარამეტრები. მეთოდის, როგორც კონსტრუქტორის განსაზღვრისთვის, თქვენ უნდა უწოდოთ მას __construct(). გთხოვთ გაითვალისწინოთ, რომ მეთოდის სახელი უნდა დაიწყოს ორი ქვედა ხაზით. ვნახოთ როგორ მუშაობს:

num1 = $num1; $this->num2 = $num2; ) // მეთოდი, რომელიც ამატებს ორი რიცხვის ფუნქციას summa() ( return $this->num1 + $this->num2; ) ) // შექმენით ობიექტი და გადაიტანეთ ორი არგუმენტი $obj = new first(15, 35); // მოვუწოდებთ მეთოდს და დაუყოვნებლივ აჩვენეთ მისი მუშაობის შედეგი echo $obj->summa(); ?>

__construct მეთოდი გამოიძახება, როდესაც ობიექტი იქმნება ახალი ოპერატორის გამოყენებით. ფრჩხილებში მითითებული არგუმენტები გადაეცემა კონსტრუქტორს. კონსტრუქტორის მეთოდი იყენებს $this ფსევდო ცვლადს, რათა მნიშვნელობები მიაკუთვნოს შექმნილი ობიექტის შესაბამის თვისებებს.

შენიშვნა: თუ კონსტრუქტორს არ აქვს პარამეტრები და არ არის გადაცემული არგუმენტები კლასის ახალი ინსტანციების შექმნისას, კლასის სახელის შემდეგ ფრჩხილები () შეიძლება გამოტოვდეს: $obj = new first;

არგუმენტის ტიპის მითითება მეთოდებში

ნაგულისხმევად, მეთოდს შეუძლია მიიღოს ნებისმიერი ტიპის არგუმენტები, მაგრამ არის შემთხვევები, როდესაც გსურთ დარწმუნდეთ, რომ მეთოდს შეუძლია არგუმენტად მიიღოს მხოლოდ კონკრეტული კლასის მაგალითები. მიღებული არგუმენტის ტიპის მითითებისთვის, უბრალოდ დაადეთ კლასის სახელი პარამეტრის სახელის წინ მეთოდის განსაზღვრაში:

getobj(ახალი კატა()); // იქნება შეცდომა: არგუმენტად გადაცემულია არასწორი ტიპის მაგალითი $kitty->getobj(new wrong()); ?>

ახლა თქვენ შეგიძლიათ გადასცეთ მხოლოდ cat ტიპის ინსტანციები, როგორც არგუმენტები getobj() მეთოდში. იმის გამო, რომ getobj() მეთოდი შეიცავს კლასის ტიპის კვალიფიკაციას, არასწორი ტიპის ობიექტის გადაცემა გამოიწვევს შეცდომას.

ტიპის მინიშნება არ შეიძლება გამოყენებულ იქნას პრიმიტიული ტიპების პარამეტრების დასადგენად, როგორიცაა სტრიქონები, რიცხვები და ა.შ. ამ მიზნით, ტიპის შემოწმების ფუნქციები, როგორიცაა is_string() უნდა იყოს გამოყენებული მეთოდის სხეულში. ასევე შესაძლებელია იმის დაზუსტება, რომ გადაცემული არგუმენტი არის მასივი:

my_arr = $some_arr; )) ?>

ბოლო სათქმელია ის, რომ თუ მეთოდის პარამეტრი განსაზღვრულია კონკრეტული კლასით, ნებადართულია ნაგულისხმევი მნიშვნელობის მითითება იმ შემთხვევაში, თუ მეთოდს არ გადაეცა ობიექტი. მხოლოდ NULL შეიძლება გამოყენებულ იქნას როგორც ნაგულისხმევი მნიშვნელობა:

ფუნქცია getobj(cat $getCat = null) ($this->someVar = $getCat;)

თუ NULL-ის ნაცვლად სხვა ნაგულისხმევ მნიშვნელობას მიუთითებთ, გამოვა შეცდომა.

ამ გაკვეთილზე თქვენ შეისწავლით PHP-ში ობიექტზე ორიენტირებული პროგრამირების საფუძვლებს. თქვენ გაეცნობით ზოგადად OOP-ის პრინციპებს და ისწავლით PHP-ში მარტივი სკრიპტების დაწერას.

კეთილი იყოს თქვენი მობრძანება PHP-ში OOP გაკვეთილების სერიის პირველში! ამ სერიის ყველა გაკვეთილის დასრულებისას თქვენ გაეცნობით OOP-ის ძირითად პრინციპებსა და კონცეფციებს და ისწავლით თუ როგორ სწრაფად და მარტივად შექმნათ სასარგებლო აპლიკაციები PHP-ში.

ამ ტუტორიალში მე დავიწყებ თქვენი სიჩქარის გაცნობას და მოგიყვებით OOP-ის ძირითადი კონცეფციების შესახებ. Ისწავლი:

• რა არის OOP
• როგორ დაგეხმარება OOP უკეთესი PHP სკრიპტების შექმნაში
• ზოგიერთი ძირითადი კონცეფცია, როგორიცაა კლასები, ობიექტები, მეთოდები, კლასის ცვლადები
• სად დავიწყოთ PHP სკრიპტის წერა

მზად ხართ ჩაყვინთოთ PHP ობიექტების სამყაროში? მაშინ წინ წადი!

რა არის ობიექტზე ორიენტირებული პროგრამირება?

თუ თქვენ ოდესმე შექმენით და იყენებდით პერსონალურ ფუნქციებს PHP-ში, თქვენ გამოიყენეთ პროცედურული პროგრამირების სტილი. პროცედურულ პროგრამირებაში, როგორც წესი, თქვენ ქმნით მონაცემთა სტრუქტურებს - რიცხვებს, სტრიქონებს, მასივებს და ა.შ. - შეინახოს გარკვეული მონაცემები და შემდეგ დაამუშავოს ეს სტრუქტურები სპეციალური ფუნქციებით, რომლებიც მანიპულირებენ ამ მონაცემებით.

ობიექტზე ორიენტირებული პროგრამირება, ან OOP, წინ წავიდა, რადგან აქ ჩვენ ვინახავთ მონაცემთა სტრუქტურებს და ფუნქციებს, რომლებიც ამუშავებენ მათ ერთ ერთეულში, რომელსაც ეწოდება ობიექტი. იმის ნაცვლად, რომ დამუშავდეს მონაცემები რაიმე ფუნქციით, თქვენ ჩატვირთავთ ამ მონაცემებს ობიექტში და შემდეგ უწოდებთ მის მეთოდებს, რათა მანიპულირებდეს და მიიღოთ სასურველი შედეგი.

ყველაზე ხშირად, OOP-ის გამოყენებით შექმნილი ობიექტები ასახავს რეალურ პირებს. მაგალითად, თუ თქვენ ქმნით ფორუმს თქვენი საიტისთვის, თქვენ შექმნით წევრის ობიექტს, რომელიც შეინახავს ინფორმაციას თითოეული ფორუმის წევრის შესახებ (სახელი, შესვლა, ელ. ფოსტა, პაროლი და ა.შ.), ასევე მეთოდებს, რომლებიც დაამუშავებს ამ ინფორმაციას ( რეგისტრაცია, ავტორიზაცია, გამოსვლა, აკრძალვა და ა.შ.).

რატომ გამოვიყენოთ OOP?

პროცედურული და ობიექტზე ორიენტირებული ერთი და იგივე საქმის გაკეთების ორი განსხვავებული გზაა. ეს არ ნიშნავს იმას, რომ ერთი მათგანი სჯობს მეორეს - ყველა წერს ისე, როგორც მოსწონს, ასე რომ თქვენ შეგიძლიათ მარტივად დააკავშიროთ ეს ორი მიდგომა ერთ სკრიპტში.

თუმცა, აქ არის OOP-ის რამდენიმე უპირატესობა დეველოპერებისთვის:

• უფრო ადვილია რეალური სიტუაციების ასახვა: როგორც ზემოთ აღვნიშნე, ობიექტები ასახავს რეალურ არსებებს - ადამიანებს, პროდუქტებს, ბარათებს, ბლოგ სტატიებს და ა.შ. მიზნის მსგავსია ობიექტებს შორის ურთიერთობა ნათელი და გასაგები იქნება.
• მოდულური პროგრამების დაწერა უფრო ადვილია: OOP მოიცავს მოდულების ჩაწერას. თქვენი კოდის მოდულებად დაყოფით, გაგიადვილდებათ მისი მართვა, გამართვა და გაფართოება.
• უფრო ადვილია კოდის დაწერა, რომელიც ბევრჯერ იქნება გამოყენებული: კოდის დაწერა, რომელიც შეიძლება გამოყენებულ იქნას არაერთხელ, დაზოგავს დროს აპლიკაციის დაწერისას და დროთა განმავლობაში შეგიძლიათ შექმნათ ამ ტიპის მოდულების მთელი ბიბლიოთეკა, რომელიც შეგიძლიათ გამოიყენოთ ბევრში. აპლიკაციები. OOP-ით, შედარებით უფრო ადვილი ხდება ისეთი კოდის დაწერა, რადგან მონაცემთა სტრუქტურები და ფუნქციები ჩასმულია ერთ ობიექტში, რომელიც შეიძლება გამოყენებულ იქნას რამდენჯერმე.

ზოგიერთი ძირითადი კონცეფცია

სანამ სკრიპტების წერას დაიწყებთ, კარგად უნდა გესმოდეთ კლასის, ობიექტის, კლასის ცვლადის და მეთოდის ცნებები.

კლასები

კლასი არის ჩარჩო ობიექტისთვის. ეს არის კოდის ნაწილი, რომელიც განსაზღვრავს:

• მონაცემთა ტიპები, რომლებსაც შეიცავენ შექმნილი კლასის ობიექტები
• ფუნქციები, რომლებიც შეიცავს ამ ობიექტებს.

როდესაც თქვენ შექმნით OOP აპლიკაციას, თქვენ ჩვეულებრივ შექმნით რამდენიმე კლასს, რომლებიც წარმოადგენენ სხვადასხვა ტიპის ერთეულებს თქვენს აპლიკაციაში. მაგალითად, ფორუმის შესაქმნელად, შეგიძლიათ შექმნათ ფორუმი, თემა, პოსტი და წევრის კლასები.

ობიექტები

ობიექტი არის ცვლადის სპეციალური ტიპი, რომელიც იქმნება კლასის მეშვეობით. ის შეიცავს რეალურ მონაცემებს და ფუნქციებს მისი მანიპულირებისთვის. თქვენ შეგიძლიათ შექმნათ იმდენი ობიექტი, რამდენიც გსურთ ერთი კლასიდან. ობიექტის თითოეული ფუნქცია დამოუკიდებელია სხვა ობიექტისგან, მაშინაც კი, თუ ისინი შექმნილია იმავე კლასიდან.

რეალურ პირებთან შედარებისთვის:

• კლასი არის მანქანის ჩარჩო: ის განსაზღვრავს როგორ გამოიყურება და იმოქმედებს მანქანა, მაგრამ ის მაინც აბსტრაქტული არსებაა.
• ობიექტი არის ნამდვილი მანქანა, რომელიც შექმნილია მავთულის ჩარჩოდან: მას აქვს რეალური თვისებები (როგორიცაა სიჩქარე) და ქცევა (როგორიცაა აჩქარება ან დამუხრუჭება).

შენიშვნა: ობიექტს ხშირად უწოდებენ კლასის არსს, ხოლო კლასის ობიექტის შექმნის პროცესს ეწოდება იმპლემენტაცია.

კლასის ცვლადები

მონაცემთა მნიშვნელობები, რომლებიც ინახება კონკრეტულ ობიექტში, იწერება სპეციალურ ცვლადებზე, რომლებსაც კლასის ცვლადები ეწოდება. კლასის ცვლადები მჭიდრო კავშირშია მის ობიექტთან. მიუხედავად იმისა, რომ კლასის ყველა ობიექტს აქვს იგივე ცვლადები, მათი მნიშვნელობები შეიძლება განსხვავდებოდეს.

მეთოდები

კლასში განსაზღვრულ და ამ კლასის ობიექტებზე გამოყენებულ ფუნქციებს მეთოდები ეწოდება. ისინი დიდად არ განსხვავდებიან ჩვეულებრივი ფუნქციებისგან - შეგიძლიათ გადასცეთ მნიშვნელობები, მათ შეუძლიათ შეიცავდეს ლოკალურ ცვლადებს და დააბრუნონ მნიშვნელობები. თუმცა, მეთოდები უფრო ხშირად მუშაობს ობიექტის ცვლადებთან. მაგალითად, login() მეთოდმა თქვენს ფორუმში მომხმარებლების შესვლისთვის შეიძლება დააყენოს logedIn კლასის ცვლადი true.

როგორ შევქმნათ კლასი PHP-ში?

ახლა, როცა უკვე იცით რა არის კლასები, მეთოდები, კლასის ცვლადები და ობიექტები, დროა შევქმნათ რამდენიმე კლასი და ობიექტი PHP კოდში.

პირველ რიგში, მოდით შევხედოთ რეალურად როგორ შევქმნათ კლასი. ძირითადად, კლასის შექმნის სკრიპტი ასე გამოიყურება:

კლასი ClassName ( // (კლასის განმარტება) )

მაგალითად, თუ თქვენ ქმნით წევრების კლასს თქვენი ფორუმისთვის, თქვენ დაწერთ ამას:

კლასის წევრი ( // (კლასის განმარტება) )

ეს საკმაოდ მარტივია. ბუნებრივია, ეს კლასი ვერაფერს გააკეთებს, სანამ მას არ დაუმატებთ ცვლადებს და მეთოდებს. თუმცა, ზემოთ მოყვანილი კოდი ქმნის მოქმედ PHP კლასს, რომლის გამოყენებაც შესაძლებელია.

კარგი წესი: მოათავსეთ თითოეული კლასი ცალკე ფაილში იგივე სახელით, როგორც კლასის სახელი. მაგალითად, ჩადეთ Member კლასი Member.php ფაილში და შეინახეთ იგი საქაღალდეში, ვთქვათ, კლასებში.

როგორ შევქმნათ ობიექტები PHP-ში?

თქვენ შეგიძლიათ შექმნათ ობიექტი ახალი საკვანძო სიტყვის გამოყენებით:

ახალი ClassName()

ეს კოდი შექმნის ClassName კლასის ობიექტს. მოგვიანებით მოგიწევთ ამ ობიექტის გამოყენება, ასე რომ თქვენ უნდა შეინახოთ იგი ცვლადში. მაგალითად, შევქმნათ Member კლასის ობიექტი და შევინახოთ $member ცვლადში:

$წევრი = ახალი წევრი();

ჩვენ ასევე შეგვიძლია შევქმნათ იმავე კლასის სხვა ობიექტი:

$member2 = ახალი წევრი();

მიუხედავად იმისა, რომ ჩვენ შევქმენით ეს ორი ობიექტი ერთი და იგივე კლასიდან, ცვლადები $member და $member2 ერთმანეთისგან დამოუკიდებელია.

შექმენით კლასის ცვლადები

ახლა, როდესაც ჩვენ უკვე ვიცით როგორ შევქმნათ კლასები და კლასის ობიექტები, მოდით შევხედოთ როგორ შევქმნათ კლასის ცვლადები. კლასის ცვლადების 3 აქსესუარია, რომლებიც შეიძლება დაემატოს კლასს:

• საჯარო კლასის ცვლადები (public): ხელმისაწვდომი - ე.ი. მათი წაკითხვა და/ან შეცვლა შესაძლებელია - სკრიპტის ნებისმიერ ადგილას, მიუხედავად იმისა, თუ სად მდებარეობს ეს კოდი - კლასში თუ მის გარეთ
• პირადი კლასის ცვლადები (პირადი): ხელმისაწვდომია მხოლოდ კლასის მეთოდებისთვის. უმჯობესია კლასის ცვლადები კერძო გახადოთ, რათა გამოვყოთ ობიექტები დანარჩენი კოდისგან.
• დაცული კლასის ცვლადები: ხელმისაწვდომია თქვენი საკუთარი კლასის მეთოდებისთვის, ასევე მემკვიდრეობით მიღებული კლასების მეთოდებისთვის (მემკვიდრეობაზე მოგვიანებით ვისაუბრებთ).

კლასის ცვლადის შესაქმნელად, ჩაწერეთ საკვანძო სიტყვა public, private ან protected და შემდეგ შეიყვანეთ ცვლადის სახელი:

კლასი ClassName ( საჯარო $propertyName; პირადი $propertyName; დაცული $propertyName; )

მოდით დავამატოთ საჯარო კლასის ცვლადი ჩვენს წევრ კლასს მომხმარებლის სახელის შესანახად:

კლასის წევრი ( საჯარო $username = ""; )

გაითვალისწინეთ, რომ ჩვენ დავაყენეთ ჩვენი კლასის ცვლადი, მისი მნიშვნელობა არის ცარიელი სტრიქონი, “”. ეს ნიშნავს, რომ ახალი მომხმარებლის შექმნისას მომხმარებლის სახელი ნაგულისხმევად იქნება ცარიელი სტრიქონი. ისევე, როგორც PHP-ში რეგულარული ცვლადების შემთხვევაში, კლასის ცვლადები არ უნდა იყოს ინიციალიზებული, მაგრამ უმჯობესია არ დაიზაროთ. თუ არ გააკეთებთ კლასის ცვლადის ინიციალიზაციას, მისი ნაგულისხმევი მნიშვნელობა არის null.

კლასის ცვლადებზე წვდომა

ობიექტის ცვლადზე წვდომის მისაღებად გამოიყენეთ -> ოპერატორი:

$object->propertyName

Მოდი ვცადოთ. მოდით დავწეროთ სკრიპტი, რომელიც აცხადებს Member კლასს და კლასის ცვლადს, ქმნის ამ კლასის ობიექტს და შემდეგ ადგენს კლასის ცვლადის მნიშვნელობას და აჩვენებს მას ეკრანზე:

მომხმარებლის სახელი = "ფრედი"; echo $member->username; // დაბეჭდე "ფრედი" ?>

გაუშვით ეს კოდი, ის აჩვენებს სტრიქონს "Fred", კლასის ცვლადის $member->username მნიშვნელობას. როგორც ხედავთ, თქვენ მოქმედებთ ობიექტის ცვლადზე ისევე, როგორც ჩვეულებრივი ცვლადი - შეგიძლიათ დააყენოთ იგი მნიშვნელობაზე და წაიკითხოთ იგი.

კლასში მეთოდების დამატება

რაც შეეხება მეთოდების შექმნას? როგორც უკვე აღვნიშნე, მეთოდები მხოლოდ რეგულარული ფუნქციებია, რომლებიც კლასის ნაწილია. ასე რომ, შეიძლება არ გაგიკვირდეთ, რომ ისინი იქმნება იგივე ფუნქციის საკვანძო სიტყვის გამოყენებით. ერთადერთი განსხვავება რეგულარული ფუნქციების შექმნისგან არის ის, რომ თქვენ ასევე შეგიძლიათ დაამატოთ წვდომის ერთ-ერთი იდენტიფიკატორი (საჯარო, კერძო, დაცული) მის დეკლარაციაში. ამ გზით, მეთოდები მსგავსია კლასის ცვლადების:

კლასი ClassName ( საჯარო ფუნქციის მეთოდიName() ( // (კოდი) ) კერძო ფუნქციის მეთოდიName() ( // (კოდი) ) დაცული ფუნქციის მეთოდიName() ( // (კოდი) ) )

შენიშვნა: ისევე, როგორც კლასის ცვლადების შემთხვევაში, საჯარო მეთოდების გამოძახება შესაძლებელია ნებისმიერი ადგილიდან, კერძო მეთოდების გამოძახება შესაძლებელია მხოლოდ კლასში, ხოლო დაცული მეთოდების გამოძახება შესაძლებელია თავად კლასიდან და მისი შთამომავლებიდან.

შევეცადოთ დავამატოთ რამდენიმე მეთოდი და კლასის ცვლადი ჩვენს კლასში:

• კერძო $loggedIn კლასის ცვლადი მომხმარებლის იდენტიფიცირებისთვის, ე.ი. შემოვიდა თუ არა,
• login() მეთოდი, რომელიც შევა ფორუმში $loggedIn კლასის ცვლადის true-ზე დაყენებით,
• logout() მეთოდი, რომელიც გამოვა ფორუმიდან $loggedIn კლასის ცვლადის false-ზე დაყენებით,
• isLoggedIn() მეთოდი, რომელიც დააბრუნებს $loggedIn კლასის ცვლადის მნიშვნელობას.

აი ჩვენი კოდი:

შესული = true; ) საჯარო ფუნქცია logout() ( $this->loggedIn = false; ) საჯარო ფუნქცია isLoggedIn() ( return $this->loggedIn; ) ) ?>

თქვენ შეიძლება შეამჩნიეთ, რომ ჩვენ გამოვიყენეთ ახალი $this საკვანძო სიტყვა. ობიექტის მეთოდების კონტექსტში, სპეციალური ცვლადი $this ეხება თავად ობიექტს. $this-ის გამოყენებით ობიექტის მეთოდში, მეთოდს შეუძლია წვდომა ობიექტის ნებისმიერ კლასის ცვლადსა და მეთოდზე.

მაგალითად, login() მეთოდს შეუძლია წვდომა ობიექტის $loggedIn კლასის ცვლადზე $this->loggedIn-ის მეშვეობით.

სხვათა შორის, ჩვენი კლასის ცვლადი კერძოა, ამიტომ მისი გამოძახება შეუძლებელია სკრიპტის რომელიმე ნაწილიდან, არამედ მხოლოდ login(), logout() და isLoggedIn() მეთოდებიდან. ეს კარგი მიდგომაა, რადგან ობიექტის შინაგანი ნაწილი (როგორიცაა, ზუსტად როგორ აფიქსირებს მომხმარებელი შესულია თუ არა) დანარჩენი კოდისგან განცალკევებულია. შეძლებისდაგვარად, შეეცადეთ გამოიყენოთ კერძო კლასის ცვლადები ისე, რომ თქვენი ობიექტები იყოს ავტონომიური, მობილური და დაცული.

შენიშვნა: $username კლასის ცვლადი ჩვენს მაგალითში არის საჯარო. მე ეს გავაკეთე უბრალოდ იმის დემონსტრირებისთვის, თუ როგორ შეგიძლიათ წვდომა ობიექტის კლასის ცვლადებზე. რეალურ პროექტებში, თქვენ გირჩევნიათ ეს ცვლადი პირადი გახადოთ და შექმნათ სპეციალური საჯარო კლასის ცვლადები, რომ საჭიროების შემთხვევაში დააყენოთ მომხმარებლის სახელის მნიშვნელობები.

მეთოდების გამოყენება

ობიექტზე მეთოდის გამოსაძახებლად გამოიყენეთ -> ოპერატორი, რომელიც უკვე გაეცანით.

$object->methodName()

ეს მუშაობს ისევე, როგორც ჩვეულებრივი ფუნქციის გამოძახება. თქვენ შეგიძლიათ გადასცეთ არგუმენტები ფრჩხილებში (თუ ვივარაუდებთ, რომ მას სჭირდება რაიმე არგუმენტი, რა თქმა უნდა), და მეთოდის გამოძახებას ასევე შეუძლია დააბრუნოს კონკრეტული მნიშვნელობები, რომლებიც შეგიძლიათ გამოიყენოთ.

შესული = true; ) საჯარო ფუნქცია logout() ( $this->loggedIn = false; ) public ფუნქცია isLoggedIn() ( return $this->loggedIn; ) ) $member = new Member(); $member->username = "ფრედი"; echo $member->username . "არის". ($member->
"; $member->login(); echo $member->username . " არის " . ($member->isLoggedIn() ? "შესული" : "გამოსული") . "
"; $member->logout(); echo $member->username . " არის " . ($member->isLoggedIn() ? "შესული" : "გამოსული") . "
"; ?>

ეს სკრიპტი აჩვენებს შემდეგს:

ფრედი გამოსულია ფრედი შესულია ფრედი გამოსულია

აი, როგორ მუშაობს:

1. Member კლასის აღწერის შემდეგ შევქმენით მისი ობიექტი და შევინახეთ $member ცვლადში. ჩვენ ასევე მივეცით ამ ობიექტის $username კლასის ცვლადს მნიშვნელობა „Fred“.
2. შემდეგ ჩვენ გამოვიძახეთ $member->isLoggedIn() მეთოდი, რათა განვსაზღვროთ არის თუ არა მომხმარებელი შესული. ეს მეთოდი უბრალოდ აბრუნებს $loggedIn კლასის ცვლადის მნიშვნელობას. ვინაიდან ამ კლასის ცვლადის ნაგულისხმევი მნიშვნელობა არის false, $member->isLoggedIn()-ის გამოძახების შედეგი იქნება false, ამიტომ გამოჩნდება შეტყობინება "Fred is logged out".
3. შემდეგ ჩვენ მოვუწოდებთ login() მეთოდს. $loggedIn კლასის ცვლადს დააყენებს true.
4. ახლა $member->isLoggedIn() მეთოდის გამოძახებისას ის უბრუნდება true და აჩვენებს შეტყობინებას "Fred is log in".
5. მოდით გამოვიძახოთ logout() მეთოდი, რომელიც $loggedIn თვისების მნიშვნელობას აყენებს false-ზე.
6. მოდით მესამედ გამოვიძახოთ $member->isLoggedIn() მეთოდი. ის ახლა დააბრუნებს false-ს, რადგან $loggedIn თვისება კვლავ დაყენებულია false-ზე. ასე რომ, შეტყობინება "ფრედი გამოვიდა" კვლავ გამოჩნდება.

შენიშვნა: თუ ეს პირველად ნახეთ: ?: არის სამმაგი ოპერატორი. ეს არის if...else ბლოკების გამარტივებული ვერსია. თქვენ შეგიძლიათ გაეცნოთ ამ ტიპის ოპერატორებს.

დასკვნები

ამ გაკვეთილზე თქვენ ისწავლეთ OOP-ის საფუძვლები PHP-ში. თქვენ შეიტყვეთ ისეთი რაღაცეების შესახებ, როგორიცაა:

• რა არის OOP და რატომ არის ის სასარგებლო?
• კლასების, ობიექტების, კლასის ცვლადების და მეთოდების ცნებები
• როგორ შევქმნათ კლასები და ობიექტები
• როგორ შევქმნათ და გამოვიყენოთ კლასის ცვლადები
• საჯარო, კერძო, დაცული წვდომის იდენტიფიკატორების ცნებები
• როგორ შევქმნათ და გამოვიყენოთ კლასის მეთოდები

თქვენ უკვე ბევრი ისწავლეთ ამის შესახებ და კიდევ ბევრს გაიგებთ შემდეგ გაკვეთილებზე. თუმცა, თუ თქვენ იმუშავეთ ჩემს მიერ მოყვანილი ყველა მაგალითზე, თქვენ გაქვთ მყარი საფუძველი. შეგიძლიათ დაიწყოთ აპლიკაციების შექმნა OOP-ის გამოყენებით.

კლასები და ობიექტები PHP-ში

Კლასი არის ობიექტზე ორიენტირებული პროგრამირების (OOP) ძირითადი კონცეფცია. კლასები ქმნიან OOP-ის სინტაქსურ საფუძველს. ისინი შეიძლება მივიჩნიოთ, როგორც ერთგვარი „კონტეინერები“ ლოგიკურად დაკავშირებული მონაცემებისა და ფუნქციებისთვის (ჩვეულებრივ უწოდებენ - იხილეთ ქვემოთ). მარტივად რომ ვთქვათ, კლასი არის ერთგვარი მონაცემთა ტიპი.

კლასის მაგალითია საგანი. ობიექტი არის მონაცემთა () და ფუნქციების (მეთოდების) ერთობლიობა მათი დამუშავებისთვის. თვისებები და მეთოდები ე.წ. ზოგადად, ობიექტი არის ყველაფერი, რაც მხარს უჭერს ინკაფსულაციას.

თუ კლასი შეიძლება ჩაითვალოს მონაცემთა ტიპად, მაშინ ობიექტი შეიძლება ჩაითვალოს ცვლადად (ანალოგიით). სკრიპტს შეუძლია ერთდროულად იმუშაოს იმავე კლასის რამდენიმე ობიექტთან, ისევე როგორც რამდენიმე ცვლადთან.

ობიექტის შიგნით მონაცემები და კოდი (კლასის წევრები) შეიძლება იყოს საჯარო ან არა. საჯარო მონაცემები და კლასის წევრები ხელმისაწვდომია პროგრამის სხვა ნაწილებისთვის, რომლებიც არ არის ობიექტის ნაწილი. მაგრამ პირადი მონაცემები და კლასის წევრები ხელმისაწვდომია მხოლოდ ამ ობიექტის შიგნით.

PHP-ში კლასების აღწერა იწყება ფუნქციური სიტყვით კლასი:

კლასის სახელი (
// კლასის წევრების აღწერა - თვისებები და მათი დამუშავების მეთოდები
}

ობიექტის გამოსაცხადებლად თქვენ უნდა გამოიყენოთ ოპერატორი ახალი:

ობიექტი = ახალი ClassName;

მონაცემები აღწერილია ფუნქციური სიტყვის გამოყენებით ვარ. მეთოდი აღწერილია ისევე, როგორც ჩვეულებრივი მომხმარებლის მიერ განსაზღვრული ფუნქცია. თქვენ ასევე შეგიძლიათ გადასცეთ პარამეტრები მეთოდს.

მოდით შევაჯამოთ: კლასის დეკლარაცია უნდა დაიწყოს საკვანძო სიტყვით კლასი(როგორც ფუნქციის დეკლარაცია იწყება საკვანძო სიტყვით ფუნქცია). კლასში შემავალი ყველა ქონების დეკლარაციას წინ უნდა უსწრებდეს საკვანძო სიტყვა ვარ. თვისებები შეიძლება იყოს ნებისმიერი ტიპის მონაცემი, რომელსაც მხარს უჭერს PHP და შეიძლება ჩაითვალოს ცვლადებად მცირე განსხვავებებით. ქონების დეკლარაციებს მოჰყვება მეთოდის დეკლარაციები, რომლებიც ძალიან ჰგავს მომხმარებლის მიერ განსაზღვრულ ფუნქციების ტიპურ დეკლარაციებს.

ზოგადად მიღებული წესების მიხედვით, OOP კლასის სახელები იწყება დიდი ასოებით, ხოლო მეთოდების სახელებში ყველა სიტყვა, გარდა პირველისა, იწყება დიდი ასოებით (პირველი სიტყვა იწყება მცირე ასოებით). რა თქმა უნდა, შეგიძლიათ გამოიყენოთ ნებისმიერი აღნიშვნა, რომელიც თქვენთვის მოსახერხებელია; მთავარია სტანდარტის შერჩევა და მისი დაცვა.

მაგალითი კლასი PHP-ში:

// ახალი Coor კლასის შექმნა:
კლასი Coor (
// მონაცემები (თვისებები):
var$ სახელი;
var $addr;

// მეთოდები:
ფუნქციის სახელი () (
ექო"

იოანე

" ;
}

}


$object = newCoor;
?>

PHP-ში კლასებსა და ობიექტებზე წვდომა

ჩვენ დავაკვირდით, როგორ არის აღწერილი კლასები და როგორ იქმნება ობიექტები. ახლა ჩვენ გვჭირდება წვდომა კლასის წევრებზე, ამ მიზნით PHP-ში არის ოპერატორი -> . აი მაგალითი:

// ახალი Coor კლასის შექმნა:
კლასი Coor (
// მონაცემები (თვისებები):
var$ სახელი;

// მეთოდები:
ფუნქცია Getname() (
ექო"

იოანე

" ;
}

}

// შექმენით Coor კლასის ობიექტი:
$object = newCoor;
// მიიღეთ წვდომა კლასის წევრებზე:
$object -> name = "Alex" ;
echo $object -> name ;
// ბეჭდავს "Alex"
// ახლა მოდით შევიდეთ კლასის მეთოდზე (ფაქტობრივად, ფუნქცია კლასში):
$object -> Getname();
// „ჯონ“ იბეჭდება დიდი ასოებით
?>

კლასში კლასის წევრებზე წვდომისთვის, თქვენ უნდა გამოიყენოთ მაჩვენებელი $ ეს, რომელიც ყოველთვის ეხება მიმდინარე ობიექტს. შეცვლილი მეთოდი სახელი ():

ფუნქცია Getname() (
echo $this->name;
}

ანალოგიურად, შეგიძლიათ დაწეროთ მეთოდი Setname ():

ფუნქცია Setname($name) (
$this->name = $name;
}

ახლა თქვენ შეგიძლიათ გამოიყენოთ მეთოდი სახელის შესაცვლელად Setname ():

$object->Setname("Peter");
$object->Getname();

და აქ არის სრული კოდის ჩამონათვალი:

// ახალი Coor კლასის შექმნა:
კლასი Coor (
// მონაცემები (თვისებები):
var$ სახელი;

// მეთოდები:
ფუნქცია Getname() (
echo $this -> name ;
}

ფუნქცია Setname($name) (
$this -> name = $name ;
}

}

// შექმენით Coor კლასის ობიექტი:
$object = newCoor;
// ახლა სახელის შესაცვლელად ვიყენებთ Setname() მეთოდს:
$object -> Setname("Nick");
// და წვდომისთვის, როგორც ადრე, Getname():
$object -> Getname();
// სკრიპტი იბეჭდება "Nick"
?>

პოინტერი $ ესასევე შეიძლება გამოყენებულ იქნას არა მხოლოდ მონაცემთა წვდომის მეთოდებზე წვდომისთვის:

ფუნქცია Setname($name) (
$this->name = $name;
$this->Getname();
}

კონსტრუქტორები

ხშირად, ობიექტის შექმნისას, საჭიროა გარკვეული თვისებების მნიშვნელობების დაყენება. საბედნიეროდ, OOP ტექნოლოგიის შემქმნელებმა გაითვალისწინეს ეს გარემოება და განახორციელეს იგი კონცეფციაში. კონსტრუქტორი არის მეთოდი, რომელიც ადგენს ზოგიერთი თვისების მნიშვნელობებს (და ასევე შეუძლია სხვა მეთოდების გამოძახება). ახალი ობიექტების შექმნისას კონსტრუქტორებს ავტომატურად იძახიან. იმისათვის, რომ ეს შესაძლებელი გახდეს, კონსტრუქტორის მეთოდის სახელი უნდა შეესაბამებოდეს კლასის სახელს, რომელიც შეიცავს მას. კონსტრუქტორის მაგალითი:

კლასის ვებგვერდი (
var $bgcolor;
ფუნქციის ვებგვერდი ($color)(
$this -> bgcolor = $color ;
}
}

// Webpage კლასის კონსტრუქტორის გამოძახება
$page = ახალი ვებგვერდი ("ყავისფერი");
?>

ადრე ობიექტის შექმნა და საკუთრების ინიციალიზაცია ცალკე ხდებოდა. დიზაინერები საშუალებას გაძლევთ შეასრულოთ ეს მოქმედებები ერთი ნაბიჯით.

საინტერესო დეტალი: გავლილი პარამეტრების რაოდენობის მიხედვით შეიძლება სხვადასხვა კონსტრუქტორის გამოძახება. განხილულ მაგალითში კლასის ობიექტები Ვებ გვერდიშეიძლება შეიქმნას ორი გზით. პირველ რიგში, შეგიძლიათ გამოძახოთ კონსტრუქტორი, რომელიც უბრალოდ ქმნის ობიექტს, მაგრამ არ ახდენს მისი თვისებების ინიციალიზაციას:

$გვერდი = ახალი ვებგვერდი;

მეორე, ობიექტი შეიძლება შეიქმნას კლასში განსაზღვრული კონსტრუქტორის გამოყენებით - ამ შემთხვევაში, თქვენ ქმნით Webpage კლასის ობიექტს და ანიჭებთ მნიშვნელობას მის თვისებას. bgcolor:

$page = ახალი ვებგვერდი ("ყავისფერი");

დესტრუქტორები

PHP-ში პირდაპირი მხარდაჭერა არ არის. თუმცა, თქვენ შეგიძლიათ მარტივად მოაწყოთ დესტრუქტორი PHP ფუნქციის გამოძახებით გაუქმება (). ეს ფუნქცია ანადგურებს ცვლადის შიგთავსს და აბრუნებს სისტემას მის მიერ დაკავებულ რესურსებს. საგნებით გაუქმება ()მუშაობს ისევე, როგორც ცვლადებთან. ვთქვათ, თქვენ მუშაობთ ობიექტთან $ვებგვერდი. ამ კონკრეტულ ობიექტთან მუშაობის დასრულების შემდეგ ფუნქციას ეწოდება:

unset ($Webpage);

ეს ბრძანება შლის ყველა შინაარსს მეხსიერებიდან $ვებგვერდი. ინკაფსულაციის სულისკვეთებით, შეგიძლიათ დარეკოთ გაუქმება ()დასახელებულ მეთოდში განადგურება ()და მერე დაუძახე:

$Website->Destroy();

დესტრუქტორების გამოძახების აუცილებლობა წარმოიქმნება მხოლოდ ობიექტებთან მუშაობისას, რომლებიც იყენებენ რესურსების დიდ რაოდენობას, რადგან ყველა ცვლადი და ობიექტი ავტომატურად ნადგურდება სკრიპტის დასრულებისას.

ობიექტების ინიცირება

ზოგჯერ საჭიროა ობიექტის ინიციალიზაცია - მისი თვისებების მინიჭება საწყის მნიშვნელობებზე. დავუშვათ, რომ კლასის სახელია კოორდა შეიცავს ორ ქონებას: პირის სახელს და მის საცხოვრებელ ქალაქს. თქვენ შეგიძლიათ დაწეროთ მეთოდი (ფუნქცია), რომელიც მოახდენს ობიექტის ინიციალიზებას, მაგალითად Მასში():

// ახალი Coor კლასის შექმნა:
კლასი Coor (
// მონაცემები (თვისებები):
var$ სახელი;
var $ ქალაქი;

// ინიციალიზაციის მეთოდი:
ფუნქცია Init ($name) (
$this -> name = $name ;
$ this -> city = "ლონდონი" ;
}

}

// შექმენით Coor კლასის ობიექტი:
$object = newCoor;
// ობიექტის ინიციალიზაციისთვის დაუყოვნებლივ გამოიძახეთ მეთოდი:
$object -> Init();
?>

მთავარია არ დაგავიწყდეთ ობიექტის შექმნისთანავე ფუნქციის გამოძახება, ან შექმნას შორის რაიმე მეთოდის გამოძახება (ოპერატორი ახალი) ობიექტი და მისი ინიციალიზაცია (გამოძახება Მასში).

იმისათვის, რომ PHP-მა იცოდეს, რომ ობიექტის შექმნისას საჭიროა გარკვეული მეთოდის ავტომატურად გამოძახება, მას უნდა მიენიჭოს იგივე სახელი, როგორც კლასი ( კოორ):

ფუნქცია Coord ($name)
$this->name = $name;
$this->city = "ლონდონი";
}

მეთოდს, რომელიც ახდენს ობიექტის ინიციალიზებას, ეწოდება კონსტრუქტორი. თუმცა, PHP-ს არ აქვს დესტრუქტორები, რადგან სკრიპტების გასვლისას რესურსები ავტომატურად იხსნება.

კლასის ელემენტებზე წვდომა

კლასის ელემენტებზე წვდომა ხდება ოპერატორის გამოყენებით :: "ორმაგი მსხვილი ნაწლავი" "ორმაგი მსხვილი ნაწლავის" გამოყენებით შეგიძლიათ შეხვიდეთ კლასის მეთოდებზე.

კლასების მეთოდებზე წვდომისას პროგრამისტმა უნდა გამოიყენოს ამ კლასების სახელები.

კლასი A (
ფუნქციის მაგალითი () (
ექო "ეს არის ორიგინალური A::example() ფუნქცია.
" ;
}
}

B კლასი ვრცელდება A (
ფუნქციის მაგალითი () (
ექო "ეს არის B::example().
" ;
A::მაგალითი();
}
}

// არ არის საჭირო A კლასის ობიექტის შექმნა.
// გამოაქვს შემდეგი:
// ეს არის ორიგინალური A::example() ფუნქცია.
A::მაგალითი();

// B კლასის ობიექტის შექმნა.
$b = ახალი B PHP პორტალი ფორუმი. ს.უ.

კლასის ობიექტი- კლასის წარმომადგენელი, რომელსაც აქვს თავისი უნიკალური მდგომარეობა და ქცევა.
ობიექტის გამოსაცხადებლად, თქვენ უნდა გამოიყენოთ ახალი ოპერატორი:

ობიექტი = ახალი ClassName;

PHP

$myObj = new newClass();

კლასის თვისებები

საკუთრება– ეს არის კლასში შენახული ცვლადები; ერთ-ერთი შემდეგი მოდიფიკატორი მოთავსებულია ქონების სახელზე (საჯარო, დაცული, კერძო). ასევე არის var საკვანძო სიტყვა, მაგრამ მისი დრო გავიდა (დარჩა PHP 4 ვერსიაში).

თვისებების აღწერა

PHP

კლასი newClass ( საჯარო $property1; დაცული $property2 = "value2"; პირადი $property3; )

კლასის თვისებებზე წვდომა

კლასის ფარგლებს გარეთ წვდომა ხორციელდება შემდეგნაირად: object->

PHP

$myObj = new newClass(); $myObj->საკუთრება1;

ქონების ღირებულებების შეცვლა

PHP

$myObj->property2 = "აქ ვცვლით მნიშვნელობას";

კლასის მეთოდები

მეთოდიარის კლასში განსაზღვრული ფუნქცია. ფუნქციას ნაგულისხმევად აქვს საჯარო მოდიფიკატორი (ანუ ფუნქციის წინ მისი დაწერა არ არის საჭირო).

მეთოდების აღწერა

PHP

კლასი newClass ( ფუნქცია myMethod($var1,$var2)( // ნაგულისხმევად ეს არის // საჯარო მეთოდი (საჯარო) // ოპერატორები ) )

მეთოდის გამოძახება

PHP

$myObj = new newClass(); $myObj->myMethod("v1","v2");

$ ეს

კლასის თვისება კლასში ხელმისაწვდომია ოპერატორის გამოყენებით ($this):
$this->property_name; (ქონებისთვის დოლარის ნიშანი არ არის!)

კლასის მეთოდი სხვა კლასის მეთოდიდან ასევე ხელმისაწვდომია $this საკვანძო სიტყვის გამოყენებით.

PHP

class newClass ( საჯარო $property1; ფუნქცია myMethod())( echo($this->property1); // გამოიტანეთ თვისების მნიშვნელობა ) ფუნქცია callMethod())( $this->myMethod(); // მეთოდის გამოძახება ) )

კონსტრუქტორები და დესტრუქტორები

კლასის კონსტრუქტორიარის სპეციალური მეთოდი, რომელიც ავტომატურად გამოიძახება ობიექტის შექმნისას.
ფრჩხილები კლასის სახელის შემდეგ(ობიექტის ინიციალიზაციისას) საჭიროა ფუნქციის პარამეტრების კონსტრუქტორისთვის გადასაცემად.

დამღუპველი– სპეციალური მეთოდი, რომელიც ავტომატურად გამოიძახება ობიექტის წაშლისას. პ.ს. ობიექტების წაშლის თანმიმდევრობა არ არის განსაზღვრული, მაგრამ აღსანიშნავია, რომ ობიექტები წაიშლება კოდის დასრულებისას (ობიექტების წაშლის თანმიმდევრობა შეუძლებელია) და გამოიძახება __destruct მეთოდი. ობიექტის იძულებით წაშლა შეიძლება: unset(object_name) .

PHP

class newClass ( public $property; ფუნქცია __construct($var)( $this->property = $var; echo "Call the constructor"; ) ფუნქცია __destruct())(echo "Call the destructor"; ) ) $obj = new newClass ("მნიშვნელობა"); //კონსტრუქტორის გამოძახება unset($obj); //დაუძახეთ დესტრუქტორს (იძულებით)

ფსევდო-მუდმივები __METHOD__ და __CLASS__

ფსევდო-მუდმივები __METHOD__ და __CLASS__. __METHOD__-ის ნაცვლად შეიცვლება შემდეგი: class_name::method_name; __CLASS__ შეიცვლება class_name-ით.

PHP

class newClass ( ფუნქცია myMethod())( echo __METHOD__; ) ფუნქცია getClassName() ( echo __CLASS__; ) ) $obj = new newClass(); $obj->myMethod();// newClass::myMethod $obj->getClassName();// newClass

ობიექტებთან მუშაობის ახალი პრინციპები

ობიექტები გადაეცემა მითითებით და არა მნიშვნელობით

PHP

კლასი newClass ( საჯარო $საკუთრება; ) $myObj = new newClass(); $myObj->საკუთრება = 1; $myObj2 = $myObj; $myObj2->საკუთრება = 2; print($myObj->საკუთრება); // Print 2 print($myObj2->property); // ბეჭდავს 2

ობიექტის კლონირება

კლონირებისას (კლონირება), კონსტრუქტორი არ არის გამოძახებული. არსებობს სპეციალური მეთოდი __კლონი, რომელსაც ეწოდება ობიექტის კლონირებისას.

ობიექტების აშკარად კოპირება

PHP

კლასი newClass ( საჯარო $საკუთრება; ) $myObj = new newClass(); $myObj->საკუთრება = 1; $myObj2 = $myObj კლონი; // შექმენით ობიექტის ასლი, PHP-ის მე-4 ვერსიაში ასე იყო: $myObj2 = &$myObj; // PHP-ის მე-5 ვერსიაში & არ მუშაობს ობიექტებთან $myObj2->property = 2; print($myObj->საკუთრება); // ბეჭდავს 1 print($myObj2->property); // ბეჭდავს 2

მემკვიდრეობა (პოლიმორფიზმი)

ერთ კლასს შეუძლია სხვა კლასის მემკვიდრეობა. ამისათვის არის სპეციალური საკვანძო სიტყვა - ვრცელდება.

PHP

კლასის მანქანა ( საჯარო $numWheels = 4; ფუნქცია printWheels() ( echo $this->numWheels; ) ) კლასი Toyota აფართოებს მანქანას ( public $country = "Japan"; ფუნქცია printCountry() (echo $this->country; ) ) $myMachine = ახალი ტოიოტა(); $myMachine->printWheels(); $myMachine->printCountry();

გადატვირთვის მეთოდი

გადატვირთვის მეთოდი– კლასში, რომელიც მემკვიდრეობით იღებს სხვა კლასს, შეგიძლიათ აღწეროთ იგივე მეთოდი, რომელიც არის მშობელ კლასში, ხოლო ახლად აღწერილი მეთოდი გადაწერს მშობელი კლასის მეთოდს. მაგალითი:

PHP

კლასის მანქანა ( საჯარო $numWheels = 4; ფუნქცია printWheels() ( echo $this->numWheels; ) ) კლასი Toyota აფართოებს მანქანას ( public $country = "Japan"; ფუნქცია printCountry() (echo $this->country; ) ფუნქცია printWheels() ( echo "გადატვირთული printWheels() მეთოდი "; ) ) $myMachine = new Toyota(); $myMachine->printWheels();

მშობელი

parent::method_name, ეს კონსტრუქცია საშუალებას გაძლევთ შეხვიდეთ მშობლის მეთოდზე.

PHP

class Machine ( public $numWheels = 4; ფუნქცია printWheels() ( echo $this->numWheels; ) ) class Toyota extends Machine ( public $country = "Japan"; ფუნქცია printWheels() (echo "გადატვირთული printWheels() მეთოდი"; მშობელი:: printWheels(); ) ) $myMachine = ახალი Toyota(); $myMachine->printWheels();

წვდომის მოდიფიკატორები: საჯარო, დაცული, პირადი

წვდომის მოდიფიკატორები: როგორ მუშაობენ ისინი?

PHP $obj = new newClass(); echo $obj->public; //YES echo $obj->დაცულია; //არა! echo $obj->პირადი; //NO $obj->myMethod();	PHP class newClass ( საჯარო $public = 1; დაცული $protected = 2; პირადი $private = 3; ფუნქცია myMethod())(echo $this->public; //YES echo $this->დაცული; //YES echo $this ->პირადი; //დიახ ))
PHP $obj1 = new NewClass(); echo $obj1->public; //YES echo $obj1->დაცულია; //არა! echo $obj1->პირადი; //NO $obj1->newMethod();	PHP კლასი NewClass აფართოებს newClass ( ფუნქცია newMethod()) (echo $this->protected; //YES echo $this->private; //NO $this->myMethod(); ) )

გამონაკლისის მართვა

ჩვენ გვაქვს კოდის ნაწილი, რომელშიც შეიძლება მოხდეს გარკვეული შეცდომა; კოდის ეს ნაწილი მოთავსებულია ბლოკში, რომელსაც ეწოდება try; იმ ადგილას, სადაც შეიძლება მოხდეს შეცდომა, იდება საკვანძო სიტყვა; დაფიქსირებული შეცდომის დასაჭერად, აღწერილია catch ბლოკი; იქ იგზავნება შეცდომა, რომლითაც შეგვიძლია ვიმუშაოთ.

PHP

სცადე ( $a = 1; $b = 0; if($b == 0) ჩააგდე ახალი გამონაკლისი ("გაყოფა 0-ზე!"); echo $a/$b; ) catch(გამონაკლისი $e)( echo "დადგა შეცდომა - ", $e->getMessage(), // აჩვენებს შეტყობინებას " in line ", $e->getLine(), // აჩვენებს "ფაილის" ხაზის ნომერს, $e->getFile(); // აჩვენებს სახელის ფაილს)

საკუთარი გამონაკლისების შექმნა

PHP

сlass MathException აფართოებს გამონაკლისს ( ფუნქცია __construct($message) ( მშობელი::__construct($message); ) ) სცადეთ ($a = 1; $b = 0; // MathException - კლასის სახელი თქვენი გამონაკლისის შესაქმნელად, თუ ( $b = = 0) გადაყარეთ ახალი MathException("გაყოფა 0-ზე!"); echo $a / $b; ) catch (MathException $e) (echo "მოხდა მათემატიკის შეცდომა", $e->getMessage(), " ხაზში ", $e->getLine(), " ფაილი ", $e->getFile(); )

ობიექტის თვისებების ციკლი

PHP

კლასის პიროვნება ( საჯარო $name; საჯარო $yearOfBorn; ფუნქცია __construct ($name, $yearOfBorn) ( $this->name = $name; $this->yearOfBorn = $yearOfBorn; ) ) $billGates = ახალი პიროვნება ('ბილ გეითსი ',1955); foreach ($billGates როგორც $name=>$value) (ბეჭდვა ($name.': '.$value.'
’); }

კლასის მუდმივები

მუდმივები კლასის მუდმივებია, ანუ ისინი არ მიეკუთვნებიან არცერთ ობიექტს. კოდის მიღმა, მუდმივზე წვდომა შესაძლებელია შემდეგნაირად: class_name::constant_name. თუ გვსურს კლასში მუდმივზე წვდომა, მაშინ უნდა გამოვიყენოთ თვით საკვანძო სიტყვა: self::constant_name.

PHP

class Person ( const HANDS = 2; ფუნქცია printHands())( print (self::HANDS);// NOT $this! მიუთითებს მუდმივზე კლასის შიგნით) ) print ("ხელების რაოდენობა: ".Person::HANDS ); // წვდომა მუდმივზე კლასის გარეთ

აბსტრაქტული მეთოდები და კლასები

აბსტრაქტული კლასი php-ში- ეს არის ეგრეთ წოდებული საბაზისო კლასი, რომელიც არ არის განკუთვნილი მისი ინსტანციების (ობიექტების) შესაქმნელად. აბსტრაქტული კლასების მთავარი მნიშვნელობა და დანიშნულება არის მისი ბავშვის კლასების შესაძლებლობების გაფართოება.

კლასები შეიძლება იყოს აბსტრაქტული. აბსტრაქტული კლასი საშუალებას გვაძლევს აბსტრაქცია გავუწიოთ უმნიშვნელო ნივთებს, რითაც გვაძლევს შესაძლებლობას კონცენტრირდეთ უფრო დახვეწილ ნიუანსებზე.

აბსტრაქტულ კლასს შეიძლება ჰქონდეს აბსტრაქტული მეთოდები(ფუნქციას წინ უძღვის აბსტრაქტული საკვანძო სიტყვა). აბსტრაქტული მეთოდი არის მეთოდი განხორციელების გარეშე (არ არის ხვეული ბრეკეტები).

აბსტრაქტული მეთოდი უნდა იყოს აღწერილი (გადატვირთული) შთამომავლობის კლასში. აბსტრაქტული მეთოდების გამოყენების უპირატესობა: თითოეული შთამომავალი კლასისთვის შეგიძლიათ აღწეროთ აბსტრაქტული მეთოდის უნიკალური ქცევა.

PHP

აბსტრაქტული კლასის Machine ( // აბსტრაქტული კლასის საჯარო $ბენზინი; ფუნქცია startEngine())( print("ძრავა დაიწყო!"); ) აბსტრაქტული ფუნქცია stopEngine(); ) კლასი InjectorMachine აფართოებს Machine ( საჯარო ფუნქცია stopEngine())(ბეჭდვა ("ძრავა გაჩერდა!"); ) ) $myMegaMachine = new Machine();//Error! $myMegaMachine = new InjectorMachine(); $myMegaMachine->startEngine(); $myMegaMachine->stopEngine();

ინტერფეისები

არსებობს სხვა ტიპის აბსტრაქტული კლასი - ინტერფეისი. ინტერფეისიარის აბსტრაქტული კლასი, რომელიც შეიცავს მხოლოდ აბსტრაქტულ მეთოდებს. ასეთ კლასამდე ინტერფეისი იწერება სიტყვის აბსტრაქტის ნაცვლად. ინტერფეისიდან მემკვიდრეობა ხდება არა extends საკვანძო სიტყვის, არამედ Implements საკვანძო სიტყვის მეშვეობით.

PHP

ინტერფეისი Hand ( ფუნქცია useKeyboard(); ფუნქცია touchNose(); ) ინტერფეისი Foot ( ფუნქცია runFast(); ფუნქცია playFootball(); ) class Person ახორციელებს Hand ( საჯარო ფუნქცია useKeyboard() (echo "Use keyboard!"; ) საჯარო ფუნქცია touchNose ()( echo "Touch nose!"; ) public ფუნქცია runFast())(echo "Run fast!"; ) public ფუნქცია playFootball())(echo "Play football!"; ) ) $vasyaPupkin = new Person(); $vasyaPupkin->touchNose();

საბოლოო მეთოდები და კლასები

საბოლოო საკვანძო სიტყვა მოთავსებულია მეთოდის წინ; ეს ხელს უშლის მეთოდის გადატვირთვას (გადაწერას). კლასი ასევე შეიძლება გამოცხადდეს საბოლოო.

PHP

კლასი მათემატიკა ( საბოლოო ფუნქცია countSum($a,$b)( print("Sum: " . $a + $b); ) ) კლასი ალგებრა აფართოებს მათემატიკას ( // შეცდომა მოხდება საჯარო ფუნქციის countSum($a,$b )( $c = $a + $b; ბეჭდვა ("$a-სა და $b-ის ჯამი: $c"); ) )

PHP

ბოლო კლასის საუზმე ( // საბოლოო კლასის ფუნქცია eatFood($food)( print("ჩვენ ვჭამეთ $საჭმელი!"); ) ) // შეცდომა მოხდება კლასი McBreakfast extends Breakfast ( // კლასის აღწერა )

კლასის სტატიკური თვისებები და მეთოდები

კლასის სტატიკური მეთოდები და თვისებები (პლუს კლასის მუდმივები) ეკუთვნის კლასს, ანუ ისინი საერთოა კლასის ყველა ობიექტისთვის. მათზე წვდომა შეუძლებელია ‛arrow‛-ის გამოყენებით, მაგრამ მხოლოდ:: (კლასში გამოიყენეთ: self::$property_name; კლასის გარეთ: class_name::$property_name). სტატიკური თვისება, მეთოდის მსგავსად, გამოცხადებულია სტატიკური საკვანძო სიტყვის გამოყენებით. როგორც თქვენ ალბათ მიხვდებით, თქვენ არ შეგიძლიათ გამოიყენოთ ეს სტატიკური მეთოდის შიგნით (ასეთი მეთოდები არ ასოცირდება ობიექტებთან).

PHP

კლასი CookieLover ( სტატიკური $loversCount = 0; // ეს არის სტატიკური თვისება და შემდგენელი არ // არ წაშლის მას ფუნქციის __construct ფუნქციის __construct()) ( ++self::$loversCount; ) სტატიკური ფუნქცია Welcome()) ( echo " კეთილი იყოს თქვენი მობრძანება ფუნთუშების მოყვარულთა კლუბში!"; //არა $this სტატიკური მეთოდის შიგნით! ) ) $vasyaPupkin = new CookieLover(); $frosyaBurlakova = new CookieLover(); print("ქუქიების მოყვარულთა ამჟამინდელი რაოდენობა: ".CookieLover::$loversCount); print(CookieLover::welcome());

საკვანძო სიტყვის მაგალითი

ზოგჯერ თქვენ უნდა გაარკვიოთ არის თუ არა მიმდინარე ობიექტი კონკრეტული კლასის ან ინტერფეისის მემკვიდრე. ამისათვის გამოიყენება საკვანძო სიტყვის მაგალითი.

PHP

class Person() $myBoss = new Person(); if($myBoss instanceOf Person) print("ჩემი ბოსი ადამიანია!"); // დაბრუნდება true, თუ Person კლასი არის ობიექტის წინაპრებში $myBoss კლასი Woman extends Person () $englishQueen = new Woman(); if($englishQueen instanceOf Person) print("ინგლისის დედოფალიც ადამიანია!"); ინტერფეისი LotsOfMoney() კლასი ReachPeople ახორციელებს LotsOfMoney() $billGates = new ReachPeople(); if($billGates instanceOf LotsOfMoney) print("ბილ გეითსს ბევრი ფული აქვს!");

__autoload() ფუნქცია

თუ PHP ობიექტის ინიციალიზაციისას შეხვდება არარსებულ კლასს, ის ეძებს __autoload ფუნქციას და გადასცემს უსახელო კლასის სახელს __autoload ფუნქციას. და PHP გამოიძახებს ამ ფუნქციას გამოტოვებული კლასის შეცდომამდე.

PHP

ფუნქცია __autoload($cl_name)( // $cl_name არის არ მოიძებნა კლასის print("კლასის ობიექტის შექმნის მცდელობა ".$cl_name); ) $obj = new undefinedClass();

ობიექტების თვისებებზე წვდომის მეთოდები

__set() მეთოდი შესრულდება როცა ჩანაწერებიმონაცემები მიუწვდომელ თვისებებში (რომლებიც არ არის კლასში).

__get() მეთოდი შესრულდება როცა კითხვამონაცემები მიუწვდომელი თვისებებიდან (რომლებიც არ არის კლასში).

PHP

კლასი newClass ( კერძო $თვისებები; ფუნქცია __get($name)( print("საკუთრების $name მნიშვნელობის წაკითხვა"); დაბრუნება $this->თვისებები[$name]; ) ფუნქცია __set($name,$value)(/ / ჩვენს შემთხვევაში, $name არის თვისება, $value უდრის 1 print("ახალი თვისების დაყენება $name = $value"); $this->თვისებები[$name] = $value; ) ) $obj = ახალი ახალი კლასი; $obj->საკუთრება = 1; // დაწერეთ ახალი თვისება $a = $obj->საკუთრება; // ქონების ღირებულების წაკითხვა ბეჭდვა $a; // 1

ზარების გადატვირთვა არარსებულ მეთოდებზე

მეთოდს თუ მოვუწოდებთ რომელიც არ არსებობს, შემდეგ PHP ეძებს __call მეთოდს (1-ლი პარამეტრი არის არარსებული მეთოდის სახელი, მე-2 არის არგუმენტების მასივი).

PHP

class newClass ( ფუნქცია __call($name, $params)( print("$name მეთოდის გამოძახების მცდელობა შემდეგი პარამეტრებით: "); print_r($params); ) ) $obj = new newClass(); $obj->megaMethod(1,2,3"four");

__toString() მეთოდი

__toString() მეთოდი საშუალებას აძლევს კლასს გადაწყვიტოს, როგორ უნდა მოახდინოს რეაგირება სტრინგზე გადაყვანისას. მაგალითად, რას ეხმიანება $obj; დაბეჭდავს? . ამ მეთოდმა უნდა დააბრუნოს სტრიქონი, წინააღმდეგ შემთხვევაში ის აღმოაჩენს გამოუსწორებელ E_RECOVERABLE_ERROR შეცდომას.

PHP

class newClass ( ფუნქცია __toString())( return "მეთოდი __toString() იყო გამოძახებული"; ) ) $obj = new newClass(); // __toString() მეთოდი მოუწოდა echo $obj;