Golang n'a pas de classe

Objets et classes en langage Go

Parmi de nombreux langages de programmation, la programmation orientée objet (POO) est un paradigme de programmation populaire qui crée de la modularité en regroupant les données et les méthodes, du code réutilisable. Dans les langages POO traditionnels (tels que Java, C++, etc.), les classes sont l'un des concepts fondamentaux de la POO. Des fonctionnalités telles que l'encapsulation, l'héritage et le polymorphisme peuvent être obtenues via des classes. Mais dans le langage Go, il n'y a pas de mot-clé de classe, et la POO en langage Go est différente du langage POO traditionnel à bien des égards.

Orienté objet en langage Go

En langage Go, l'implémentation orientée objet est principalement implémentée via des structures (Structs) et des méthodes (Methods). Ces méthodes peuvent être associées à des structures pour former un objet. Dans le langage Go, les structures sont définies de la même manière et peuvent également contenir des variables membres et des méthodes membres.

Une structure Go simple est définie comme suit :

type Person struct {
    Name    string
    Age     int
    Address string
}

Dans cet exemple, nous définissons une structure nommée Personne, qui contient trois champs : Nom, Âge et Adresse. Les variables membres de cette structure sont accessibles via la syntaxe ".", par exemple :

var person Person
person.Name = "Tom"
person.Age = 20
person.Address = "New York"

De cette façon, nous créons une instance nommée personne, et les champs qu'elle contient sont accessibles via ".".

Grâce à la structure, nous pouvons définir les attributs (variables membres) de l'instance, mais comment faire fonctionner l'instance ? Dans le langage Go, vous pouvez définir des méthodes pour une structure et exploiter les variables membres de la structure au sein de la méthode.

Une méthode Go simple est définie comme suit :

func (p *Person) GetAge() int {
    return p.Age
}

Dans cet exemple, nous définissons une méthode appelée GetAge, qui renvoie l'âge (Age) de l'instance de structure actuelle. Il est à noter que cette méthode utilise un récepteur de type pointeur, ce qui signifie qu'il peut modifier les propriétés de l'instance de structure.

Création et utilisation d'objets

La façon dont les objets sont créés dans le langage Go est également différente des autres langages POO. Dans les langages POO traditionnels, nous pouvons créer des objets via des mots-clés tels que « nouveau » ou « constructeur ». Mais en langage Go, il suffit de créer une instance via la définition de la structure, puis de transmettre le pointeur de l'instance à la méthode pour l'opération.

Un exemple simple de création et d'utilisation d'objets Go est le suivant :

var person *Person = new(Person)
person.Name = "Tom"
person.Age = 20
person.Address = "New York"
fmt.Println("The age of person is", person.GetAge()) // 输出 The age of person is 20

Dans cet exemple, nous créons d'abord une instance nommée person via la fonction new(), puis définissons ses propriétés. Enfin, nous appelons la méthode GetAge() de la personne pour obtenir son âge.

A noter qu'en langage Go, vous pouvez utiliser l'opérateur "&" pour obtenir le pointeur d'une variable, par exemple :

var person Person
var p *Person = &person

Ici, on définit d'abord une instance de structure nommée personne, puis on utilise "&" L'opérateur obtient son pointeur et attribue le pointeur à la variable p. Vous pouvez également utiliser directement l'opérateur "&" pour obtenir le pointeur d'une instance de structure nouvellement créée, par exemple :

var p *Person = &Person{}

De cette façon, nous créons un objet Person nommé p et attribuons son pointeur à la variable p.

Héritage et polymorphisme

Dans les langages POO traditionnels, l'héritage et le polymorphisme sont deux caractéristiques très importantes. Ils peuvent grandement améliorer la réutilisabilité et la flexibilité du code. Cependant, dans le langage Go, puisqu'il n'y a pas de mot-clé de classe, l'implémentation de l'héritage et du polymorphisme est quelque peu différente.

En langage Go, l'héritage est implémenté via "Embedded Struct". Ceci est très similaire à l'héritage dans le langage Java, mais contrairement à Java, la structure imbriquée dans le langage Go n'hérite pas par défaut de tous les membres de la structure parent.

Un exemple de structure imbriquée Go simple est le suivant :

type Driver struct {
    Name string
}

type Car struct {
    *Driver
    Brand string
}

func (d *Driver) Drive() {
    fmt.Println(d.Name, "is driving")
}

func main() {
    var john *Driver = &Driver{Name: "John"}
    var benz *Car = &Car{Driver: john, Brand: "Benz"}
    benz.Drive() // 输出 John is driving
}

Dans cet exemple, nous définissons une structure nommée Driver et une structure nommée Car, avec Driver imbriqué dans Car. La structure Driver possède une méthode appelée Drive, qui est utilisée pour afficher le nom du pilote. Nous pouvons voir que le Driver est imbriqué dans la Car et que la méthode Driver's Drive peut être appelée via l'instance Car. Cela implémente un héritage simple.

Dans le langage Go, le polymorphisme peut être implémenté à l'aide de la méthode "Interface". Différent des langages POO traditionnels tels que Java, l'implémentation de l'interface est définie par le mot-clé "implements" (comme le mot-clé "implements" en Java), qui est implémenté implicitement dans le langage Go. Il vous suffit de définir un ensemble de méthodes. Tant que le type qui implémente cet ensemble de méthodes peut implémenter l'interface, il n'est pas nécessaire de déclarer explicitement qu'il implémente l'interface.

Un exemple d'interface Go simple est le suivant :

type Animal interface {
    Speak() string
}

type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

type Cat struct{}

func (c Cat) Speak() string {
    return "Meow!"
}

func main() {
    var animal Animal = Dog{}
    fmt.Println(animal.Speak()) // 输出 Woof!
    animal = Cat{}
    fmt.Println(animal.Speak()) // 输出 Meow!
}

Dans cet exemple, nous définissons une interface nommée Animal et une méthode nommée Speak dedans. Nous avons également créé deux types, Dog et Cat, qui implémentent tous deux l'interface Animal. Enfin, nous utilisons la nature dynamique de l'interface animale, l'attribuons à des instances de types Chien et Chat et appelons leurs méthodes Speak correspondantes. Comme vous pouvez le voir, grâce à l'interface, nous avons réalisé un polymorphisme simple.

Résumé

Bien qu'il n'y ait pas de mot-clé de classe dans le langage Go, grâce à la combinaison de structures et de méthodes, nous pouvons également réaliser une programmation orientée objet, incluant des fonctionnalités telles que l'encapsulation, l'héritage et le polymorphisme. Et comme il n’y a pas de complexité de classes, la programmation orientée objet en langage Go est plus concise et flexible. Dans le même temps, le langage Go fournit également des fonctionnalités telles qu'une interface et une structure intégrée pour implémenter le polymorphisme et l'héritage. Ces fonctionnalités permettent au langage Go de conserver la simplicité et l'efficacité du langage tout en implémentant la POO.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!