სათაური: ვისწავლოთ ობიექტზე ორიენტირებული პროგრამირება (OOP) Python-ით!

ჰეი ბავშვებო! ოდესმე დაფიქრებულხართ, როგორ მოაწყოთ თქვენი კოდი და გახადოთ

ის უფრო სახალისო და ეფექტური? მოდით, ჩავუღრმავდეთ ობიექტზე ორიენტირებული
პროგრამირების (OOP) საინტერესო სამყაროს პითონის გამოყენებით!

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

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

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

ახლა იფიქრე თამაშზე. თამაშში თქვენ გყავთ განსხვავებული პერსონაჟები , როგორიცაა

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

ვთქვათ, გვინდა შევქმნათ თამაში სუპერგმირებით. ჩვენ შეგვიძლია შევქმნათ

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

OOP-ის ძალა ნამდვილად ანათებს, როდესაც ვიწყებთ ობიექტების გაერთიანებას და მათ

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

OOP-ის კიდევ ერთი რეალური მაგალითია რესტორანი. რესტორანში თქვენ გაქვთ

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

OOP ხდის კოდირებას უფრო ორგანიზებულ, მრავალჯერად გამოყენებადს და უფრო

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

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

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

CASE #1:

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

განსაზღვრით: წიგნი და ბიბლიოთეკა.

წიგნის კლასი:

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

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

2.

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

ახლა მოდით შევქმნათ ობიექტები და ვიმოქმედოთ ბიბლიოთეკის მართვის სისტემასთან :

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

აღწერა:

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

განსაზღვრით: წიგნი და ბიბლიოთეკა.

წიგნის კლასი:

პითონი

დააკოპირეთ კოდი

კლასის წიგნი:
 def __init__(თვითონ, სათაური, ავტორი, გამოცემის_წელი):

თვით.სათაური = სათაური

თვით.ავტორი = ავტორი

self.publication_year = გამოქვეყნების_წელი

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

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

ბიბლიოთეკის კლასი:

პითონი

დააკოპირეთ კოდი

კლასის ბიბლიოთეკა:

Def __Init__(თვითონ):

self.books = []

def add_book(self, book):

self.books.append(წიგნი)

def remove_book(self, book):

self.books.remove(წიგნი)

def search_book_by_author (თვითონ, ავტორი):

შესატყვისი_წიგნები = []

წიგნისთვის self.books:

თუ წიგნი.ავტორი == ავტორი:

matching_books.append(წიგნი)

შესატყვისი_წიგნების დაბრუნება

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

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

ახლა მოდით შევქმნათ ობიექტები და ვიმოქმედოთ ბიბლიოთეკის მართვის სისტემასთან :

პითონი

დააკოპირეთ კოდი

# შექმენით ბიბლიოთეკის ობიექტი

ჩემი_ბიბლიოთეკა = ბიბლიოთეკა()

# შექმენით წიგნის ობიექტები

book1 = წიგნი ("ჰარი პოტერი და ფილოსოფიური ქვა", "J.K. Rowling", 1997)

book2 = წიგნი ("დამცინავი ფრინველის მოკვლა", "ჰარპერ ლი", 1960)

book3 = წიგნი ("დიდი გეტსბი", "ფ. სკოტ ფიცჯერალდი", 1925)

# დაამატეთ წიგნები ბიბლიოთეკაში

my_library.add_book(book1)

my_library.add_book(book2)

my_library.add_book(book3)

# ამოიღეთ წიგნი ბიბლიოთეკიდან

my_library.remove_book(book2)

# მოძებნეთ კონკრეტული ავტორის წიგნები

matching_books = my_library.search_book_by_author ("ჯ.კ. როულინგი")

წიგნისთვის matching_books-ში:

ბეჭდვა (წიგნი.სათაური)

ამ კოდში, ჩვენ ვქმნით ბიბლიოთეკის ობიექტს სახელწოდებით my_library და სამი Book

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

ეს კოდი გვიჩვენებს, თუ როგორ გვაძლევს OOP საშუალებას მოვაწყოთ ჩვენი კოდი

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

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

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

ასე რომ, ამ შემთხვევაში, OOP გვეხმარება შევქმნათ ბიბლიოთეკის მართვის სისტემა ,

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

დაიმახსოვრეთ, OOP არის ძლიერი პარადიგმა, რომელიც კოდირებას უფრო

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

იმედი მაქვს, რომ ეს მაგალითი და კოდის გადაწყვეტა დაეხმარება OOP-ის გამოყენების

ილუსტრირებას რეალურ სცენარში.

CASE #2

აღწერა:

სკოლის მართვის სისტემის შესაქმნელად, შეგვიძლია განვსაზღვროთ ორი კლასი :

სტუდენტი და სკოლა.
სტუდენტური კლასი:

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

სახელი, კლასი და ასაკი. __init__ მეთოდი არის კონსტრუქტორი, რომელიც ახდენს ამ
ატრიბუტების ინიციალიზებას. კლასს ასევე აქვს ისეთი მეთოდები, როგორიცაა study() და
take_exam(), რომლებიც წარმოადგენენ მოქმედებებს, რომელთა შესრულებაც სტუდენტს
შეუძლია.

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

ახლა მოდით შევქმნათ ობიექტები და ვიმოქმედოთ სკოლის მართვის სისტემასთან :

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

აღწერა:

სკოლის მართვის სისტემის შესაქმნელად, შეგვიძლია განვსაზღვროთ ორი კლასი :

სტუდენტი და სკოლა.

სტუდენტური კლასი:

პითონი

დააკოპირეთ კოდი

კლასის მოსწავლე:
 def __ init__ (თავი, სახელი, კლასი, ასაკი):

თვით.სახელი = სახელი

თვით.კლასი = შეფასება

თვით.ასაკი = ასაკი

სწავლა (თვითონ):

print (f"{self.name} სწავლობს.")

def take_exam(self):

print(f"{self.name} გადის გამოცდას.")

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

სახელი, კლასი და ასაკი. __init__ მეთოდი არის კონსტრუქტორი, რომელიც ახდენს ამ
ატრიბუტების ინიციალიზებას. კლასს ასევე აქვს ისეთი მეთოდები, როგორიცაა study() და
take_exam(), რომლებიც წარმოადგენენ მოქმედებებს, რომელთა შესრულებაც სტუდენტს
შეუძლია.

სკოლის კლასი:

პითონი

დააკოპირეთ კოდი

კლასის სკოლა:

def __init__(თავი, სახელი, მდებარეობა):

თვით.სახელი = სახელი

თვით.ადგილმდებარეობა = მდებარეობა

თვითმმართველობა.სტუდენტები = []

def enroll_student(თვითონ, სტუდენტი):

self.students.append(სტუდენტი)

def dismiss_student(თვითონ, სტუდენტი):

self.students.remove(სტუდენტი)
 def list_students(self):

ბეჭდვა (f"სტუდენტები {self.name}-ზე:")

სტუდენტისთვის თვითმმართველობის. სტუდენტები:

print(f"- {student.name}")

სკოლის კლასი წარმოადგენს სკოლას და აქვს მოსწავლეების ჩარიცხვის , სტუდენტების

გათავისუფლების და სკოლის ყველა მოსწავლის ჩამოთვლის მეთოდები . enroll_student
მეთოდი ამატებს მოსწავლის ობიექტს სკოლის მოსწავლეთა სიაში. dismiss_student მეთოდი
ამოიღებს სტუდენტის ობიექტს სიიდან. list_students მეთოდი აჩვენებს სკოლაში
ჩარიცხული ყველა მოსწავლის სახელს.

ახლა მოდით შევქმნათ ობიექტები და ვიმოქმედოთ სკოლის მართვის სისტემასთან :

პითონი

დააკოპირეთ კოდი

# შექმენით სკოლის ობიექტი

my_school = სკოლა ("ABC School", "Cityville")

# შექმენით სტუდენტური ობიექტები

student1 = სტუდენტი ("ალისა", 5, 10)

student2 = სტუდენტი ("ბობ", 6, 11)

student3 = სტუდენტი ("ჩარლი", 4, 9)

# ჩარიცხეთ მოსწავლეები სკოლაში

my_school.enroll_student(student1)

my_school.enroll_student(student2)

my_school.enroll_student(student3)

# გაათავისუფლეთ მოსწავლე სკოლიდან

my_school.dismiss_student(student2)
# ჩამოთვალეთ სკოლის ყველა მოსწავლე

my_school.list_students()

ამ კოდში ჩვენ ვქმნით სკოლის ობიექტს სახელად my_school და სამ სტუდენტურ ობიექტს ,
რომლებიც წარმოადგენენ სხვადასხვა სტუდენტებს. შემდეგ ჩვენ ვარიცხავთ ამ
მოსწავლეებს სკოლაში enroll_student მეთოდით. შემდეგ სკოლიდან გავათავისუფლებთ
ერთ მოსწავლეს dismiss_student მეთოდით. ბოლოს ჩამოვთვლით სკოლის ყველა
მოსწავლეს list_students მეთოდით.

ეს კოდი გვიჩვენებს, თუ როგორ გვაძლევს OOP საშუალებას მოვახდინოთ სკოლის

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

OOP უზრუნველყოფს სტრუქტურირებულ და მოდულურ მიდგომას რეალურ ცხოვრებაში

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

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

გახსოვდეთ, OOP არის მძლავრი პარადიგმა, რომელიც მოაქვს სტრუქტურას და

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

ენკაფსულაცია:

ენკაფსულაცია ჰგავს საგანძურს, რომელიც ინახავს ძვირფას ნივთებს . OOP-ში ჩვენ

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

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

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

მემკვიდრეობა:

მემკვიდრეობა ჰგავს მშობლებისგან შვილებს განსაკუთრებული შესაძლებლობების ან

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

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

პოლიმორფიზმი:

პოლიმორფიზმი ჰგავს სუპერგმირს, რომელიც ცვლის თავის ფორმას ან ფორმას

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

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

აბსტრაქცია:

აბსტრაქცია ჰგავს მნიშვნელოვან ნაწილებზე ფოკუსირებას და არასაჭირო დეტალების

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

მაგალითი: წარმოიდგინეთ ავტომობილის ობიექტი. მას შეიძლება ჰქონდეს ისეთი

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

OOP-ის ეს პრინციპები გვეხმარება უკეთესი, ორგანიზებული და მრავალჯერადი

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

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