Comment implémenter les concepts de programmation orientée objet dans Go

La programmation orientée objet (POO) est un paradigme de programmation basé sur les objets comme concept central. Dans la POO, le code est formaté en fonction de la fonctionnalité, permettant la maintenance du code, l'abstraction, la réutilisabilité, l'efficacité et de nombreuses fonctionnalités sur l'objet.

L'objet a des attributs (variables) qui définissent ses caractéristiques, propriétés et méthodes (fonctions) qui définissent les actions (procédures) et les comportements de l'objet.

La programmation orientée objet en Go est différente des autres langages. Les concepts orientés objet sont implémentés dans Go à l'aide de structures, d'interfaces et de types personnalisés.

Personnalisation des types dans Go

Les types personnalisés facilitent le regroupement et l'identification de code similaire à réutiliser.

Le code pour déclarer les types personnalisés est :

taper typeName dataType 

Lors de la création d'un type personnalisé et de l'affectation d'une variable, vous pouvez vérifier le type à l'aide de refléter. Type de() qui prend une variable et renvoie le type de la variable.

importer("fmt"
 "refléter")
taper deux entier// crée le type "deux"
var numéro deux // variable de type "deux"
fmt. Println (réfléchir. TypeOf (nombre))

​​​

Le Numéro variable est un type de deux qui est un entier. Vous pouvez aller plus loin pour créer davantage de types personnalisés.

Créer des structures en Go

Les structs (structures) sont les plans de la programmation orientée objet en Go. Les structures sont des collections de champs définies par l'utilisateur.

Une structure peut contenir une variété de types de données, y compris des types composés et des méthodes.

Vous pouvez créer une structure en utilisant cette syntaxe :

taper NomStructure structure {
// un peu de code
}

Classiquement, les noms de structure sont généralement en majuscules et en casse camel pour plus de lisibilité.

Le type struct accepte les noms de champs et les types de données. Les structures peuvent accepter n'importe quel type de données Go, y compris les types personnalisés.

taper Utilisateur structure {
 champ1 corde
 champ2 entier
 champCarte carte[corde]entier
}

Vous pouvez instancier un type de struct en affectant le struct en tant que variable.

instance := Utilisateur{
// un peu de code
}

L'instance de structure peut être remplie avec des champs lors de l'instanciation tels que définis à l'initialisation ou définis sur null.

instance := Utilisateur{
 champ1: "un corde domaine",
 champ2: 10,
 fieldMap: carte[corde]entier{},
 }

Accéder aux éléments de structure

Vous pouvez accéder aux champs d'une instance de struct en utilisant une notation par points pour le champ.

fmt. Println("Accéder à un champ de valeur", instance.field2)

Cela produit le champ2 de l'instance de structure instanciée.

Affectation de méthodes à des structures

Les fonctions (méthodes) sont affectées aux types de structure en spécifiant un nom de récepteur et le nom de la structure avant le nom de la fonction, comme indiqué dans la syntaxe ci-dessous.

fonction(récepteur NomStructure)nom_fonction() {
// un peu de code
}

La méthode nom_fonction ne peut être utilisé que sur le type de structure spécifié.

Implémentation de l'héritage dans Go

L'héritage est la capacité des objets et des types à accéder et à utiliser les méthodes et les attributs d'autres objets. Go n'a pas d'héritage en tant que fonctionnalité, mais vous pouvez utiliser des compositions. Dans Go, la composition implique de faire référence à une superstructure (la structure à hériter) dans une sous-structure en fournissant le nom de la superstructure à la sous-structure.

En utilisant l'exemple de structure ci-dessus :

taper Utilisateur structure {
 champ1 corde
 champ2 entier
 champCarte carte[corde]entier
}
taper Utilisateur2 structure {
 Utilisateur
}

En passant le Utilisateur nom de structure dans le Utilisateur2 structure, la Utilisateur2 struct peut accéder à toutes les méthodes et attributs de la Utilisateur struct sur l'instanciation sauf que des techniques d'abstraction sont employées.

fils := Utilisateur2{
 Utilisateur{
 champ1: "bébé",
 champ2: 0,
 fieldMap: néant,
 },
 }
fmt. Println (son.field2)

Le fils variable ci-dessus est une instanciation de la Utilisateur2 structure. Comme on le voit dans l'exemple, le fils variable peut accéder et instancier des valeurs de type User et les utiliser.

Encapsulation des champs de type dans Go

L'encapsulation, également connue sous le nom de « masquage d'informations », est une technique consistant à regrouper les méthodes et les attributs d'un objet en unités pour restreindre l'utilisation et l'accès sauf indication contraire (activation des privilèges de lecture/écriture).

L'encapsulation est implémentée dans Go à l'aide d'identifiants exportés et non exportés dans les packages.

Identifiants exportés (lecture et écriture)

Les identifiants exportés sont exportés à partir de leurs packages définis et accèdent à d'autres programmes. La mise en majuscule d'un identificateur de champ exporte le champ fo.

taper Utilisateur structure {
 Champ1 corde
 Champ2 entier
 FieldMap carte[corde]entier
}
taper Utilisateur2 structure {
 Utilisateur
}

Identifiants non exportés (lecture seule)

Les identifiants non exportés ne sont pas exportés du package défini et sont généralement en minuscules.

taper Utilisateur structure {
 champ1 corde
 champ2 entier
 champCarte carte[corde]entier
}
taper Utilisateur2 structure {
 Utilisateur
}

Le concept d'identifiants exportés et non exportés s'applique également aux méthodes d'un objet.

Polymorphisme en Go

Le polymorphisme est une technique utilisée pour donner différentes formes à un objet pour plus de flexibilité.

Go implémente le polymorphisme à l'aide d'interfaces. Les interfaces sont des types personnalisés utilisés pour définir des signatures de méthode.

Déclaration des interfaces

La déclaration d'interfaces est similaire à la déclaration de structures. Cependant, les interfaces sont déclarées à l'aide de la interface mot-clé.

taper NomInterface interface{
//quelques méthodes
}

Les déclarations d'interface contiennent des méthodes qui doivent être implémentées par des types de structure.

Implémentation d'interfaces dans des structures

Les types qui implémentent l'interface doivent être déclarés après quoi les méthodes du type implémentent l'interface.

// L'interface
taper Couleur interface{
 Peinture() corde
}
// Déclaration des structures
taper Vert structure {
// un code spécifique à la structure
}
taper Bleu structure {
// un code spécifique
}

L'extrait de code ci-dessus a un Couleur interface déclarée avec un Peinture méthode à mettre en œuvre par le Vert et Bleu types de structure.

Les interfaces sont implémentées en affectant des méthodes aux types de structure, puis en nommant la méthode par la méthode d'interface à implémenter.

fonction(g Vert)Peinture()corde {
retourner "peint en vert"
}
fonction(b Bleu)Peinture()corde {
retourner "peint en bleu"
}

La méthode Paint est implémentée par les types Green et Blue qui peuvent maintenant appeler et utiliser la méthode Peinture méthode.

pinceau := Vert{}
fmt. Println (pinceau. Peinture())

"Painted green" est imprimé sur la console validant que l'interface a été implémentée avec succès.

Champs abstraits dans Go

L'abstraction est le processus de masquage des méthodes et des attributs sans importance d'un type, ce qui facilite la protection de certaines parties du programme contre une utilisation anormale et involontaire.

Go n'a pas mis en œuvre l'abstraction dès le départ; cependant, vous pouvez suivre notre chemin en implémentant l'abstraction à l'aide d'interfaces.

// les humains peuvent courir
taper Humain interface {
 Cours() corde
}
// Le garçon est un humain avec des jambes
taper Garçon structure {
 Jambes corde
}
// une méthode sur boy implémente la méthode run de l'interface Human
fonction(h Garçon)Cours()corde {
retourner h. Jambes
}

Le code ci-dessus crée un Humain s'interfacer avec un Cours interface qui renvoie une chaîne. Le Garçon type implémente le Cours méthode de la Humain interface et renvoie une chaîne lors de l'instanciation.

L'une des façons d'implémenter l'abstraction consiste à faire hériter une structure de l'interface dont les méthodes doivent être abstraites. Il existe de nombreuses autres approches, mais celle-ci est la plus simple.

taper Personne structure {
 Nom corde
 Âge entier
 Statut humain 
}
fonctionprincipale() {
 person1 := &Boy{Jambes: "deux jambes"}
 personne2 := &Personne{ // instance d'une personne
 Nom: "amina",
 Âge: 19,
 Statut: personne1,
 }
 fmt. Println (personne. Statut.run()) 
}

Le Personne structure hérite de la Humain interface et peut accéder à toutes ses méthodes à l'aide de la variable Statut héritant de l'interface.

Lors d'une instanciation par référence (à l'aide d'un pointeur), l'instance de Personne structure Personne2 fait référence à une instance de Garçon structure Personne1 et accède aux méthodes.

De cette façon, vous pouvez spécifier des méthodes spécifiques à implémenter par le type.

POO vs programmation fonctionnelle

La programmation orientée objet est un paradigme important car elle vous donne plus de contrôle sur votre programme et encourage la réutilisation du code contrairement à la programmation fonctionnelle.

Cela ne fait pas de la programmation fonctionnelle un mauvais choix, car la programmation fonctionnelle peut être utile et meilleure pour certains cas d'utilisation.

Qu'est-ce que la programmation orientée objet? Les bases expliquées en termes simples

Lire la suite

A propos de l'auteur