Η κληρονομικότητα είναι ένα ισχυρό χαρακτηριστικό της αντικειμενοστραφούς προγραμματισμού που μας επιτρέπει να δημιουργούμε κλάσεις που βασίζονται σε άλλες κλάσεις, επαναχρησιμοποιώντας και επεκτείνοντας τον κώδικα. Αυτό μας δίνει τη δυνατότητα να οργανώνουμε τον κώδικα μας με λογικό τρόπο, να αποφεύγουμε την επανάληψη κώδικα και να διευκολύνουμε τη συντήρηση και τη διαχείριση των κλάσεων μας.
Η κληρονομικότητα μπορεί να εφαρμοστεί με διάφορους τρόπους, ανάλογα με τις ανάγκες μας. Μπορούμε να χρησιμοποιήσουμε τη απλή κληρονομικότητα, όπου μια κλάση κληρονομεί τις ιδιότητες και τις μεθόδους μιας μόνο γονικής κλάσης. Μπορούμε επίσης να έχουμε πολλαπλή κληρονομικότητα, όπου μια κλάση κληρονομεί τις ιδιότητες και τις μεθόδους από πολλές γονικές κλάσεις ταυτόχρονα. Τέλος, μπορούμε να χρησιμοποιήσουμε την πολυεπίπεδη κληρονομικότητα, όπου μια κλάση κληρονομεί τις ιδιότητες και τις μεθόδους από μια γονική κλάση, η οποία καθ’ αυτήν την είναι υποκλάση μιας άλλης κλάσης.
Μέσω της κληρονομικότητας, μπορούμε να δημιουργήσουμε ιεραρχίες κλάσεων που αντικατοπτρίζουν τις σχέσεις και τις ιδιότητες στον πραγματικό κόσμο, επιτυγχάνοντας έτσι έναν πιο οργανωμένο και επεκτάσιμο κώδικα.
Για να δημιουργήσετε μια υποκλάση στην Python που κληρονομεί από μια γονική κλάση, απλά αναφέρετε το όνομα της γονικής κλάσης μέσα στις παρενθέσεις κατά τον ορισμό της υποκλάσης. Αυτό γίνεται με την εξής σύνταξη:
class Subclass(ParentClass): # Κανόνες και μέθοδοι της υποκλάσης
Στον παραπάνω κώδικα, η υποκλάση Subclass
δημιουργείται και κληρονομεί από τη γονική κλάση ParentClass
. Έτσι, η υποκλάση κληρονομεί τις ιδιότητες και τις μεθόδους της γονικής κλάσης και μπορεί επίσης να προσθέσει τις δικές της κανόνες και μεθόδους.
Εδώ βάζουμε το όνομα της γονικής κλάσης στις παρενθέσεις κατά τον ορισμό της υποκλάσης για να καθορίσουμε τη σχέση κληρονομικότητας μεταξύ των κλάσεων.
Όταν μια υποκλάση κληρονομεί από μια γονική κλάση στην Python, αποκτά πρόσβαση και μπορεί να χρησιμοποιήσει όλες τις μεθόδους και ιδιότητες της γονικής κλάσης. Αυτό σημαίνει ότι η υποκλάση μπορεί να αξιοποιήσει την υπάρχουσα λειτουργικότητα της γονικής κλάσης χωρίς να χρειάζεται να υλοποιηθεί ξανά.
Επιπλέον, η υποκλάση έχει τη δυνατότητα να προσθέσει νέες μεθόδους και ιδιότητες που είναι ειδικές για την υποκλάση. Μπορεί επίσης να παρακάμψει (override) τις υπάρχουσες μεθόδους και ιδιότητες της γονικής κλάσης, αντικαθιστώντας την υλοποίησή τους με μια νέα που ανταποκρίνεται στις απαιτήσεις της υποκλάσης.
Η χρήση της κληρονομικότητας συμβάλλει στην ευκολία συντήρησης του κώδικα, καθώς αλλαγές που γίνονται στη γονική κλάση επηρεάζουν αυτόματα και τις υποκλάσεις. Έτσι, ο κώδικας μπορεί να είναι πιο οργανωμένος, ευανάγνωστος και ευέλικτος, καθώς οι αλλαγές και οι βελτιώσεις μπορούν να εφαρμοστούν σε ολόκληρη την ιεραρχία των κλάσεων με έναν απλό τρόπο.
[adinserter block=”2″]
Για να καλέσετε μια μέθοδο από τη γονική κλάση στην υποκλάση, μπορείτε να χρησιμοποιήσετε τη λέξη-κλειδί super()
:
class Parent: def my_method(self): print("Μέθοδος της γονικής κλάσης") class SubClass(Parent): def my_method(self): super().my_method() # Κλήση της μεθόδου my_method() της γονικής κλάσης με τη χρήση της συνάρτησης super() print("Μέθοδος της υποκλάσης") obj = SubClass() # Δημιουργία αντικειμένου της υποκλάσης SubClass obj.my_method() # Κλήση της μεθόδου my_method() του αντικειμένου obj
Ο παραπάνω κώδικας ορίζει δύο κλάσεις, την Parent
και την SubClass
.
Η κλάση Parent
έχει μία μέθοδο με όνομα my_method
που εκτυπώνει το μήνυμα “Μέθοδος της γονικής κλάσης”.
Η κλάση SubClass
κληρονομεί από την Parent
και έχει επίσης μία μέθοδο my_method
. Στην αρχή της μεθόδου, καλεί την my_method
της γονικής κλάσης χρησιμοποιώντας τη συνάρτηση super()
. Έπειτα, εκτυπώνει το μήνυμα “Μέθοδος της υποκλάσης”.
Στο κύριο μέρος του κώδικα, δημιουργείται ένα αντικείμενο obj
της κλάσης SubClass
. Στη συνέχεια, καλείται η μέθοδος my_method()
του αντικειμένου obj
.
Κατά την εκτέλεση, η μέθοδος my_method()
της SubClass
καλεί πρώτα την my_method()
της Parent
με τη χρήση της super()
, εκτυπώνοντας το μήνυμα “Μέθοδος της γονικής κλάσης”, και στη συνέχεια εκτυπώνει το μήνυμα “Μέθοδος της υποκλάσης”. Έτσι, στην έξοδο θα εμφανιστούν τα δύο μηνύματα, με τη σειρά “Μέθοδος της γονικής κλάσης” και “Μέθοδος της υποκλάσης”.
Χρησιμοποιώντας τη λέξη-κλειδί super()
, μπορείτε να καλέσετε μια μέθοδο από την γονική κλάση και να προσθέσετε ή να τροποποιήσετε τη λειτουργικότητά της στην υποκλάση. Αυτό σας επιτρέπει να διατηρήσετε την οργάνωση του κώδικα και την ευκολία συντήρησής του, καθώς μπορείτε να επωφεληθείτε από την υπάρχουσα λειτουργικότητα της γονικής κλάσης και να προσθέσετε μόνο τις απαραίτητες αλλαγές ή επεκτάσεις.
Για να προσθέσετε τη συνάρτηση __init__()
στην υποκλάση, μπορείτε να την ορίσετε μέσα στην κλάση, όπως θα κάνατε με οποιαδήποτε άλλη μέθοδο. Η συνάρτηση __init__()
είναι μια ειδική μέθοδος που καλείται αυτόματα όταν δημιουργείται ένα νέο αντικείμενο της κλάσης.
Για να προσθέσετε τη μέθοδο __init__()
στην υποκλάση, απλά ορίζετε τη μέθοδο μέσα στην κλάση, με το όνομα __init__
, όπως θα κάνατε με οποιαδήποτε άλλη μέθοδο. Η μέθοδος __init__()
είναι μια ειδική μέθοδος που καλείται αυτόματα κατά τη δημιουργία ενός νέου αντικειμένου της κλάσης.
Δείτε το παρακάτω παράδειγμα:
class Parent: def __init__(self): print("Κατασκευαστής της γονικής κλάσης") class SubClass(Parent): def __init__(self): super().__init__() # Κλήση του κατασκευαστή της γονικής κλάσης με τη χρήση της συνάρτησης super() print("Κατασκευαστής της υποκλάσης") obj = SubClass() # Δημιουργία ενός αντικειμένου της υποκλάσης
Ο παραπάνω κώδικας ορίζει δύο κλάσεις, την Parent
και την SubClass
.
Η κλάση Parent
έχει έναν κατασκευαστή (__init__
) που εκτυπώνει το μήνυμα “Κατασκευαστής της γονικής κλάσης”.
Η κλάση SubClass
είναι μια υποκλάση της κλάσης Parent
και έχει επίσης έναν κατασκευαστή. Στον κατασκευαστή της SubClass
, πρώτα γίνεται η κλήση του κατασκευαστή της γονικής κλάσης (super().__init__()
), που εκτελεί τον κατασκευαστή της Parent
και εκτυπώνει το μήνυμα “Κατασκευαστής της γονικής κλάσης”. Στη συνέχεια, εκτυπώνεται το μήνυμα “Κατασκευαστής της υποκλάσης”.
Τέλος, δημιουργείται ένα αντικείμενο της κλάσης SubClass
με τη γραμμή κώδικα obj = SubClass()
, και εκτυπώνονται τα αντίστοιχα μηνύματα κατά την εκτέλεση του κατασκευαστή.
Χρησιμοποιώντας τη συνάρτηση __init__()
στην υποκλάση, μπορούμε να ορίσουμε και να προσθέσουμε ιδιότητες ή μεθόδους που είναι ειδικές για την υποκλάση. Ταυτόχρονα, μπορούμε να κληρονομήσουμε τις ιδιότητες και τις μεθόδους της γονικής κλάσης και να τις τροποποιήσουμε ανάλογα με τις ανάγκες μας. Αυτή η δυνατότητα μας επιτρέπει να δημιουργήσουμε πιο εξειδικευμένα αντικείμενα που αντικατοπτρίζουν τις ιδιαιτερότητες της υποκλάσης και να τα διαχειριστούμε αποτελεσματικότερα.
[adinserter block=”3″]
Επιπλέον, μπορείτε να προσθέσετε παραμέτρους στη μέθοδο __init__()
της υποκλάσης και να τις περάσετε ως παραμέτρους στην κλήση της μεθόδου super().__init__()
, προκειμένου να περάσουν αυτές οι παράμετροι στη γονική κλάση. Αυτό επιτρέπει τη μεταφορά πληροφοριών από την υποκλάση στη γονική κλάση κατά τη δημιουργία ενός αντικειμένου της υποκλάσης.
Παράδειγμα:
class Parent: def __init__(self, x): print("Κατασκευαστής της γονικής κλάσης:", x) class SubClass(Parent): def __init__(self, x, y): super().__init__(x) # Κλήση του κατασκευαστή της γονικής κλάσης με τη χρήση της super() print("Κατασκευαστής της υποκλάσης:", y) obj = SubClass(1, 2) # Δημιουργία ενός αντικειμένου της υποκλάσης SubClass με τις παραμέτρους 1 και 2
Ο παραπάνω κώδικας ορίζει δύο κλάσεις, την Parent
και την SubClass
. Η κλάση SubClass
είναι μια υποκλάση της κλάσης Parent
, δηλαδή κληρονομεί τις ιδιότητες και τις μεθόδους της.
Η κλάση Parent
έχει έναν κατασκευαστή (__init__
) που δέχεται ένα όρισμα x
και εκτυπώνει το μήνυμα “Κατασκευαστής της γονικής κλάσης:” ακολουθούμενο από την τιμή του x
.
Η κλάση SubClass
έχει επίσης έναν κατασκευαστή (__init__
) που δέχεται δύο ορίσματα x
και y
. Αρχικά, καλείται ο κατασκευαστής της γονικής κλάσης (super().__init__(x)
) για να εκτελεστεί ο κώδικας του κατασκευαστή της γονικής κλάσης. Στη συνέχεια, εκτυπώνεται το μήνυμα “Κατασκευαστής της υποκλάσης:” ακολουθούμενο από την τιμή του y
.
Τέλος, δημιουργείται ένα αντικείμενο της κλάσης SubClass
με τις παραμέτρους 1 και 2, και ο κατασκευαστής της υποκλάσης εκτελείται, εκτυπώνοντας τα αντίστοιχα μηνύματα.
Συνολικά, ο κώδικας εκτυπώνει τα μηνύματα:
Κατασκευαστής της γονικής κλάσης: 1 Κατασκευαστής της υποκλάσης: 2
δείχνοντας έτσι τη σειρά εκτέλεσης των κατασκευαστών των κλάσεων.
Η κληρονομικότητα και η χρήση της συνάρτησης __init__()
στην Python μας επιτρέπουν να δημιουργήσουμε υποκλάσεις που επωφελούνται από τις ιδιότητες και τις μεθόδους των γονικών κλάσεων. Αυτό μας παρέχει μεγαλύτερη ευελιξία και χρηστικότητα κατά την ανάπτυξη λογισμικού, καθώς μπορούμε να επαναχρησιμοποιήσουμε τον κώδικα που έχει ήδη υλοποιηθεί στις γονικές κλάσεις.
Με τη χρήση της κληρονομικότητας, μια υποκλάση μπορεί να κληρονομήσει τα χαρακτηριστικά της γονικής κλάσης και να προσθέσει ή να τροποποιήσει τη συμπεριφορά ανάλογα με τις ανάγκες της. Αυτό μας επιτρέπει να αποφύγουμε την επανάληψη κώδικα και να εξοικονομήσουμε χρόνο και προσπάθεια.
Η συνάρτηση __init__()
αναφέρεται στον κατασκευαστή μιας κλάσης και καλείται αυτόματα κατά τη δημιουργία ενός νέου αντικειμένου από αυτήν την κλάση. Χρησιμοποιώντας την super().__init__()
μέσα στον κατασκευαστή μιας υποκλάσης, μπορούμε να καλέσουμε τον κατα
σκευαστή της γονικής κλάσης και να εκτελέσουμε τον κώδικα του πριν συνεχίσουμε με τον κώδικα της υποκλάσης. Αυτό μας επιτρέπει να διαχειριστούμε κοινές λειτουργίες και ιδιότητες μεταξύ των κλάσεων και να προσθέσουμε επιπλέον λειτουργίες στην υποκλάση.
Η κληρονομικότητα είναι ένας σημαντικός πυλώνας του αντικειμενοστραφούς προγραμματισμού και μας βοηθά να δημιουργήσουμε κώδικα που είναι ευανάγνωστος, επαναχρησιμοποιήσιμος και ευέλικτος για μελλοντικές αλλαγές και επεκτάσεις.
Παρακάτω θα δούμε ένα παράδειγμα που δείχνει πώς να χρησιμοποιήσετε την κληρονομικότητα και τη συνάρτηση __init__()
για να δημιουργήσετε μια υποκλάση που επεκτείνει τη λειτουργικότητα της γονικής κλάσης:
class Vehicle: def __init__(self, make, model, year): self.make = make # Αρχικοποίηση της μεταβλητής make με την τιμή που δόθηκε ως όρισμα self.model = model # Αρχικοποίηση της μεταβλητής model με την τιμή που δόθηκε ως όρισμα self.year = year # Αρχικοποίηση της μεταβλητής year με την τιμή που δόθηκε ως όρισμα def print_info(self): print(f"Κατασκευαστής: {self.make}, Μοντέλο: {self.model}, Έτος: {self.year}") class Car(Vehicle): def __init__(self, make, model, year, doors): super().__init__(make, model, year) # Κλήση του constructor της γονικής κλάσης για να αρχικοποιηθούν οι κοινές μεταβλητές self.doors = doors # Αρχικοποίηση της μεταβλητής doors με την τιμή που δόθηκε ως όρισμα def print_info(self): super().print_info() # Κλήση της μεθόδου print_info της γονικής κλάσης για να εκτυπωθούν οι κοινές πληροφορίες print(f"Πόρτες: {self.doors}") # Εκτύπωση του αριθμού των πορτών του αυτοκινήτου my_car = Car("Toyota", "Corolla", 2021, 4) # Δημιουργία αντικειμένου Car με τις συγκεκριμένες παραμέτρους my_car.print_info() # Κλήση της μεθόδου print_info για να εκτυπωθούν οι πληροφορίες του αυτοκινήτου
Ο παραπάνω κώδικας δημιουργεί δύο κλάσεις: την Vehicle
και την Car
. Η κλάση Vehicle
αναπαριστά ένα οχήμα με τις ιδιότητες make (κατασκευαστής), model (μοντέλο) και year (έτος). Η κλάση Car
είναι υποκλάση της Vehicle
και προσθέτει μια επιπλέον ιδιότητα doors (πόρτες).
[adinserter block=”4″]
Ο κώδικας δημιουργεί ένα αντικείμενο my_car
τύπου Car
, με τις παρεχόμενες τιμές για το make, model, year και doors. Στη συνέχεια, καλείται η μέθοδος print_info()
του αντικειμένου my_car
, η οποία εκτελεί την εκτύπωση των πληροφοριών του αυτοκινήτου, συμπεριλαμβανομένου του κατασκευαστή, του μοντέλου, του έτους και του αριθμού των πορτών.
Έτσι, ο κώδικας εκτυπώνει τις πληροφορίες του αυτοκινήτου “Toyota Corolla 2021” και τον αριθμό των πορτών που είναι 4.
Η κληρονομικότητα στην Python μπορεί να είναι πολλαπλών επιπέδων, προκειμένου μια υποκλάση να μπορεί να κληρονομήσει από μια άλλη υποκλάση, η οποία, από τη σειρά της, κληρονομεί από μια γονική κλάση. Αυτό παρέχει τη δυνατότητα δημιουργίας πιο εξειδικευμένων και οργανωμένων κλάσεων που αντικατοπτρίζουν τη δομή και τη λειτουργία των αντικειμένων που επιθυμείτε να αναπαραστήσετε.
Για παράδειγμα:
class ElectricCar(Car): def __init__(self, make, model, year, doors, battery_capacity): super().__init__(make, model, year, doors) self.battery_capacity = battery_capacity # Αρχικοποίηση της μεταβλητής battery_capacity με την τιμή που περνάμε ως όρισμα def print_info(self): super().print_info() # Κλήση της μεθόδου print_info της βασικής κλάσης print(f"Χωρητικότητα μπαταρίας: {self.battery_capacity} kWh") # Εκτύπωση πληροφοριών για την χωρητικότητα της μπαταρίας my_electric_car = ElectricCar("Tesla", "Model 3", 2021, 4, 75) # Δημιουργία αντικειμένου ElectricCar με τις κατάλληλες παραμέτρους my_electric_car.print_info() # Κλήση της μεθόδου print_info του αντικειμένου my_electric_car
Ο παραπάνω κώδικας δημιουργεί μια υποκλάση με όνομα ElectricCar
η οποία κληρονομεί τη βασική κλάση Car
. Η υποκλάση ElectricCar
έχει μια επιπλέον μεταβλητή battery_capacity
που αναπαριστά τη χωρητικότητα της μπαταρίας του ηλεκτρικού αυτοκινήτου.
Η μέθοδος __init__
της υποκλάσης ElectricCar
καλεί τη μέθοδο __init__
της βασικής κλάσης Car
για να αρχικοποιήσει τις κοινές μεταβλητές. Στη συνέχεια, η μέθοδος print_info
επεκτείνει τη μέθοδο print_info
της βασικής κλάσης Car
, εκτυπώνοντας επιπλέον πληροφορίες σχετικά με την χωρητικότητα της μπαταρίας του ηλεκτρικού αυτοκινήτου.
Τέλος, δημιουργείται ένα αντικείμενο my_electric_car
τύπου ElectricCar
και καλείται η μέθοδος print_info
για να εκτυπωθούν οι πληροφορίες του αυτοκινήτου, συμπεριλαμβανομένης της χωρητικότητας της μπαταρίας.
Η κληρονομικότητα είναι ένας από τους πολλούς μηχανισμούς που παρέχονται από τον αντικειμενοστραφή προγραμματισμό, ο οποίος αποσκοπεί στη βελτίωση της οργάνωσης, της επαναχρησιμοποίησης και της συντήρησης του κώδικα. Άλλα στοιχεία του αντικειμενοστραφούς προγραμματισμού περιλαμβάνουν την ενθυλάκωση, την πολυμορφισμός και τη σύνθεση, τα οποία όλα μαζί συνεισφέρουν στη δημιουργία ευέλικτου και αποτελεσματικού κώδικα.
Στην Python, μπορείτε να προσθέσετε ιδιότητες (properties) σε μια κλάση για να παρέχετε πρόσβαση ή/και να τροποποιήσετε τις ιδιωτικές μεταβλητές της κλάσης μέσω των μεθόδων getter και setter. Οι ιδιότητες επιτρέπουν την ελέγχουμενη πρόσβαση στις μεταβλητές και την εκτέλεση πρόσθετης λογικής κατά την πρόσβαση σε αυτές.
Οι getter μέθοδοι χρησιμοποιούνται για την ανάκτηση τιμών από ιδιότητες, ενώ οι setter μέθοδοι χρησιμοποιούνται για την τροποποίηση των τιμών των ιδιοτήτων. Η χρήση ιδιοτήτων παρέχει έναν ασφαλή τρόπο για την επικοινωνία με τις ιδιωτικές μεταβλητές της κλάσης, καθώς μπορούν να ελεγχθούν οι τιμές που επιστρέφονται ή αναθέτονται.
Οι ιδιότητες συμβάλλουν στην καλύτερη ενθυλάκωση του κώδικα, καθώς μπορείτε να αλλάξετε την εσωτερική υλοποίηση ενός getter ή setter μεθόδου χωρίς να επηρεαστεί ο κώδικας που χρησιμοποιεί τις ιδιότητες. Επίσης, η χρήση ιδιοτήτων καθιστά τον κώδικα πιο κατανοητό και συντηρήσιμο, καθώς οι ενέργειες που σχετίζονται με τις μεταβλητές ενσωματώνονται στις ιδιότητες.
Θα συνεχίσουμε με το προηγούμενο παράδειγμα που χρησιμοποιήσαμε, τροποποιώντας την κλάση Car
για να προσθέσουμε ιδιότητες:
class Car(Vehicle): def __init__(self, make, model, year, doors): super().__init__(make, model, year) # Κλήση του constructor της υπερκλάσης με τα ορίσματα make, model, year self._doors = doors # Αρχικοποίηση της μεταβλητής _doors με την τιμή του ορίσματος doors @property def doors(self): return self._doors # Επιστροφή της τιμής της μεταβλητής _doors @doors.setter def doors(self, value): if value > 0: # Έλεγχος αν ο αριθμός πορτών είναι θετικός self._doors = value # Αλλαγή της τιμής της μεταβλητής _doors σε value else: raise ValueError("Ο αριθμός των πορτών πρέπει να είναι θετικός") # Αν ο αριθμός πορτών δεν είναι θετικός, εκτόξευση ValueError def print_info(self): super().print_info() # Κλήση της μεθόδου print_info() της υπερκλάσης print(f"Πόρτες: {self.doors}") # Εκτύπωση του αριθμού των πορτών
Ο παραπάνω κώδικας ορίζει μια υποκλάση με όνομα “Car” που κληρονομεί από την κλάση “Vehicle”. Η υποκλάση “Car” έχει έναν constructor που δέχεται τις παραμέτρους “make”, “model”, “year” και “doors”.
Ο constructor καλεί τον constructor της υπερκλάσης “Vehicle” με τις παραμέτρους “make”, “model”, “year”. Στη συνέχεια, αρχικοποιεί τη μεταβλητή “_doors” με την τιμή του ορίσματος “doors”.
[adinserter block=”5″]
Η κλάση “Car” έχει μια ιδιότητα (property) με όνομα “doors”, η οποία επιστρέφει την τιμή της μεταβλητής “_doors”. Επίσης, έχει μια μέθοδο (setter) με όνομα “doors” που επιτρέπει την αλλαγή της τιμής της μεταβλητής “_doors”. Πριν την αλλαγή, γίνεται έλεγχος αν ο αριθμός πορτών είναι θετικός. Αν δεν είναι, εκτοξεύεται μια εξαίρεση ValueError.
Η κλάση “Car” έχει επίσης μια μέθοδο με όνομα “print_info”, η οποία καλεί την μέθοδο “print_info” της υπερκλάσης “Vehicle” και στη συνέχεια εκτυπώνει τον αριθμό των πορτών.
Συνολικά, ο κώδικας ορίζει μια κλάση “Car” που αντιπροσωπεύει ένα αυτοκίνητο, με τις ιδιότητες “make”, “model”, “year” και “doors”. Οι μέθοδοι της κλάσης επιτρέπουν την αλλαγή και εμφάνιση αυτών των ιδιοτήτων.
Χρησιμοποιώντας τις ιδιότητες, μπορείτε να εφαρμόσετε πρόσθετους ελέγχους και λειτουργικότητα κατά την τροποποίηση ή ανάκτηση της τιμής μιας ιδιωτικής μεταβλητής. Αυτό σας παρέχει ένα επίπεδο ασφάλειας και ευελιξίας στον κώδικά σας.
Μέσω της κληρονομικότητας και των ιδιοτήτων, ο αντικειμενοστραφής προγραμματισμός στην Python σας επιτρέπει να δημιουργήσετε κώδικα που είναι οργανωμένος με σωστό τρόπο, εύκολο να συντηρηθεί και ευέλικτος σε περίπτωση αλλαγών.
Μπορείτε να προσθέσετε μεθόδους σε μια κλάση Python με τον ίδιο τρόπο που προσθέτετε συναρτήσεις σε αυτήν. Απλά ορίστε μια νέα συνάρτηση εντός της κλάσης και χρησιμοποιήστε τη λέξη-κλειδί “self” για να αναφερθείτε στα πεδία και τις μεθόδους της ίδιας της κλάσης. Ο όρος “self” αντιπροσωπεύει το αντικείμενο της κλάσης και σας επιτρέπει να προσπελάσετε και να τροποποιήσετε τις μεταβλητές μέλη και τις μεθόδους της κλάσης.
Εδώ είναι ένα παράδειγμα με μια κλάση αυτοκινήτου (Car) που έχει μια μέθοδο για να επιστρέφει την τρέχουσα ταχύτητα του αυτοκινήτου:
class Car: def __init__(self, make, model, year): self.make = make # Αρχικοποίηση της μεταβλητής make με την τιμή που δίνεται ως όρισμα self.model = model # Αρχικοποίηση της μεταβλητής model με την τιμή που δίνεται ως όρισμα self.year = year # Αρχικοποίηση της μεταβλητής year με την τιμή που δίνεται ως όρισμα self.speed = 0 # Αρχικοποίηση της μεταβλητής speed με την τιμή 0 def get_speed(self): return self.speed # Επιστροφή της τρέχουσας ταχύτητας του αυτοκινήτου
Ο παραπάνω κώδικας ορίζει μια κλάση με όνομα “Car” που αναπαριστά ένα αυτοκίνητο. Η κλάση έχει τα ακόλουθα χαρακτηριστικά και μεθόδους:
- Το μέθοδο
__init__
: Είναι ο κατασκευαστής της κλάσης και χρησιμοποιείται για να αρχικοποιήσει τα χαρακτηριστικά του αντικειμένου. Παίρνει τρία ορίσματα – τον κατασκευαστή (make), το μοντέλο (model) και το έτος (year) – και τα αποθηκεύει στις αντίστοιχες μεταβλητές της κλάσης. Επίσης, αρχικοποιεί τη μεταβλητή speed με την τιμή 0. - Η μέθοδο
get_speed
: Είναι μια μέθοδος που επιστρέφει την τρέχουσα ταχύτητα του αυτοκινήτου (την τιμή της μεταβλητής speed).
Ο κώδικας δημιουργεί ένα αντικείμενο της κλάσης Car
με τις τιμές “make”, “model” και “year” που δίνονται ως ορίσματα στον κατασκευαστή. Στη συνέχεια, μπορείτε να χρησιμοποιήσετε τη μέθοδο get_speed
για να αποκτήσετε την τρέχουσα ταχύτητα του αυτοκινήτου.
Η μέθοδος get_speed()
επιστρέφει απλά την ταχύτητα του αυτοκινήτου, η οποία αρχικά είναι 0.
Για να καλέσετε αυτήν τη μέθοδο, δημιουργήστε ένα αντικείμενο από την κλάση Car και χρησιμοποιήστε τη μέθοδο get_speed()
. Για παράδειγμα:
my_car = Car("Toyota", "Corolla", 2021) print(my_car.get_speed()) # Output: 0
Ο κώδικας δημιουργεί ένα αντικείμενο της κλάσης Car
με τις τιμές “Toyota”, “Corolla” και 2021 για τον κατασκευαστή, το μοντέλο και το έτος αντίστοιχα. Στη συνέχεια, χρησιμοποιείται η μέθοδος get_speed()
στο αντικείμενο my_car
για να επιστραφεί η τρέχουσα ταχύτητα του αυτοκινήτου.
Δεδομένου ότι η μεταβλητή speed
αρχικοποιείται με την τιμή 0 στον κατασκευαστή, η εκτέλεση της εντολής print(my_car.get_speed())
θα εμφανίσει το αποτέλεσμα 0. Αυτό σημαίνει ότι η ταχύτητα του αυτοκινήτου είναι μηδέν.