Hur man implementerar objektorienterade programmeringskoncept i Go

Objektorienterad programmering (OOP) är ett programmeringsparadigm baserat på objekt som det centrala begreppet. I OOP formateras koden baserat på funktionalitet, vilket möjliggör kodunderhåll, abstraktion, återanvändbarhet, effektivitet och många funktioner på objektet.

Objektet har attribut (variabler) som definierar dess egenskaper, egenskaper och metoder (funktioner) som definierar objektets åtgärder (procedurer) och beteenden.

Objektorienterad programmering i Go skiljer sig från andra språk. Objektorienterade koncept implementeras i Go med hjälp av strukturer, gränssnitt och anpassade typer.

Anpassa typer i Go

Anpassade typer gör det enkelt att gruppera och identifiera liknande kod för återanvändning.

Koden för att deklarera anpassade typer är:

typ typName dataType 

När du skapar en anpassad typ och tilldelar en variabel kan du kontrollera typen med reflektera. Sorts() som tar in en variabel och returnerar typen av variabel.

importera("fmt"
 "reflektera")
typ två int// skapar typ "två"
var nummer två // variabel av typen "två"
fmt. Println (reflektera. TypeOf (antal))

​​​

De siffra variabel är en typ av två som är ett heltal. Du kan gå längre för att skapa mer av den anpassade typen.

Skapa strukturer i Go

Strukturer (strukturer) är ritningarna för objektorienterad programmering i Go. Strukturer är användardefinierade samlingar av fält.

En struktur kan innehålla en mängd olika datatyper, inklusive sammansatta typer och metoder.

Du kan skapa en struktur med hjälp av denna syntax:

typ StructName struktur {
// lite kod
}

Konventionellt är strukturnamn vanligtvis versaler och kamelkapslade för läsbarhet.

Strukturtypen tar in fältnamn och datatyper. Strukturer kan ta in alla Go-datatyper, inklusive anpassade typer.

typ Användare struktur {
 fält1 sträng
 fält2 int
 fältkarta Karta[sträng]int
}

Du kan instansiera en strukturtyp genom att tilldela strukturen som en variabel.

instans := Användare{
// lite kod
}

struct-instansen kan fyllas i med fält vid instansiering som definierats vid initiering eller satt till null.

instans := Användare{
 fält1: "a sträng fält",
 fält 2: 10,
 fältkarta: Karta[sträng]int{},
 }

Åtkomst till strukturelement

Du kan komma åt fälten i en struct-instans med hjälp av en punktnotation till fältet.

fmt. Println("Åtkomst till ett värdefält", instans.fält2)

Detta ger ut fält2 av den instansierade structinstansen.

Tilldela metoder till strukturer

Funktioner (metoder) tilldelas strukturtyper genom att ange ett mottagarnamn och strukturnamnet före funktionsnamnet som visas i syntaxen nedan.

func(mottagare StructName)funktionsnamn() {
// lite kod
}

Metoden funktionsnamn kan endast användas på den specificerade strukturtypen.

Implementering av arv i Go

Arv är objekts och typers förmåga att komma åt och använda metoder och attribut för andra objekt. Go har inte Arv som funktion, men du kan använda kompositioner. I Go innebär komposition att hänvisa till en superstruktur (strukturen som ska ärvas) i en substruktur genom att ange superstrukturens namn till substrukturen.

Med hjälp av strukturexemplet ovan:

typ Användare struktur {
 fält1 sträng
 fält2 int
 fältkarta Karta[sträng]int
}
typ Användare 2 struktur {
 Användare
}

Genom att passera Användare strukturera namn till Användare 2 struct, den Användare 2 struct kan komma åt alla metoder och attribut för Användare struktur på instansiering förutom att abstraktionstekniker används.

son := Användare2{
 Användare{
 field1: "baby",
 fält 2: 0,
 fältkarta: noll,
 },
 }
fmt. Println (son.field2)

De son variabeln ovan är en instansiering av Användare 2 struktur. Som framgår av exemplet är son variabel kan komma åt och instansiera värden av användartypen och använda dem.

Inkapslar typfält i Go

Inkapsling, även känd som "informationsdöljande", är en teknik för att bunta ett objekts metoder och attribut till enheter för att begränsa användningen och åtkomsten förutom vad som anges (aktiverar läs-/skrivbehörigheter).

Inkapsling implementeras i Go med hjälp av exporterade och oexporterade identifierare i paket.

Exporterade identifierare (läs och skriv)

Exporterade identifierare exporteras från deras definierade paket och tillgång till andra program. Genom att använda versaler i en fältidentifierare exporteras fältet fo.

typ Användare struktur {
 Fält 1 sträng
 Fält 2 int
 Fältkarta Karta[sträng]int
}
typ Användare 2 struktur {
 Användare
}

Ej exporterade identifierare (skrivskyddad)

Oexporterade identifierare exporteras inte från det definierade paketet och är vanligtvis små bokstäver.

typ Användare struktur {
 fält1 sträng
 fält2 int
 fältkarta Karta[sträng]int
}
typ Användare 2 struktur {
 Användare
}

Konceptet med exporterade och ej exporterade identifierare gäller även för metoderna för ett objekt.

Polymorfism i Go

Polymorfism är en teknik som används för att ge olika former till ett objekt för flexibilitet.

Go implementerar polymorfism med hjälp av gränssnitt. Gränssnitt är anpassade typer som används för att definiera metodsignaturer.

Deklarerar gränssnitt

Att deklarera gränssnitt liknar att deklarera strukturer. Gränssnitt deklareras dock med hjälp av gränssnitt nyckelord.

typ Gränssnittsnamn gränssnitt{
//några metoder
}

Gränssnittsdeklarationer innehåller metoder som ska implementeras av struct-typer.

Implementera gränssnitt i strukturer

Typerna som implementerar gränssnittet måste deklareras varefter metoden för typen implementerar gränssnittet.

// Gränssnittet
typ Färg gränssnitt{
 Måla() sträng
}
// Deklarerar strukturerna
typ Grön struktur {
// någon strukturspecifik kod
}
typ Blå struktur {
// någon specifik kod
}

Kodavsnittet ovan har en Färg gränssnitt deklarerat med en Måla metod som ska implementeras av Grön och Blå strukturtyper.

Gränssnitt implementeras genom att tilldela metoder till strukturtyper och sedan namnge metoden efter den gränssnittsmetod som ska implementeras.

func(g grön)Måla()sträng {
lämna tillbaka "målad grön"
}
func(b blå)Måla()sträng {
lämna tillbaka "målad blå"
}

Paint-metoden implementeras av gröna och blå typer som nu kan anropa och använda Måla metod.

borste := Grön{}
fmt. Println (pensel. Måla())

"Målad grön" är tryckt på konsolen och bekräftar att gränssnittet har implementerats.

Abstrahera fält i Go

Abstraktion är processen att dölja oviktiga metoder och attribut av en typ, vilket gör det lättare att säkra delar av programmet från onormal, oavsiktlig användning.

Go har inte abstraktion implementerad direkt; du kan dock arbeta oss genom att implementera abstraktion med hjälp av gränssnitt.

// människor kan springa
typ Mänsklig gränssnitt {
 springa() sträng
}
// Pojke är en människa med ben
typ Pojke struktur {
 Ben sträng
}
// en metod för pojke implementerar körmetoden för det mänskliga gränssnittet
func(h Pojke)springa()sträng {
lämna tillbaka h. Ben
}

Koden ovan skapar en Mänsklig gränssnitt med en springa gränssnitt som returnerar en sträng. De Pojke typ implementerar springa metod för Mänsklig gränssnitt och returnerar en sträng vid instansiering.

Ett av sätten att implementera abstraktion är att få en struktur att ärva gränssnittet vars metoder ska abstraheras. Det finns många andra tillvägagångssätt, men det här är det enklaste.

typ Person struktur {
 namn sträng
 Ålder int
 Status Människan 
}
funchuvud() {
 person1 := &Pojke{Ben: "två ben"}
 person2 := &Person{ // förekomst av en person
 Namn: "amina",
 Ålder: 19,
 Status: person1,
 }
 fmt. Println (person. Status.run()) 
}

De Person struct ärver Mänsklig gränssnitt och kan komma åt alla dess metoder med hjälp av variabeln Status ärver gränssnittet.

Vid instansiering genom referens (med hjälp av en pekare), instansen av Person struktur Person2 refererar till en instans av Pojke struktur Person1 och får tillgång till metoderna.

På så sätt kan du specificera specifika metoder som ska implementeras av typen.

OOP vs funktionell programmering

Objektorienterad programmering är ett viktigt paradigm eftersom det ger dig mer kontroll över ditt program och uppmuntrar kodåteranvändning på ett sätt som funktionell programmering inte gör.

Detta gör inte funktionell programmering till ett dåligt val, eftersom funktionell programmering kan vara till hjälp och bättre för vissa användningsfall.

Vad är objektorienterad programmering? Grunderna förklaras i lekmans villkor

Läs Nästa

Om författaren