თქვენი პირველი პროგრამირების ენა დიდ გავლენას ახდენს იმაზე, თუ როგორ ფიქრობთ კოდზე

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

მემკვიდრეობა ჯავაში

ჯავაში მემკვიდრეობის იდეა მჭიდროდ არის დაკავშირებული ქვეტიპის კონცეფციასთან. ქვეტიპინგი არის IS A ურთიერთობის განხორციელება. მაგალითად, Rabbit კლასი არის Mammal კლასის ქვეტიპი. ამიერიდან, Rabbit მაგალითს აქვს Mammal ყველა ქცევა : ის მემკვიდრეობით იღებს ქცევას.

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

ეს არის აშკარა მემკვიდრეობა .

 class Animal { void feed(); } class Rabbit extends Animal { //1 }

1. იმის გამო Animal რომ Rabbit IS A , მას შეუძლია feed()

მემკვიდრეობა Go-ში

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

თუ ის იხვს ჰგავს, იხვივით ცურავს და იხვივით ცურავს, მაშინ ალბათ ასეა.

თუ Go struct ახორციელებს იგივე ფუნქციებს, როგორც ინტერფეისი, ის ირიბად ახორციელებს ინტერფეისს.

 type Animal interface { feed() //1 } type Rabbit struct { } func (rabbit Rabbit) feed() { //2 // feeds }

1. Animal შეუძლია კვება
2. იმის გამო, რომ feed() ფუნქცია არსებობს, რომელიც პარამეტრად იღებს Rabbit , Rabbit ახორციელებს Animal

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

მემკვიდრეობა პითონში

პითონი ყველაზე საინტერესო ენაა, რაც მე ვიცი მემკვიდრეობასთან დაკავშირებით.

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

 class Animal: def feed(self): #1 pass #2 class Rabbit(Animal): #3 pass

1. Animal შეუძლია კვება
2. პითონში არ არის აბსტრაქტული კლასები და ინტერფეისები, მხოლოდ კლასები
3. იმის გამო Animal რომ Rabbit IS A , მას შეუძლია feed()

ამ მხრივ, Python მუშაობს ისევე, როგორც ჯავა მემკვიდრეობის თვალსაზრისით. პითონი ასევე გთავაზობთ იხვის აკრეფას, რომელიც მე აღვწერე, როგორც ჯადოსნური მეთოდები . მაგალითად, იმისთვის, რომ გააკეთოთ რაღაც iterable , მაგ. , რომელსაც შეუძლია დააბრუნოს iterator , თქვენ მხოლოდ უნდა განახორციელოთ __iter__() და __next__() :

 class SingleValueIterable(): done = False def __init__(self, value): self.value = value def __iter__(self): #1 return self def __next__(self): #1 if self.done: raise StopIteration else: self.done = True return self.value svi = SingleValueIterable(5) sviter = iter(svi) #2 for x in sviter: print(x) #3

1. იხვი აკრეფის მეთოდები
2. შექმენით Iterator - Pythons-მა იცის როგორ, მას შემდეგ, რაც ჩვენ განვახორციელეთ ზემოთ აღწერილი მეთოდები
3. ბეჭდვა 5

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

 class Animal: def feed(): pass class Rabbit: def feed(): pass

ზემოთ მოყვანილ ფრაგმენტში Rabbit არ არის Animal , რაც ძალიან გვაწუხებს. შეიყვანეთ PEP 544 , სახელწოდებით Protocols: Structural subtyping (სტატიკური იხვი აკრეფა). PEP წყვეტს ჩვენი კლასებისთვის ჯადოსნური მეთოდების განსაზღვრის შეუძლებლობას. ის განსაზღვრავს Protocol მარტივ კლასს: მას შემდეგ, რაც თქვენ მიიღებთ მემკვიდრეობას, კლასში განსაზღვრული მეთოდები გახდება შესაფერისი იხვი აკრეფისთვის, აქედან გამომდინარე, სახელწოდება - სტატიკური იხვი აკრეფა.

 from typing import Protocol class Animal(Protocol): #1 def feed(): #2 pass class Rabbit: def feed(): #2 pass class VenusFlytrap: def feed(): #2 pass

1. მემკვიდრეობა Protocol
2. რადგან Animal არის Protocol , ნებისმიერი კლასი, რომელიც განსაზღვრავს feed() ხდება Animal , უკეთესი ან უარესი.

დასკვნა

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

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

გადადით უფრო შორს:

• მემკვიდრეობა (ობიექტზე ორიენტირებული პროგრამირება)
• იხვი აკრეფა
• პითონის პროტოკოლი

თავდაპირველად გამოქვეყნდა A Java Geek- ში 2025 წლის 26 იანვარს