Objectgeoriënteerde programmeerconcepten implementeren in Go

Object-Oriented Programming (OOP) is een programmeerparadigma gebaseerd op objecten als centraal concept. In OOP wordt code geformatteerd op basis van functionaliteit, waardoor code-onderhoud, abstractie, herbruikbaarheid, efficiëntie en tal van functionaliteit op het object mogelijk is.

Het object heeft attributen (variabelen) die de kenmerken, eigenschappen en methoden (functies) definiëren die de acties (procedures) en het gedrag van het object definiëren.

Objectgeoriënteerd programmeren in Go is anders dan andere talen. Objectgeoriënteerde concepten worden in Go geïmplementeerd met behulp van structs, interfaces en aangepaste typen.

Typen aanpassen in Go

Aangepaste typen maken het gemakkelijk om vergelijkbare code te groeperen en te identificeren voor hergebruik.

De code voor het declareren van aangepaste typen is:

type typeNaam dataType 

Bij het maken van een aangepast type en het toewijzen van een variabele, kunt u het type controleren met reflecteren. Soort van() die een variabele opneemt en het type van de variabele retourneert.

importeren("fmt"
 "reflecteren")
type twee int// maakt type "twee"
var nummer twee // variabele van het type "twee"
fmt. Println (reflect. TypeOf (aantal))

​​​

De nummer variabele is een type van twee wat een geheel getal is. U kunt verder gaan om meer van het aangepaste type te maken.

Structuren maken in Go

Structs (structuren) zijn de blauwdrukken voor objectgeoriënteerd programmeren in Go. Structuren zijn door de gebruiker gedefinieerde verzamelingen velden.

Een struct kan verschillende gegevenstypen bevatten, waaronder samengestelde typen en methoden.

U kunt een structuur maken met behulp van deze syntaxis:

type structuurnaam structureren {
// een code
}

Conventioneel worden structnamen meestal met een hoofdletter geschreven en in een kameel geplaatst voor de leesbaarheid.

Het struct-type neemt veldnamen en datatypes in. Structs kunnen elk Go-gegevenstype bevatten, inclusief aangepaste typen.

type Gebruiker structureren {
 veld1 draad
 veld2 int
 veldkaart kaart[draad]int
}

U kunt een struct-type instantiëren door de struct als een variabele toe te wijzen.

instantie := Gebruiker{
// een code
}

Het struct-exemplaar kan worden gevuld met velden bij instantiatie zoals gedefinieerd bij initialisatie of ingesteld op null.

instantie := Gebruiker{
 veld1: "a draad veld",
 veld2: 10,
 veldkaart: kaart[draad]int{},
 }

Toegang tot structuurelementen

U kunt toegang krijgen tot de velden van een struct-instantie met behulp van een puntnotatie bij het veld.

fmt. Println("Toegang tot een waardeveld", instance.field2)

Dit geeft de veld2 van de instantie die is geïnstantieerd.

Methoden toewijzen aan structuren

Functies (methoden) worden toegewezen aan struct-typen door een ontvangernaam en de struct-naam voor de functienaam op te geven, zoals weergegeven in de onderstaande syntaxis.

func(ontvanger structuurnaam)functienaam() {
// een code
}

De methode functienaam kan alleen worden gebruikt op het opgegeven structuurtype.

Overerving implementeren in Go

overerving is het vermogen van objecten en typen om toegang te krijgen tot methoden en attributen van andere objecten en deze te gebruiken. Go heeft geen Inheritance als functie, maar je kunt composities gebruiken. In Go houdt compositie in dat wordt verwezen naar een superstruct (de over te nemen structuur) in een substruct door de naam van de superstruct aan de substruct te geven.

Met behulp van het bovenstaande structuurvoorbeeld:

type Gebruiker structureren {
 veld1 draad
 veld2 int
 veldkaart kaart[draad]int
}
type Gebruiker2 structureren {
 Gebruiker
}

Door het passeren van de Gebruiker naam structureren in de Gebruiker2 struct, de Gebruiker2 struct heeft toegang tot alle methoden en attributen van de Gebruiker struct op instantiatie, behalve dat abstractietechnieken worden gebruikt.

zoon := Gebruiker2{
 Gebruiker{
 veld1: "baby",
 veld2: 0,
 veldkaart: nul,
 },
 }
fmt. Println (zoon.veld2)

De zoon variabele hierboven is een instantie van de Gebruiker2 structureren. Zoals te zien is in het voorbeeld, de zoon variabele kan waarden van het gebruikerstype openen en instantiëren en gebruiken.

Typevelden inkapselen in Go

Inkapseling, ook wel 'informatie verbergen' genoemd, is een techniek om de methoden en attributen van een object in eenheden te bundelen om het gebruik en de toegang te beperken, behalve gespecificeerd (lees-/schrijfrechten inschakelen).

Inkapseling is geïmplementeerd in Go met behulp van geëxporteerde en niet-geëxporteerde ID's in pakketten.

Geëxporteerde ID's (lezen en schrijven)

Geëxporteerde identifiers worden geëxporteerd vanuit hun gedefinieerde pakketten en toegang tot andere programma's. Door een veld-ID met een hoofdletter te schrijven, wordt het veld fo geëxporteerd.

type Gebruiker structureren {
 Veld1 draad
 Veld2 int
 Veldkaart kaart[draad]int
}
type Gebruiker2 structureren {
 Gebruiker
}

Niet-geëxporteerde ID's (alleen-lezen)

Niet-geëxporteerde ID's worden niet geëxporteerd vanuit het gedefinieerde pakket en worden gewoonlijk in kleine letters weergegeven.

type Gebruiker structureren {
 veld1 draad
 veld2 int
 veldkaart kaart[draad]int
}
type Gebruiker2 structureren {
 Gebruiker
}

Het concept van geëxporteerde en niet-geëxporteerde identifiers is ook van toepassing op de methoden van een object.

Polymorfisme in Go

Polymorfisme is een techniek die wordt gebruikt om verschillende vormen aan een object te geven voor flexibiliteit.

Go implementeert polymorfisme met behulp van interfaces. Interfaces zijn aangepaste typen die worden gebruikt om methodehandtekeningen te definiëren.

Interfaces declareren

Het declareren van interfaces is vergelijkbaar met het declareren van structs. Interfaces worden echter gedeclareerd met de koppel trefwoord.

type Interfacenaam koppel{
//sommige methoden
}

Interface-declaraties bevatten methoden die moeten worden geïmplementeerd door struct-typen.

Interfaces implementeren in Structs

De typen die de interface implementeren moeten worden gedeclareerd, waarna de methoden van het type de interface implementeren.

// De interface
type Kleur koppel{
 Verf() draad
}
// De structs verklaren
type Groente structureren {
// sommige struct specifieke code
}
type Blauw structureren {
// een specifieke code
}

Het bovenstaande codefragment heeft een Kleur interface gedeclareerd met a Verf methode die moet worden geïmplementeerd door de Groente en Blauw soorten structuur.

Interfaces worden geïmplementeerd door methoden toe te wijzen aan structtypen en vervolgens de methode te benoemen door de te implementeren interfacemethode.

func(g Groen)Verf()draad {
opbrengst "groen geverfd"
}
func(b Blauw)Verf()draad {
opbrengst "blauw geverfd"
}

De Paint-methode wordt geïmplementeerd door groene en blauwe typen die nu de. kunnen aanroepen en gebruiken Verf methode.

penseel := Groen{}
fmt. Println (borstel. Verf())

"Geverfd groen" wordt afgedrukt op de console en bevestigt dat de interface met succes is geïmplementeerd.

Velden abstraheren in Go

abstractie is het proces van het verbergen van onbelangrijke methoden en attributen van een type, waardoor het gemakkelijker wordt om delen van het programma te beveiligen tegen abnormaal, onbedoeld gebruik.

Go heeft abstractie niet meteen geïmplementeerd; u kunt ons echter een weg banen door abstractie te implementeren met behulp van interfaces.

// mensen kunnen rennen
type Menselijk koppel {
 loop() draad
}
// Jongen is een mens met benen
type Jongen structureren {
 Poten draad
}
// een methode op jongen implementeert de run-methode van de menselijke interface
func(h jongen)loop()draad {
opbrengst h. Poten
}

De bovenstaande code creëert een Menselijk interface met a loop interface die een string retourneert. De Jongen type implementeert de loop methode van de Menselijk interface en retourneert een string bij instantiatie.

Een van de manieren om abstractie te implementeren is door een struct de interface te laten erven waarvan de methoden moeten worden geabstraheerd. Er zijn veel andere benaderingen, maar dit is de gemakkelijkste.

type Persoon structureren {
 Naam draad
 Leeftijd int
 Status Mens 
}
funchoofd() {
 person1 := &Jongen{Benen: "twee benen"}
 persoon2 := &Persoon{ // instantie van een persoon
 Naam: "amina",
 Leeftijd: 19,
 Status: persoon1,
 }
 fmt. Println (persoon. Status.run()) 
}

De Persoon struct erft de Menselijk interface en heeft toegang tot al zijn methoden met behulp van de variabele Toestand de interface erven.

Bij instantiëren door verwijzing (met behulp van een aanwijzer), de instantie van de Persoon structureren Persoon2 verwijst naar een instantie van de Jongen structureren Persoon1 en krijgt toegang tot de methoden.

Op deze manier kunt u specifieke methoden specificeren die door het type moeten worden geïmplementeerd.

OOP versus functioneel programmeren

Objectgeoriënteerd programmeren is een belangrijk paradigma omdat het u meer controle over uw programma geeft en het hergebruik van code aanmoedigt op een manier waarop functioneel programmeren dat niet doet.

Dit maakt functioneel programmeren geen slechte keuze, aangezien functioneel programmeren voor sommige toepassingen nuttig en beter kan zijn.

Wat is objectgeoriënteerd programmeren? De basis uitgelegd in lekentaal

Lees volgende

Over de auteur