Πώς να εφαρμόσετε αντικειμενοστρεφείς έννοιες προγραμματισμού στο Go

Ο Αντικειμενοστρεφής Προγραμματισμός (OOP) είναι ένα παράδειγμα προγραμματισμού που βασίζεται σε αντικείμενα ως κεντρική έννοια. Στο OOP, ο κώδικας μορφοποιείται με βάση τη λειτουργικότητα, επιτρέποντας τη συντήρηση κώδικα, την αφαίρεση, την επαναχρησιμοποίηση, την αποτελεσματικότητα και πολλές λειτουργίες στο αντικείμενο.

Το αντικείμενο έχει ιδιότητες (μεταβλητές) που ορίζουν τα χαρακτηριστικά, τις ιδιότητες και τις μεθόδους (συναρτήσεις) του που ορίζουν τις ενέργειες (διαδικασίες) και τις συμπεριφορές του αντικειμένου.

Ο αντικειμενοστραφής προγραμματισμός στο Go είναι διαφορετικός από άλλες γλώσσες. Οι αντικειμενοστρεφείς έννοιες υλοποιούνται στο Go χρησιμοποιώντας δομές, διεπαφές και προσαρμοσμένους τύπους.

Προσαρμογή τύπων στο Go

Οι προσαρμοσμένοι τύποι διευκολύνουν την ομαδοποίηση και τον εντοπισμό παρόμοιου κώδικα για επαναχρησιμοποίηση.

Ο κωδικός για τη δήλωση προσαρμοσμένων τύπων είναι:

τύπος typeName dataType 

Κατά τη δημιουργία ενός προσαρμοσμένου τύπου και την εκχώρηση μιας μεταβλητής, μπορείτε να ελέγξετε τον τύπο χρησιμοποιώντας

κατοπτρίζω. Τύπου() που δέχεται μια μεταβλητή και επιστρέφει τον τύπο της μεταβλητής.

εισαγωγή( "fmt"
 "κατοπτρίζω")
τύπος δύο ενθ// δημιουργεί τον τύπο "δύο"
var νούμερο δύο // μεταβλητή τύπου "δύο"
fmt. Println (αντανακλ. TypeOf (αριθμός))

​​​

ο αριθμός η μεταβλητή είναι ένας τύπος δύο που είναι ακέραιος αριθμός. Μπορείτε να προχωρήσετε περαιτέρω για να δημιουργήσετε περισσότερο από τον προσαρμοσμένο τύπο.

Δημιουργία δομών στο Go

Οι δομές (δομές) είναι τα προσχέδια για αντικειμενοστραφή προγραμματισμό στο Go. Οι δομές είναι συλλογές πεδίων που ορίζονται από τον χρήστη.

Μια δομή μπορεί να περιέχει μια ποικιλία τύπων δεδομένων, συμπεριλαμβανομένων τύπων ενώσεων και μεθόδων.

Μπορείτε να δημιουργήσετε μια δομή χρησιμοποιώντας αυτήν τη σύνταξη:

τύπος Όνομα δομής struct {
// κάποιο κώδικα
}

Συμβατικά, τα ονόματα των δομών συνήθως γράφονται με κεφαλαία και κεφαλαία για αναγνωσιμότητα.

Ο τύπος δομής περιλαμβάνει ονόματα πεδίων και τύπους δεδομένων. Οι δομές μπορούν να λάβουν οποιονδήποτε τύπο δεδομένων Go, συμπεριλαμβανομένων των προσαρμοσμένων τύπων.

τύπος Χρήστης struct {
 πεδίο 1 σειρά
 πεδίο 2 ενθ
 χάρτης πεδίου χάρτης[σειρά]ενθ
}

Μπορείτε να δημιουργήσετε έναν τύπο δομής εκχωρώντας το struct ως μεταβλητή.

παράδειγμα := Χρήστης{
// κάποιο κώδικα
}

Το στιγμιότυπο της δομής μπορεί να συμπληρωθεί με πεδία κατά την προετοιμασία όπως ορίζονται κατά την προετοιμασία ή να οριστεί σε null.

παράδειγμα := Χρήστης{
 πεδίο 1: "α σειρά πεδίο",
 πεδίο 2: 10,
 Χάρτης πεδίου: χάρτης[σειρά]ενθ{},
 }

Πρόσβαση στα δομικά στοιχεία

Μπορείτε να αποκτήσετε πρόσβαση στα πεδία μιας παρουσίας δομής χρησιμοποιώντας έναν συμβολισμό κουκκίδας στο πεδίο.

fmt. Println("Πρόσβαση σε πεδίο τιμής", instance.field2)

Αυτό βγάζει το πεδίο 2 του στιγμιότυπου της δομής.

Ανάθεση μεθόδων σε δομές

Οι συναρτήσεις (μέθοδοι) εκχωρούνται σε τύπους δομών, καθορίζοντας ένα όνομα δέκτη και το όνομα δομής πριν από το όνομα της συνάρτησης, όπως φαίνεται στην παρακάτω σύνταξη.

func(Όνομα δομής δέκτη)Όνομα λειτουργίας() {
// κάποιο κώδικα
}

Η μέθοδος Όνομα λειτουργίας μπορεί να χρησιμοποιηθεί μόνο στον καθορισμένο τύπο δομής.

Εφαρμογή της κληρονομιάς στο Go

Η κληρονομιά είναι την ικανότητα των αντικειμένων και των τύπων να έχουν πρόσβαση και να χρησιμοποιούν μεθόδους και ιδιότητες άλλων αντικειμένων. Το Go δεν έχει Κληρονομικότητα ως δυνατότητα, αλλά μπορείτε να χρησιμοποιήσετε συνθέσεις. Στο Go, η σύνθεση συνεπάγεται αναφορά σε μια υπερκατασκευή (η δομή που θα κληρονομηθεί) σε μια υποδομή παρέχοντας το όνομα της υπερκατασκευής στην υποδομή.

Χρησιμοποιώντας το παραπάνω παράδειγμα δομής:

τύπος Χρήστης struct {
 πεδίο 1 σειρά
 πεδίο 2 ενθ
 χάρτης πεδίου χάρτης[σειρά]ενθ
}
τύπος Χρήστης 2 struct {
 Χρήστης
}

Περνώντας το Χρήστης όνομα δομής στο Χρήστης 2 struct, το Χρήστης 2 Η struct μπορεί να έχει πρόσβαση σε όλες τις μεθόδους και τα χαρακτηριστικά του Χρήστης struct on instantiation εκτός από τις τεχνικές αφαίρεσης που χρησιμοποιούνται.

γιος := Χρήστης2{
 Χρήστης{
 πεδίο 1: "μωρό",
 πεδίο 2: 0,
 Χάρτης πεδίου: μηδέν,
 },
 }
fmt. Println (son.field2)

ο υιός η παραπάνω μεταβλητή είναι μια παρουσίαση του Χρήστης 2 struct. Όπως φαίνεται στο παράδειγμα, το υιός μεταβλητή μπορεί να έχει πρόσβαση και να δημιουργήσει τιμές του τύπου Χρήστη και να τις χρησιμοποιήσει.

Ενθυλάκωση πεδίων τύπου στο Go

Η ενθυλάκωση, γνωστή και ως «απόκρυψη πληροφοριών», είναι α τεχνική ομαδοποίησης των μεθόδων και των χαρακτηριστικών ενός αντικειμένου σε μονάδες για να περιορίσετε τη χρήση και την πρόσβαση εκτός από το καθορισμένο (ενεργοποίηση των δικαιωμάτων ανάγνωσης/εγγραφής).

Η ενθυλάκωση υλοποιείται στο Go χρησιμοποιώντας εξαγόμενα και μη εξαγόμενα αναγνωριστικά σε πακέτα.

Εξαγόμενα αναγνωριστικά (Ανάγνωση και εγγραφή)

Τα εξαγόμενα αναγνωριστικά εξάγονται από τα καθορισμένα πακέτα τους και την πρόσβαση σε άλλα προγράμματα. Η χρήση κεφαλαίων σε ένα αναγνωριστικό πεδίου εξάγει το πεδίο fo.

τύπος Χρήστης struct {
 Πεδίο 1 σειρά
 Πεδίο 2 ενθ
 Χάρτης Πεδίου χάρτης[σειρά]ενθ
}
τύπος Χρήστης 2 struct {
 Χρήστης
}

Μη εξαγόμενα αναγνωριστικά (μόνο για ανάγνωση)

Τα μη εξαγόμενα αναγνωριστικά δεν εξάγονται από το καθορισμένο πακέτο και είναι συμβατικά πεζά.

τύπος Χρήστης struct {
 πεδίο 1 σειρά
 πεδίο 2 ενθ
 χάρτης πεδίου χάρτης[σειρά]ενθ
}
τύπος Χρήστης 2 struct {
 Χρήστης
}

Η έννοια των εξαγόμενων και μη εξαγόμενων αναγνωριστικών ισχύει επίσης για τις μεθόδους ενός αντικειμένου.

Πολυμορφισμός στο Go

Ο πολυμορφισμός είναι μια τεχνική που χρησιμοποιείται για να δώσει διαφορετικές μορφές σε ένα αντικείμενο για ευελιξία.

Το Go υλοποιεί τον πολυμορφισμό χρησιμοποιώντας διεπαφές. Οι διεπαφές είναι προσαρμοσμένοι τύποι που χρησιμοποιούνται για τον ορισμό υπογραφών μεθόδων.

Δήλωση διεπαφών

Η δήλωση διεπαφών είναι παρόμοια με τη δήλωση δομών. Ωστόσο, οι διεπαφές δηλώνονται χρησιμοποιώντας το διεπαφή λέξη-κλειδί.

τύπος Όνομα διεπαφής διεπαφή{
//μερικές μέθοδοι
}

Οι δηλώσεις διεπαφής περιέχουν μεθόδους που πρόκειται να εφαρμοστούν από τύπους δομών.

Υλοποίηση διεπαφών σε δομές

Οι τύποι που υλοποιούν τη διεπαφή πρέπει να δηλωθούν και μετά οι μέθοδοι του τύπου υλοποιούν τη διεπαφή.

// Η διεπαφή
τύπος Χρώμα διεπαφή{
 Χρώμα() σειρά
}
// Δήλωση των δομών
τύπος Πράσινος struct {
// μερικοί struct συγκεκριμένο κώδικα
}
τύπος Μπλε struct {
// κάποιο συγκεκριμένο κωδικό
}

Το παραπάνω απόσπασμα κώδικα έχει ένα Χρώμα διεπαφή που δηλώνεται με α Χρώμα μέθοδος που θα εφαρμοστεί από την Πράσινος και Μπλε τύπους κατασκευών.

Οι διεπαφές υλοποιούνται με την ανάθεση μεθόδων για την κατασκευή τύπων και στη συνέχεια ονομάζοντας τη μέθοδο με τη μέθοδο διεπαφής που πρόκειται να εφαρμοστεί.

func(g Πράσινο)Χρώμα()σειρά {
ΕΠΙΣΤΡΟΦΗ "ζωγραφισμένο πράσινο"
}
func(β Μπλε)Χρώμα()σειρά {
ΕΠΙΣΤΡΟΦΗ "ζωγραφισμένο μπλε"
}

Η μέθοδος Paint υλοποιείται από τους τύπους Green και Blue, οι οποίοι μπορούν πλέον να καλούν και να χρησιμοποιούν το Χρώμα μέθοδος.

βούρτσα := Πράσινο{}
fmt. Println (βούρτσα. Χρώμα())

Το "Painted green" εκτυπώνεται στην κονσόλα επιβεβαιώνοντας ότι η διεπαφή εφαρμόστηκε με επιτυχία.

Αφαίρεση πεδίων στο Go

Η αφαίρεση είναι η διαδικασία απόκρυψης ασήμαντων μεθόδων και χαρακτηριστικών ενός τύπου, διευκολύνοντας την ασφάλεια τμημάτων του προγράμματος από μη φυσιολογική, ακούσια χρήση.

Το Go δεν έχει την αφαίρεση να εφαρμόζεται αμέσως. Ωστόσο, μπορείτε να εργαστείτε με την εφαρμογή αφαίρεσης χρησιμοποιώντας διεπαφές.

// οι άνθρωποι μπορούν να τρέξουν
τύπος Ο άνθρωπος διεπαφή {
 τρέξιμο() σειρά
}
// Το αγόρι είναι ένας άνθρωπος με πόδια
τύπος Αγόρι struct {
 Πόδια σειρά
}
// μια μέθοδος στο αγόρι υλοποιεί τη μέθοδο εκτέλεσης της διεπαφής Human
func(h Αγόρι)τρέξιμο()σειρά {
ΕΠΙΣΤΡΟΦΗ η. Πόδια
}

Ο παραπάνω κώδικας δημιουργεί ένα Ο άνθρωπος διεπαφή με α τρέξιμο διεπαφή που επιστρέφει μια συμβολοσειρά. ο Αγόρι τύπος υλοποιεί το τρέξιμο μέθοδος του Ο άνθρωπος διασύνδεση και επιστρέφει μια συμβολοσειρά στο instantiation.

Ένας από τους τρόπους υλοποίησης της αφαίρεσης είναι κάνοντας μια δομή να κληρονομήσει τη διεπαφή της οποίας οι μέθοδοι πρόκειται να αφαιρεθούν. Υπάρχουν πολλές άλλες προσεγγίσεις, αλλά αυτή είναι η πιο εύκολη.

τύπος Πρόσωπο struct {
 Ονομα σειρά
 Ηλικία ενθ
 Κατάσταση Άνθρωπος 
}
funcκύριος() {
 person1 := &Boy{Πόδια: "δύο πόδια"}
 άτομο 2 := &Άτομο{ // περίπτωση ατόμου
 Όνομα: "αμίνα",
 Ηλικία: 19,
 Κατάσταση: άτομο1,
 }
 fmt. Println (άτομο. Status.run()) 
}

ο Πρόσωπο struct κληρονομεί το Ο άνθρωπος διεπαφή και μπορεί να έχει πρόσβαση σε όλες τις μεθόδους του χρησιμοποιώντας τη μεταβλητή Κατάσταση κληρονομώντας τη διεπαφή.

Κατά την εγκατάσταση με αναφορά (χρησιμοποιώντας δείκτη), το παράδειγμα του Πρόσωπο struct Πρόσωπο 2 αναφέρεται σε ένα παράδειγμα του Αγόρι struct Πρόσωπο 1 και έχει πρόσβαση στις μεθόδους.

Με αυτόν τον τρόπο, μπορείτε να καθορίσετε συγκεκριμένες μεθόδους που θα εφαρμοστούν ανά τύπο.

OOP vs Λειτουργικός Προγραμματισμός

Ο αντικειμενοστραφής προγραμματισμός είναι ένα σημαντικό παράδειγμα, καθώς σας δίνει περισσότερο έλεγχο του προγράμματός σας και ενθαρρύνει την επαναχρησιμοποίηση κώδικα με τρόπους που δεν το κάνει ο λειτουργικός προγραμματισμός.

Αυτό δεν κάνει τον λειτουργικό προγραμματισμό κακή επιλογή, καθώς ο λειτουργικός προγραμματισμός μπορεί να είναι χρήσιμος και καλύτερος για ορισμένες περιπτώσεις χρήσης.

Τι είναι ο Αντικειμενοστραφής Προγραμματισμός; Τα βασικά που εξηγούνται με τους όρους Layman

Διαβάστε Επόμενο

Σχετικά με τον Συγγραφέα