Hva er arv i Golang
Arv i Golang
Arv i Golang er en måte å lage en barneklasse som er en modifisert versjon av en eksisterende eller foreldreklasse. Den nyopprettede klassen tar egenskapene til den eksisterende foreldreklassen. Underklassen eller barneklassen kan også endre eller legge til noen nye egenskaper i foreldreklassen.
Syntaks for å arve i Golang
For å arve fra en foreldreklasse i Golang, bruker vi struktur nøkkelord og legg inn foreldreklassen i barneklassen. Her er et eksempel:
Skriv overordnede struktur
Eiendom1 streng
Property2 Int
skriv barnestruktur
Foreldre
Property3 Float32
Ovennevnte syntaks har en barnestruktur som innebærer overordnet struktur, noe som betyr at den arver alle dens egenskaper og metoder. Barnstrukturen har også en ny eiendom som heter Property3.
Hvorfor Golang ikke støtter arv
I tradisjonell objektorientert programmering er arv et grunnleggende konsept som innebærer å arve egenskaper fra en foreldreklasse til en barneklasse. Imidlertid siden Golang støtter ikke klasser, Arv implementeres ved hjelp av strukturinnleggelse.
I Golang kan ikke strukturer utvides direkte, så vi bruker sammensetning for å konstruere nye objekter ved hjelp av struktur. Derfor er det nøyaktig å si at Golang ikke gir innfødt støtte til arv, men støtter heller sammensetning som et alternativ.
Hvordan oppnå arv i Golang ved bruk av strukturinnlegg
I Golang oppnås arv gjennom en mekanisme som heter strukturinnlegging. Dette gjør at vi kan legge inn en struktur i en annen, noe som resulterer i en forhold som en foreldre- og barneklasse. Barnestrukturen kan da få tilgang til feltene og metodene til overordnet struktur, som om de var en del av sin egen definisjon.
Her er et eksempel på hvordan du oppnår arv i Golang ved bruk av strukturinnstilling:
Skriv person struktur
Navnstreng
alder int
type ansattstruktur
Person // innebygging av personstrukturen i ansattes struktur
empid int
Lønn Float64
I koden ovenfor er personstrukturen innebygd av ansattstruktur ved å bruke personfeltnavn uten en type, noe som innebærer at den innebærer selve strukturen. Dette skaper et foreldre-barn-forhold mellom de to strukturer, der den ansattes struktur er barnet, og personstrukturen er overordnede.
Nå kan du få tilgang til alle felt eller metoder som er definert i personstrukturen fra den ansattes struktur. For eksempel kan vi få tilgang til navnfeltet til personstrukturen fra ansattstrukturen ved å bruke DOT -notasjonen:
e: = ansatt person navn: "kash", alder: 24, 20, 1000
fmt.Println (e.Navn)
Tilsvarende kan vi definere metoder i personstrukturen som kan nås fra ansattes struktur:
func (p *person) introdusere ()
fmt.Printf ("Hei, jeg heter %s og jeg er %d år gammel.\ n ", p.Navn, s.alder)
func main ()
e: = ansatt person navn: "kash", alder: 24, 20, 1000
e.introdusere()
Eksempel 1: Golang -program for å vise arv i strukturinnleggelse
pakkehoved
Importer "FMT"
Skriv person struktur
Navnstreng
alder int
type ansattstruktur
Person // innebygging av personstrukturen i ansattes struktur
empid int
Lønn Float64
func (p *person) introdusere ()
fmt.Printf ("Hei, jeg heter %s og jeg er %d år gammel.\ n ", p.Navn, s.alder)
func (e *ansatt) introdusere ()
fmt.Printf ("Hei, jeg heter %s og jeg er %d år gammel. Min ansattes ID er %d og lønnen min er $ %.2f.\ n ", e.Navn, e.alder, e.Empid, e.lønn)
func main ()
e: = ansatt person navn: "kash", alder: 24, 20, 1000
fmt.Println (e.Navn)
e.introdusere()
Her har vi definert en personstruktur og en ansattstruktur som innebærer personstrukturen. Vi definerer da introdusere() Metode på personstrukturen, som vi kan få tilgang til fra ansattes struktur. I Main () opprettet vi en ny ansattes forekomst og demonstrerte hvordan vi kan få tilgang til feltene og metodene til den innebygde personstrukturen.
Eksempel 2: Golang -program for å vise flere arv til en struktur
pakkehoved
Importer "FMT"
Skriv person struktur
Navnstreng
alder int
Skriv studentstruktur
Person // innebygging av personstrukturen inne i studentstrukturen
Rollno int
type lærerstruktur
Person // innebygging av personstrukturen i lærerstrukturen
empid int
func (p *person) introdusere ()
fmt.Printf ("Hei, jeg heter %s og jeg er %d år gammel.\ n ", p.Navn, s.alder)
func (S *student) studie ()
fmt.Printf ("%s studerer.\ n ", s.Navn)
func (t *lærer) lære ()
fmt.Printf ("%s underviser.\ n ", t.Navn)
func main ()
s: = student person navn: "kash", alder: 24, 1001
t: = lærer person navn: "Sam", alder: 30, 2001
s.introdusere()
s.studere()
t.introdusere()
t.lære bort()
I eksemplet over definerer vi en personstruktur og to andre strukturer, student og lærer, som legger inn personstrukturen. Vi definerer også introdusering (), studier () og undervisning () metoder for henholdsvis person, student og lærerstrukturer.
I Main () opprettet vi nye forekomster av både student og lærer og demonstrerte hvordan vi kan få tilgang til feltene og metodene til den innebygde personstrukturen, så vel som metodene som er spesifikke for hver struktur.
Konklusjon
Arv er et essensielt konsept innen objektorientert programmering, og Golang gir støtte for enkelt arv gjennom strukturinnleggelse. For flere arv i Golang brukes komposisjonsmetoden. Denne artikkelen dekker hvordan vi kan oppnå arven ved hjelp av sammensetningsmetode i Golang. For ytterligere detaljer om arv i Golang, les artikkelen.