Come implementare concetti di programmazione orientata agli oggetti in Go

La programmazione orientata agli oggetti (OOP) è un paradigma di programmazione basato sugli oggetti come concetto centrale. In OOP, il codice è formattato in base alla funzionalità, consentendo la manutenzione del codice, l'astrazione, la riutilizzabilità, l'efficienza e numerose funzionalità sull'oggetto.

L'oggetto ha attributi (variabili) che ne definiscono le caratteristiche, le proprietà ei metodi (funzioni) che definiscono le azioni (procedure) ei comportamenti dell'oggetto.

La programmazione orientata agli oggetti in Go è diversa dagli altri linguaggi. I concetti orientati agli oggetti vengono implementati in Go utilizzando struct, interfacce e tipi personalizzati.

Personalizzazione dei tipi in Go

I tipi personalizzati semplificano il raggruppamento e l'identificazione di codice simile per il riutilizzo.

Il codice per dichiarare i tipi personalizzati è:

genere typeName dataType 

Durante la creazione di un tipo personalizzato e l'assegnazione di una variabile, è possibile verificare il tipo utilizzando

riflettere. Tipo di() che accetta una variabile e restituisce il tipo della variabile.

importare("fmt"
 "riflettere")
genere Due int// crea il tipo "due"
var numero due // variabile di tipo "due"
fmt. Println (rif. TipoDi (numero))

​​​

Il numero variabile è un tipo di Due che è un numero intero. Puoi andare oltre per creare più tipi personalizzati.

Creazione di struct in Go

Le strutture (strutture) sono i progetti per la programmazione orientata agli oggetti in Go. Gli struct sono raccolte di campi definite dall'utente.

Uno struct può contenere una varietà di tipi di dati, inclusi tipi e metodi composti.

Puoi creare una struttura usando questa sintassi:

genere Nomestruttura struttura {
// del codice
}

Convenzionalmente, i nomi degli struct sono solitamente in maiuscolo e in maiuscolo per la leggibilità.

Il tipo struct accetta nomi di campo e tipi di dati. Structs può accettare qualsiasi tipo di dati Go, inclusi i tipi personalizzati.

genere Utente struttura {
 campo1 corda
 campo2 int
 campoMap carta geografica[corda]int
}

È possibile creare un'istanza di un tipo struct assegnando lo struct come variabile.

istanza := Utente{
// del codice
}

L'istanza struct può essere popolata con campi sull'istanza come definito all'inizializzazione o impostata su null.

istanza := Utente{
 campo1: "a corda campo",
 campo2: 10,
 mappa del campo: carta geografica[corda]int{},
 }

Accesso agli elementi strutturali

È possibile accedere ai campi di un'istanza struct utilizzando una notazione a punto nel campo.

fmt. Println("Accesso a un campo di valore", instance.field2)

Questo emette il campo2 dell'istanza struct istanziata.

Assegnazione di metodi a struct

Le funzioni (metodi) vengono assegnate ai tipi struct specificando un nome del ricevitore e il nome dello struct prima del nome della funzione, come mostrato nella sintassi seguente.

funz(StructName ricevente)nomefunzione() {
// del codice
}

Il metodo nomefunzione può essere utilizzato solo sul tipo di struttura specificato.

Implementazione dell'ereditarietà in Go

L'eredità è la capacità di oggetti e tipi di accedere e utilizzare metodi e attributi di altri oggetti. Go non ha Ereditarietà come funzionalità, ma puoi usare le composizioni. In Go, la composizione implica fare riferimento a una superstruttura (la struttura da ereditare) in una sottostruttura fornendo il nome della superstruttura alla sottostruttura.

Usando l'esempio struct sopra:

genere Utente struttura {
 campo1 corda
 campo2 int
 campoMap carta geografica[corda]int
}
genere Utente2 struttura {
 Utente
}

Passando il Utente struct nome nel Utente2 struttura, il Utente2 struct può accedere a tutti i metodi e agli attributi di Utente struct sull'istanziazione tranne per l'impiego di tecniche di astrazione.

figlio := Utente2{
 Utente{
 campo1: "bambino",
 campo2: 0,
 mappa del campo: zero,
 },
 }
fmt. Println (son.field2)

Il figlio la variabile sopra è un'istanza di Utente2 struttura Come si vede nell'esempio, il figlio la variabile può accedere e creare un'istanza di valori del tipo Utente e utilizzarli.

Incapsulamento dei campi di tipo in Go

L'incapsulamento, noto anche come "nascondere le informazioni", è a tecnica di raggruppare i metodi e gli attributi di un oggetto in unità per limitare l'uso e l'accesso se non specificato (abilitazione dei privilegi di lettura/scrittura).

L'incapsulamento è implementato in Go utilizzando identificatori esportati e non esportati nei pacchetti.

Identificatori esportati (lettura e scrittura)

Gli identificatori esportati vengono esportati dai pacchetti definiti e l'accesso ad altri programmi. La capitalizzazione di un identificatore di campo esporta il campo fo.

genere Utente struttura {
 Campo 1 corda
 Campo2 int
 Mappa di campo carta geografica[corda]int
}
genere Utente2 struttura {
 Utente
}

Identificatori non esportati (sola lettura)

Gli identificatori non esportati non vengono esportati dal pacchetto definito e sono convenzionalmente minuscoli.

genere Utente struttura {
 campo1 corda
 campo2 int
 campoMap carta geografica[corda]int
}
genere Utente2 struttura {
 Utente
}

Il concetto di identificatori esportati e non esportati si applica anche ai metodi di un oggetto.

Polimorfismo in Go

Il polimorfismo è una tecnica utilizzata per dare forme diverse a un oggetto per la flessibilità.

Go implementa il polimorfismo usando le interfacce. Le interfacce sono tipi personalizzati utilizzati per definire le firme dei metodi.

Dichiarazione di interfacce

La dichiarazione di interfacce è simile alla dichiarazione di struct. Tuttavia, le interfacce vengono dichiarate utilizzando il interfaccia parola chiave.

genere NomeInterfaccia interfaccia{
//alcuni metodi
}

Le dichiarazioni di interfaccia contengono metodi che devono essere implementati dai tipi struct.

Implementazione di interfacce in struct

I tipi che implementano l'interfaccia devono essere dichiarati dopodiché i metodi del tipo implementano l'interfaccia.

// L'interfaccia
genere Colore interfaccia{
 Colore() corda
}
// Dichiarazione degli struct
genere Verde struttura {
// del codice specifico per la struttura
}
genere Blu struttura {
// un codice specifico
}

Il frammento di codice sopra ha a Colore interfaccia dichiarata con a Colore metodo che deve essere implementato dal Verde e Blu tipi di struttura.

Le interfacce vengono implementate assegnando metodi ai tipi struct e quindi denominando il metodo in base al metodo di interfaccia da implementare.

funz(g Verde)Colore()corda {
Restituzione "verniciato verde"
}
funz(b Blu)Colore()corda {
Restituzione "dipinto di blu"
}

Il metodo Paint è implementato dai tipi Green e Blue che ora possono chiamare e utilizzare il Colore metodo.

pennello := Verde{}
fmt. Println (pennello. Colore())

"Verniciato di verde" viene stampato sulla console per confermare che l'interfaccia è stata implementata con successo.

Campi di astrazione in Go

L'astrazione è il processo di nascondere metodi e attributi non importanti di un tipo, rendendo più facile proteggere parti del programma da usi anormali e non intenzionali.

Go non ha l'astrazione implementata subito; tuttavia, puoi procedere attraverso l'implementazione dell'astrazione usando le interfacce.

// gli umani possono correre
genere Umano interfaccia {
 correre() corda
}
// Il ragazzo è un umano con le gambe
genere Ragazzo struttura {
 Gambe corda
}
// un metodo su boy implementa il metodo run dell'interfaccia umana
funz(h ragazzo)correre()corda {
Restituzione h. Gambe
}

Il codice sopra crea un Umano interfaccia con a correre interfaccia che restituisce una stringa. Il Ragazzo tipo implementa il correre metodo del Umano interfaccia e restituisce una stringa sull'istanza.

Uno dei modi per implementare l'astrazione è fare in modo che uno struct erediti l'interfaccia i cui metodi devono essere astratti. Ci sono molti altri approcci, ma questo è il più semplice.

genere Persona struttura {
 Nome corda
 Età int
 Stato umano 
}
funzprincipale() {
 persona1 := &Ragazzo{Gambe: "due gambe"}
 persona2 := &Persona{ // istanza di una persona
 Nome: "amina",
 Età: 19,
 Stato: persona1,
 }
 fmt. Println (persona. Stato.run()) 
}

Il Persona struct eredita il Umano interfaccia e può accedere a tutti i suoi metodi utilizzando la variabile Stato ereditare l'interfaccia.

Su un'istanza per riferimento (utilizzando un puntatore), l'istanza di Persona struttura Persona2 fa riferimento a un'istanza di Ragazzo struttura Persona1 e ottiene l'accesso ai metodi.

In questo modo, puoi specificare metodi specifici che devono essere implementati dal tipo.

OOP vs Programmazione Funzionale

La programmazione orientata agli oggetti è un paradigma importante in quanto ti dà un maggiore controllo del tuo programma e incoraggia il riutilizzo del codice in modi che la programmazione funzionale non fa.

Ciò non rende la programmazione funzionale una cattiva scelta, poiché la programmazione funzionale può essere utile e migliore per alcuni casi d'uso.

Che cos'è la programmazione orientata agli oggetti? Le basi spiegate in termini di Layman

Leggi Avanti

Circa l'autore