Cum să implementați concepte de programare orientată pe obiecte în Go

Programarea orientată pe obiecte (OOP) este o paradigmă de programare bazată pe obiecte ca concept central. În OOP, codul este formatat pe baza funcționalității, permițând întreținerea codului, abstracția, reutilizarea, eficiența și numeroase funcționalități ale obiectului.

Obiectul are atribute (variabile) care îi definesc caracteristicile, proprietățile și metodele (funcțiile) care definesc acțiunile (procedurile) și comportamentele obiectului.

Programarea orientată pe obiecte în Go este diferită de alte limbaje. Conceptele orientate pe obiecte sunt implementate în Go folosind structuri, interfețe și tipuri personalizate.

Personalizarea tipurilor în Go

Tipurile personalizate facilitează gruparea și identificarea codului similar pentru reutilizare.

Codul pentru declararea tipurilor personalizate este:

tip typeName dataType 

La crearea unui tip personalizat și alocarea unei variabile, puteți verifica tipul folosind Reflectați. Tip de() care preia o variabilă și returnează tipul variabilei.

import





instagram viewer
("fmt"
 "Reflectați")
tip Două int// creează tipul „două”
var numarul doi // variabilă de tip „două”
fmt. Println (reflect. TypeOf (număr))

​​​

The număr variabila este un tip de Două care este un număr întreg. Puteți merge mai departe pentru a crea mai multe tipuri personalizate.

Crearea structurilor în Go

Structurile (structurile) sunt planurile pentru programarea orientată pe obiecte în Go. Structurile sunt colecții de câmpuri definite de utilizator.

O structură poate conține o varietate de tipuri de date, inclusiv tipuri și metode compuse.

Puteți crea o structură folosind această sintaxă:

tip StructName struct {
// ceva cod
}

În mod convențional, numele structurilor sunt de obicei scrise cu majuscule și cu majuscule camel pentru lizibilitate.

Tipul struct preia numele câmpurilor și tipurile de date. Structurile pot prelua orice tip de date Go, inclusiv tipuri personalizate.

tip Utilizator struct {
 câmpul 1 şir
 câmpul2 int
 fieldMap Hartă[şir]int
}

Puteți instanția un tip de struct prin atribuirea structurii ca variabilă.

instanță := Utilizator{
// ceva cod
}

Instanța struct poate fi populată cu câmpuri la instanțiere așa cum a fost definită la inițializare sau setată la null.

instanță := Utilizator{
 câmpul 1: „a şir camp",
 câmpul 2: 10,
 fieldMap: Hartă[şir]int{},
 }

Accesarea elementelor de structură

Puteți accesa câmpurile unei instanțe struct folosind o notație cu puncte în câmp.

fmt. Println("Accesarea unui câmp de valoare", instance.field2)

Acest lucru produce câmpul2 a instanței struct instanțiate.

Atribuirea metodelor la Structs

Funcțiile (metodele) sunt atribuite tipurilor de structuri prin specificarea unui nume de receptor și numele structurii înaintea numelui funcției, așa cum se arată în sintaxa de mai jos.

func(receptor StructName)functionName() {
// ceva cod
}

Metoda functionName poate fi folosit numai pe tipul de struct specificat.

Implementarea Moștenirii în Go

Moștenirea este capacitatea obiectelor și a tipurilor de a accesa și de a utiliza metode și atribute ale altor obiecte. Go nu are Moștenirea ca caracteristică, dar puteți folosi compoziții. În Go, compoziția implică referirea la o suprastructură (structul care urmează să fie moștenit) într-un substruct, furnizând numele suprastructului substructului.

Folosind exemplul de structura de mai sus:

tip Utilizator struct {
 câmpul 1 şir
 câmpul2 int
 fieldMap Hartă[şir]int
}
tip Utilizator2 struct {
 Utilizator
}

Prin trecerea Utilizator struct numele în Utilizator2 struct, the Utilizator2 struct poate accesa toate metodele și atributele Utilizator struct pe instanțiere, cu excepția utilizării tehnicilor de abstractizare.

fiul := User2{
 Utilizator{
 câmpul 1: „copil”,
 câmpul 2: 0,
 fieldMap: zero,
 },
 }
fmt. Println (son.field2)

The fiul variabila de mai sus este o instanțiere a Utilizator2 struct. După cum se vede în exemplu, the fiul variabila poate accesa și instanția valori ale tipului de utilizator și le poate folosi.

Încapsularea câmpurilor de tip în Go

Încapsularea, cunoscută și sub denumirea de „ascunderea informațiilor”, este a tehnică de grupare a metodelor și atributelor unui obiect în unități pentru a restricționa utilizarea și accesul, cu excepția celor specificate (permiterea privilegiilor de citire/scriere).

Încapsularea este implementată în Go folosind identificatori exportați și neexportați în pachete.

Identificatori exportați (citire și scriere)

Identificatorii exportați sunt exportați din pachetele lor definite și accesul la alte programe. Valorificarea unui identificator de câmp exportă câmpul fo.

tip Utilizator struct {
 Câmpul 1 şir
 Câmpul 2 int
 FieldMap Hartă[şir]int
}
tip Utilizator2 struct {
 Utilizator
}

Identificatori neexportați (numai citire)

Identificatorii neexportați nu sunt exportați din pachetul definit și sunt în mod convențional litere mici.

tip Utilizator struct {
 câmpul 1 şir
 câmpul2 int
 fieldMap Hartă[şir]int
}
tip Utilizator2 struct {
 Utilizator
}

Conceptul de identificatori exportați și neexportați se aplică și metodelor unui obiect.

Polimorfismul în Go

Polimorfismul este o tehnică folosită pentru a da diferite forme unui obiect pentru flexibilitate.

Go implementează polimorfismul folosind interfețe. Interfețele sunt tipuri personalizate utilizate pentru a defini semnăturile metodei.

Declararea interfețelor

Declararea interfețelor este similară cu declararea structurilor. Cu toate acestea, interfețele sunt declarate folosind interfata cuvânt cheie.

tip InterfaceName interfata{
//unele metode
}

Declarațiile de interfață conțin metode care urmează să fie implementate de tipurile de structuri.

Implementarea interfețelor în Structs

Tipurile care implementează interfața trebuie declarate după care metodele tipului implementează interfața.

// Interfața
tip Culoare interfata{
 A picta() şir
}
// Declararea structurilor
tip Verde struct {
// un cod specific structurii
}
tip Albastru struct {
// un cod specific
}

Fragmentul de cod de mai sus are un Culoare interfață declarată cu a A picta metoda care urmează să fie implementată de către Verde și Albastru tipuri de structuri.

Interfețele sunt implementate prin atribuirea de metode tipurilor de struct și apoi denumirea metodei după metoda interfeței care urmează să fie implementată.

func(g verde)A picta()şir {
întoarcere "vopsit în verde"
}
func(b Albastru)A picta()şir {
întoarcere "vopsit in albastru"
}

Metoda Paint este implementată de tipurile Green și Blue, care acum pot apela și utiliza A picta metodă.

perie := verde{}
fmt. Println (perie. A picta())

„Vopsit în verde” este imprimat pe consolă, validând că interfața a fost implementată cu succes.

Extragerea câmpurilor în Go

Abstracția este procesul de ascundere a metodelor și atributelor neimportante ale unui tip, ceea ce face mai ușor să securizeze părți ale programului împotriva utilizării anormale, neintenționate.

Go nu are abstracția implementată de la început; cu toate acestea, puteți să ne faceți drum prin implementarea abstracției folosind interfețe.

// oamenii pot alerga
tip Uman interfata {
 alerga() şir
}
// Băiatul este un om cu picioare
tip Băiat struct {
 Picioarele şir
}
// o metodă pe băiat implementează metoda de rulare a interfeței Uman
func(h băiat)alerga()şir {
întoarcere h. Picioarele
}

Codul de mai sus creează un Uman interfață cu a alerga interfață care returnează un șir. The Băiat tip implementează alerga metoda de Uman interfață și returnează un șir la instanțiere.

Una dintre modalitățile de implementare a abstractizării este de a face ca o structură să moștenească interfața ale cărei metode urmează să fie abstractizate. Există multe alte abordări, dar aceasta este cea mai ușoară.

tip Persoană struct {
 Nume şir
 Vârstă int
 Statut uman 
}
funcprincipal() {
 person1 := &Băiat{Picioare: „două picioare”}
 person2 := &Person{ // instanță a unei persoane
 Nume: "amina",
 Vârstă: 19,
 Stare: persoana 1,
 }
 fmt. Println (persoană. Status.run()) 
}

The Persoană struct moștenește Uman interfață și poate accesa toate metodele sale folosind variabila stare moștenind interfața.

La instanțierea prin referință (folosind un pointer), instanța lui Persoană struct Persoana2 face referire la o instanță a Băiat struct Persoana1 și are acces la metode.

În acest fel, puteți specifica metode specifice care urmează să fie implementate de tip.

OOP vs programare funcțională

Programarea orientată pe obiecte este o paradigmă importantă, deoarece vă oferă mai mult control asupra programului dvs. și încurajează reutilizarea codului în moduri în care programarea funcțională nu o face.

Acest lucru nu face din programarea funcțională o alegere proastă, deoarece programarea funcțională poate fi utilă și mai bună pentru unele cazuri de utilizare.

Ce este programarea orientată pe obiecte? Elementele de bază explicate în Termenii profani

Citiți în continuare

Despre autor