Cosa è eredità nel golang
Ereditarietà in Golang
L'eredità in Golang è un modo per creare una classe figlio che è una versione modificata di una classe esistente o genitore. La classe appena creata prende le proprietà della classe genitore esistente. La classe sottoclasse o figlio può anche modificare o aggiungere alcune nuove proprietà nella classe principale.
Sintassi per ereditare in Golang
Per ereditare da una classe genitore a Golang, usiamo il strumento parola chiave e incorporare la classe genitore all'interno della classe figlio. Ecco un esempio:
Digita la struttura genitore
Proprietà1 String
Proprietà2 int
Tipo bambino struct
Genitore
Proprietà3 float32
La sintassi sopra ha una struttura figlio che incorpora la struttura genitore, il che significa che eredita tutte le sue proprietà e i suoi metodi. The Child Struct ha anche una nuova proprietà chiamata Property3.
Perché Golang non supporta l'eredità
Nella programmazione tradizionale orientata agli oggetti, l'eredità è un concetto fondamentale che prevede le proprietà ereditarie da una classe genitore a una classe figlio. Tuttavia, da quando Golang non supporta le lezioni, L'eredità è implementata utilizzando l'incorporamento della struttura.
In Golang, le strutture non possono essere estese direttamente, quindi utilizziamo la composizione per costruire nuovi oggetti usando il strumento. Pertanto, è accurato affermare che Golang non fornisce supporto nativo per l'eredità, ma supporta piuttosto la composizione come alternativa.
Come ottenere l'eredità nel golang usando l'incorporamento structing
In Golang, l'eredità si ottiene attraverso un meccanismo chiamato Incorporamento della struttura. Questo ci consente di incorporare una struttura all'interno di un'altra, che si traduce in una relazione come un genitore e una classe figlio. La struttura figlio può quindi accedere ai campi e ai metodi della struttura genitore, come se facessero parte della propria definizione.
Ecco un esempio di come ottenere l'eredità in Golang usando l'incorporamento di strutture:
tipo persona struct
Nome String
età int
Tipo Struttura dei dipendenti
Persona // incorporare la struttura della persona all'interno della struttura dei dipendenti
empid int
Stipendio Float64
Nel codice sopra, la struttura della persona è incorporata dalla struttura dei dipendenti usando il nome del campo della persona senza un tipo, il che implica che sta incorporando la struttura stessa. Questo crea una relazione genitore-figlio tra le due strutture, in cui la struttura dei dipendenti è il bambino e la struttura è il genitore.
Ora, è possibile accedere a tutti i campi o metodi definiti nella struttura della persona dalla struttura dei dipendenti. Ad esempio, possiamo accedere al campo Nome della persona struttura dalla struttura dei dipendenti usando la notazione DOT:
e: = dipendente persona nome: "kash", età: 24, 20, 1000
fmt.Println (e.nome)
Allo stesso modo, possiamo definire i metodi nella struttura di persona a cui è possibile accedere dalla struttura dei dipendenti:
func (p *persona) presenta ()
fmt.Printf ("Ciao, mi chiamo %s e ho %di anni.\ n ", p.nome, p.età)
func main ()
e: = dipendente persona nome: "kash", età: 24, 20, 1000
e.introdurre()
Esempio 1: programma Golang per mostrare l'eredità nell'incorporamento delle strutture
Pacchetto principale
Importa "FMT"
tipo persona struct
Nome String
età int
Tipo Struttura dei dipendenti
Persona // incorporare la struttura della persona all'interno della struttura dei dipendenti
empid int
Stipendio Float64
func (p *persona) presenta ()
fmt.Printf ("Ciao, mi chiamo %s e ho %di anni.\ n ", p.nome, p.età)
func (e *dipendente) presenta ()
fmt.Printf ("Ciao, mi chiamo %s e ho %di anni. Il mio ID dipendente è %d e il mio stipendio è $ %.2f.\ n ", e.nome, e.età, e.empid, e.stipendio)
func main ()
e: = dipendente persona nome: "kash", età: 24, 20, 1000
fmt.Println (e.nome)
e.introdurre()
Qui, abbiamo definito una struttura di persona e una struttura per i dipendenti che incorpora la struttura della persona. Definiamo quindi il introdurre() Metodo sulla struttura della persona, a cui possiamo accedere dalla struttura dei dipendenti. In Main (), abbiamo creato una nuova istanza dei dipendenti e dimostrato come possiamo accedere ai campi e ai metodi della persona incorporata.
Esempio 2: programma Golang per mostrare molte eredità a una struttura
Pacchetto principale
Importa "FMT"
tipo persona struct
Nome String
età int
Digita Student struct
Persona // incorporare la struttura della persona all'interno dello studente struct
rollno int
tipo insegnante struct
Persona // incorporare la persona struttura all'interno della struttura dell'insegnante
empid int
func (p *persona) presenta ()
fmt.Printf ("Ciao, mi chiamo %s e ho %di anni.\ n ", p.nome, p.età)
func (s *studente) studio ()
fmt.Printf ("%s sta studiando.\ n ", s.nome)
func (t *insegnante) insegnante ()
fmt.Printf ("%s sta insegnando.\ n ", t.nome)
func main ()
S: = Student Person Nome: "Kash", età: 24, 1001
T: = insegnante persona nome: "Sam", età: 30, 2001
S.introdurre()
S.studio()
T.introdurre()
T.insegnare()
Nell'esempio sopra, definiamo una struttura di persona e altre due strutture, studente e insegnante, che incorporano la persona struttura. Definiamo anche i metodi introduttivi (), studio () e insegniamo () sulla persona, studente e strutture per insegnanti, rispettivamente.
In Main (), abbiamo creato nuovi casi di studente e insegnante e abbiamo dimostrato come possiamo accedere ai campi e ai metodi della struttura della persona incorporata, nonché ai metodi specifici per ogni struttura.
Conclusione
L'eredità è un concetto essenziale nella programmazione orientata agli oggetti e Golang fornisce supporto per una singola eredità attraverso l'incorporamento delle strutture. Per l'eredità multipla in Golang, viene utilizzato il metodo di composizione. Questo articolo copre il modo in cui possiamo ottenere l'eredità usando il metodo di composizione in Golang. Per ulteriori dettagli sull'eredità di Golang, leggi l'articolo.