Hvordan implementere objektorienterte programmeringskonsepter i Go

Objektorientert programmering (OOP) er et programmeringsparadigme basert på objekter som det sentrale konseptet. I OOP formateres kode basert på funksjonalitet, noe som muliggjør kodevedlikehold, abstraksjon, gjenbrukbarhet, effektivitet og en rekke funksjoner på objektet.

Objektet har attributter (variabler) som definerer dets egenskaper, egenskaper og metoder (funksjoner) som definerer handlingene (prosedyrene) og atferden til objektet.

Objektorientert programmering i Go er forskjellig fra andre språk. Objektorienterte konsepter er implementert i Go ved å bruke strukturer, grensesnitt og tilpassede typer.

Tilpasse typer i Go

Egendefinerte typer gjør det enkelt å gruppere og identifisere lignende kode for gjenbruk.

Koden for å deklarere egendefinerte typer er:

type typeNavn dataType 

Når du oppretter en egendefinert type og tilordner en variabel, kan du sjekke typen ved å bruke reflektere. TypeOf() som tar inn en variabel og returnerer typen til variabelen.

import("fmt"
 "reflektere")
type to int

instagram viewer

// lager typen "to"
var nummer to // variabel av typen "to"
fmt. Println (reflekt. TypeOf (antall))

​​​

De Nummer variabel er en type to som er et heltall. Du kan gå lenger for å lage mer av den egendefinerte typen.

Opprette strukturer i Go

Strukturer (strukturer) er tegningene for objektorientert programmering i Go. Strukturer er brukerdefinerte samlinger av felt.

En struktur kan inneholde en rekke datatyper, inkludert sammensatte typer og metoder.

Du kan lage en struktur ved å bruke denne syntaksen:

type Strukturnavn struktur {
// litt kode
}

Konvensjonelt er strukturnavn vanligvis med store bokstaver og kamelhus for lesbarhet.

Strukturtypen tar inn feltnavn og datatyper. Strukturer kan ta inn alle Go-datatyper, inkludert egendefinerte typer.

type Bruker struktur {
 felt1 streng
 felt2 int
 feltkart kart[streng]int
}

Du kan instansiere en strukturtype ved å tilordne strukturen som en variabel.

instans := Bruker{
// litt kode
}

Strukturforekomsten kan fylles ut med felt ved instansiering som definert ved initialisering eller satt til null.

instans := Bruker{
 felt1: "a streng felt",
 felt 2: 10,
 feltkart: kart[streng]int{},
 }

Tilgang til strukturelementer

Du kan få tilgang til feltene til en struct-forekomst ved å bruke en punktnotasjon til feltet.

fmt. Println("Tilgang til et verdifelt", instance.field2)

Dette gir ut felt2 av struct-forekomsten instansiert.

Tilordne metoder til strukturer

Funksjoner (metoder) tilordnes strukturtyper ved å spesifisere et mottakernavn og strukturnavnet før funksjonsnavnet som vist i syntaksen nedenfor.

func(mottaker StructName)funksjonsnavn() {
// litt kode
}

Metoden funksjonsnavn kan bare brukes på den angitte strukturtypen.

Implementering av arv i Go

Arv er evnen til objekter og typer til å få tilgang til og bruke metoder og attributter til andre objekter. Go har ikke arv som funksjon, men du kan bruke komposisjoner. I Go innebærer komposisjon å referere til en overbygning (strukturen som skal arves) i en understruktur ved å gi overbygningens navn til underbygningen.

Ved å bruke struktureksemplet ovenfor:

type Bruker struktur {
 felt1 streng
 felt2 int
 feltkart kart[streng]int
}
type Bruker 2 struktur {
 Bruker
}

Ved å bestå Bruker strukturer navnet inn i Bruker 2 struct, den Bruker 2 struct kan få tilgang til alle metodene og attributtene til Bruker struktur på instansiering bortsett fra at abstraksjonsteknikker brukes.

sønn := Bruker2{
 Bruker{
 felt1: "baby",
 felt 2: 0,
 feltkart: null,
 },
 }
fmt. Println (son.field2)

De sønn variabelen ovenfor er en instansiering av Bruker 2 struktur. Som det fremgår av eksempelet sønn variabel kan få tilgang til og instansiere verdier av brukertypen og bruke dem.

Innkapsling av typefelt i Go

Innkapsling, også kjent som "informasjonsskjul", er en teknikk for å samle metodene og attributtene til et objekt i enheter for å begrense bruken og tilgangen unntatt spesifisert (aktivering av lese-/skriverettigheter).

Innkapsling er implementert i Go ved å bruke eksporterte og ikke-eksporterte identifikatorer i pakker.

Eksporterte identifikatorer (lese og skrive)

Eksporterte identifikatorer eksporteres fra deres definerte pakker og tilgang til andre programmer. Ved å bruke store bokstaver i en feltidentifikator eksporteres feltet fo.

type Bruker struktur {
 Felt 1 streng
 Felt 2 int
 Feltkart kart[streng]int
}
type Bruker 2 struktur {
 Bruker
}

Ikke-eksporterte identifikatorer (skrivebeskyttet)

Ikke-eksporterte identifikatorer eksporteres ikke fra den definerte pakken og er konvensjonelt små.

type Bruker struktur {
 felt1 streng
 felt2 int
 feltkart kart[streng]int
}
type Bruker 2 struktur {
 Bruker
}

Konseptet med eksporterte og ikke-eksporterte identifikatorer gjelder også metodene til et objekt.

Polymorfisme i Go

Polymorfisme er en teknikk som brukes til å gi forskjellige former til et objekt for fleksibilitet.

Go implementerer polymorfisme ved å bruke grensesnitt. Grensesnitt er tilpassede typer som brukes til å definere metodesignaturer.

Erklære grensesnitt

Deklarering av grensesnitt ligner på deklarering av strukturer. Imidlertid er grensesnitt erklært ved å bruke grensesnitt søkeord.

type Grensesnittnavn grensesnitt{
//noen metoder
}

Grensesnittdeklarasjoner inneholder metoder som skal implementeres av struct-typer.

Implementering av grensesnitt i strukturer

Typene som implementerer grensesnittet må deklareres, hvoretter metodene for typen implementerer grensesnittet.

// Grensesnittet
type Farge grensesnitt{
 Maling() streng
}
// Erklærer strukturene
type Grønn struktur {
// noen strukturspesifikk kode
}
type Blå struktur {
// noen spesifikk kode
}

Kodebiten ovenfor har en Farge grensesnitt erklært med en Maling metode som skal implementeres av Grønn og Blå strukturtyper.

Grensesnitt implementeres ved å tilordne metoder til strukturtyper og deretter navngi metoden etter grensesnittmetoden som skal implementeres.

func(g Grønn)Maling()streng {
komme tilbake "malt grønn"
}
func(b blå)Maling()streng {
komme tilbake "malt blå"
}

Paint-metoden er implementert av grønne og blå typer som nå kan ringe og bruke Maling metode.

børste := Grønn{}
fmt. Println (pensel. Maling())

"Painted green" er trykt på konsollen som bekrefter at grensesnittet ble implementert.

Abstrahere felt i farten

Abstraksjon er prosessen med å skjule uviktige metoder og attributter av en type, noe som gjør det enklere å sikre deler av programmet fra unormal, utilsiktet bruk.

Go har ikke abstraksjon implementert umiddelbart; Du kan imidlertid jobbe oss gjennom å implementere abstraksjon ved hjelp av grensesnitt.

// mennesker kan løpe
type Menneskelig grensesnitt {
 løpe() streng
}
// Gutten er et menneske med bein
type Gutt struktur {
 Ben streng
}
// en metode på gutt implementerer kjøremetoden til Human-grensesnittet
func(h Gutt)løpe()streng {
komme tilbake h. Ben
}

Koden ovenfor oppretter en Menneskelig grensesnitt med en løpe grensesnitt som returnerer en streng. De Gutt type implementerer løpe metoden for Menneskelig grensesnitt og returnerer en streng ved instansiering.

En av måtene å implementere abstraksjon på er å få en struktur til å arve grensesnittet hvis metoder skal abstraheres. Det er mange andre tilnærminger, men dette er den enkleste.

type Person struktur {
 Navn streng
 Alder int
 Status Menneske 
}
funchoved-() {
 person1 := &Gutt{Bein: "to bein"}
 person2 := &Person{ // forekomst av en person
 Navn: "amina",
 Alder: 19,
 Status: person1,
 }
 fmt. Println (person. Status.run()) 
}

De Person struct arver Menneskelig grensesnitt og kan få tilgang til alle metodene ved hjelp av variabelen Status arver grensesnittet.

Ved instansiering ved referanse (ved hjelp av en peker), forekomsten av Person struktur Person 2 refererer til en forekomst av Gutt struktur Person1 og får tilgang til metodene.

På denne måten kan du spesifisere spesifikke metoder som skal implementeres av typen.

OOP vs funksjonell programmering

Objektorientert programmering er et viktig paradigme ettersom det gir deg mer kontroll over programmet og oppmuntrer til gjenbruk av kode på måter funksjonell programmering ikke gjør.

Dette gjør ikke funksjonell programmering til et dårlig valg, ettersom funksjonell programmering kan være nyttig og bedre for noen brukstilfeller.

Hva er objektorientert programmering? Det grunnleggende forklart i lekmannsvilkår

Les Neste

Om forfatteren