Sådan implementeres objektorienterede programmeringskoncepter i Go

Objektorienteret programmering (OOP) er et programmeringsparadigme baseret på objekter som det centrale koncept. I OOP formateres kode baseret på funktionalitet, hvilket muliggør kodevedligeholdelse, abstraktion, genanvendelighed, effektivitet og talrige funktioner på objektet.

Objektet har attributter (variabler), der definerer dets karakteristika, egenskaber og metoder (funktioner), som definerer objektets handlinger (procedurer) og adfærd.

Objektorienteret programmering i Go adskiller sig fra andre sprog. Objektorienterede koncepter implementeres i Go ved hjælp af strukturer, grænseflader og brugerdefinerede typer.

Tilpasning af typer i Go

Brugerdefinerede typer gør det nemt at gruppere og identificere lignende kode til genbrug.

Koden til at angive brugerdefinerede typer er:

type typeNavn dataType 

Når du opretter en brugerdefineret type og tildeler en variabel, kan du kontrollere typen vha afspejle. Type() som tager en variabel ind og returnerer variablens type.

importere("fmt"
 "afspejle")





instagram viewer


type to int// opretter typen "to"
var nummer to // variabel af typen "to"
fmt. Println (afspejle. TypeOf (antal))

​​​

Det nummer variabel er en type to som er et heltal. Du kan gå længere for at oprette mere af den tilpassede type.

Oprettelse af strukturer i Go

Strukturer (strukturer) er tegningerne til objektorienteret programmering i Go. Strukturer er brugerdefinerede samlinger af felter.

En struktur kan indeholde en række forskellige datatyper, herunder sammensatte typer og metoder.

Du kan oprette en struktur ved hjælp af denne syntaks:

type Strukturnavn struktur {
// noget kode
}

Konventionelt er strukturnavne sædvanligvis med stort bogstav og kamel-huse for at kunne læse dem.

Strukturtypen optager feltnavne og datatyper. Strukturer kan optage enhver Go-datatype, inklusive brugerdefinerede typer.

type Bruger struktur {
 felt1 snor
 felt2 int
 feltkort kort[snor]int
}

Du kan instansiere en strukturtype ved at tildele strukturen som en variabel.

instans := Bruger{
// noget kode
}

Strukturforekomsten kan udfyldes med felter ved instansiering som defineret ved initialisering eller sat til null.

instans := Bruger{
 felt1: "a snor Mark",
 felt 2: 10,
 feltkort: kort[snor]int{},
 }

Adgang til strukturelementer

Du kan få adgang til felterne i en struct-instans ved hjælp af en priknotation til feltet.

fmt. Println("Adgang til et værdifelt", instance.field2)

Dette udsender felt2 af den instansierede struct-instans.

Tildeling af metoder til strukturer

Funktioner (metoder) tildeles strukturtyper ved at angive et modtagernavn og strukturnavnet før funktionsnavnet som vist i syntaksen nedenfor.

func(modtager StructName)funktionsnavn() {
// noget kode
}

Metoden funktionsnavn kan kun bruges på den specificerede strukturtype.

Implementering af arv i Go

Arv er objekters og typers evne til at få adgang til og bruge andre objekters metoder og attributter. Go har ikke Inheritance som funktion, men du kan bruge kompositioner. I Go indebærer komposition, at man refererer til en overbygning (den struktur, der skal nedarves) i en underbygning ved at angive overbygningens navn til underbygningen.

Ved at bruge struktureksemplet ovenfor:

type Bruger struktur {
 felt1 snor
 felt2 int
 feltkort kort[snor]int
}
type Bruger 2 struktur {
 Bruger
}

Ved at bestå Bruger struct navn ind i Bruger 2 struct, den Bruger 2 struct kan få adgang til alle metoder og attributter for Bruger struktur på instansiering, undtagen der anvendes abstraktionsteknikker.

søn := Bruger2{
 Bruger{
 felt1: "baby",
 felt 2: 0,
 feltkort: nul,
 },
 }
fmt. Println (son.field2)

Det søn variabel ovenfor er en instansiering af Bruger 2 struktur. Som det ses i eksemplet søn variabel kan få adgang til og instansiere værdier af brugertypen og bruge dem.

Indkapsling af typefelter i Go

Indkapsling, også kendt som "informationsskjul", er en teknik til at samle et objekts metoder og attributter i enheder for at begrænse brugen og adgangen undtagen specificeret (aktiverer læse/skrive-rettigheder).

Indkapsling er implementeret i Go ved hjælp af eksporterede og ikke-eksporterede identifikatorer i pakker.

Eksporterede identifikatorer (læs og skriv)

Eksporterede identifikatorer eksporteres fra deres definerede pakker og adgang til andre programmer. Ved at skrive et felt-id med stort bogstav eksporteres feltet fo.

type Bruger struktur {
 Felt 1 snor
 Felt 2 int
 Feltkort kort[snor]int
}
type Bruger 2 struktur {
 Bruger
}

Ikke-eksporterede identifikatorer (skrivebeskyttet)

Ikke-eksporterede identifikatorer eksporteres ikke fra den definerede pakke og er konventionelt med små bogstaver.

type Bruger struktur {
 felt1 snor
 felt2 int
 feltkort kort[snor]int
}
type Bruger 2 struktur {
 Bruger
}

Konceptet med eksporterede og ikke-eksporterede identifikatorer gælder også for et objekts metoder.

Polymorfi i Go

Polymorfi er en teknik, der bruges til at give forskellige former til et objekt for fleksibilitet.

Go implementerer polymorfi ved hjælp af grænseflader. Grænseflader er brugerdefinerede typer, der bruges til at definere metodesignaturer.

Erklærer grænseflader

Erklæring af grænseflader svarer til at erklære strukturer. Men grænseflader erklæres ved hjælp af interface søgeord.

type Interfacenavn interface{
//nogle metoder
}

Interface-deklarationer indeholder metoder, der skal implementeres af struct-typer.

Implementering af grænseflader i strukturer

De typer, der implementerer grænsefladen, skal deklareres, hvorefter typens metoder implementerer grænsefladen.

// Interfacet
type Farve interface{
 Maling() snor
}
// Erklæring af strukturerne
type Grøn struktur {
// en eller anden strukturspecifik kode
}
type Blå struktur {
// en bestemt kode
}

Kodestykket ovenfor har en Farve grænseflade erklæret med en Maling metode, der skal implementeres af Grøn og Blå struktur typer.

Grænseflader implementeres ved at tildele metoder til strukturtyper og derefter navngive metoden efter interfacemetoden, der skal implementeres.

func(g Grøn)Maling()snor {
Vend tilbage "malet grøn"
}
func(b blå)Maling()snor {
Vend tilbage "malet blå"
}

Paint-metoden er implementeret af grønne og blå typer, som nu kan kalde og bruge Maling metode.

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

"Painted green" er trykt på konsollen, hvilket bekræfter, at grænsefladen blev implementeret.

Abstraktion af felter i farten

Abstraktion er processen med at skjule uvigtige metoder og attributter af en type, hvilket gør det nemmere at sikre dele af programmet mod unormal, utilsigtet brug.

Go har ikke abstraktion implementeret lige fra hånden; du kan dog arbejde os gennem implementering af abstraktion ved hjælp af grænseflader.

// mennesker kan løbe
type Human interface {
 løb() snor
}
// Dreng er et menneske med ben
type Dreng struktur {
 Ben snor
}
// en metode på dreng implementerer kørselsmetoden i Human-grænsefladen
func(h dreng)løb()snor {
Vend tilbage h. Ben
}

Koden ovenfor opretter en Human grænseflade med en løb grænseflade, der returnerer en streng. Det Dreng type implementerer løb metoden til Human interface og returnerer en streng ved instansiering.

En af måderne at implementere abstraktion på er ved at få en struktur til at arve den grænseflade, hvis metoder skal abstraheres. Der er mange andre tilgange, men dette er den nemmeste.

type Person struktur {
 Navn snor
 Alder int
 Status Menneske 
}
funcvigtigste() {
 person1 := &Dreng{Ben: "to ben"}
 person2 := &Person{ // forekomst af en person
 Navn: "amina",
 Alder: 19,
 Status: person1,
 }
 fmt. Println (person. Status.run()) 
}

Det Person struct arver Human interface og kan få adgang til alle dens metoder ved hjælp af variablen Status arver grænsefladen.

Ved instansiering ved reference (ved hjælp af en markør), forekomsten af Person struktur Person 2 henviser til et eksempel på Dreng struktur Person 1 og får adgang til metoderne.

På denne måde kan du specificere specifikke metoder, der skal implementeres af typen.

OOP vs funktionel programmering

Objektorienteret programmering er et vigtigt paradigme, da det giver dig mere kontrol over dit program og tilskynder til genbrug af kode på måder, som funktionel programmering ikke gør.

Dette gør ikke funktionel programmering til et dårligt valg, da funktionel programmering kan være nyttigt og bedre i nogle tilfælde.

Hvad er objektorienteret programmering? Det grundlæggende forklaret i lægmands vilkår

Læs Næste

Om forfatteren