** Addenda ** Pas orienté objet en langage Go, c'est orienté objet comme Go! Il semble y avoir un mauvais mot J'ai reçu diverses suggestions dans la section des commentaires, donc j'apprécierais que vous puissiez les vérifier.
J'ai rejoint Dip Co., Ltd. à mi-chemin et j'ai créé une API en langage Go. Jusqu'à présent, je parlais tous les jours de langages orientés objet comme PHP et Ruby.
Malgré tout, j'ai eu l'occasion de profiter de mon expérience professionnelle antérieure. Cette fois, j'aimerais parler de "J'ai fait du bien à la source du langage Go en utilisant mon expérience de travail antérieure."
Comme le sait tous ceux qui s'occupent du langage Go, il n'y a pas d'orientation objet dans le langage Go. Il n'y a pas de classes, pas d'héritage, pas de constructeurs. La pensée d'objet (pas de fautes de frappe) que j'ai cultivée jusqu'à présent est comme une poubelle.
Si vous voulez l'implémenter dans Go, vous devez l'implémenter docilement comme Go, mais même ainsi, l'idée que «si c'est orienté objet, il devrait être implémenté comme ça» est écrasante. Lorsque j'ai cherché longtemps sur le net, j'ai trouvé "comment faire des choses orientées objet en langage Go". J'ai fait une belle implémentation en référence à eux, donc je vais le résumer avec un échantillon.
Il y a différentes choses qui sont orientées objet, mais cette fois nous viserons ce domaine.
package main
import (
"fmt"
)
const line = "--------------------"
func main() {
wiz := newWizard("Fille magique", 10, 10, 5)
war := newWarrior("+‡ † Berserker † ‡+", 10, 15, 30)
fmt.Println(wiz.hello())
fmt.Println(war.hello())
fmt.Println(line)
fmt.Println(wiz.attack())
fmt.Println(war.attack())
fmt.Println(line)
fmt.Println(wiz.magic())
fmt.Println(war.attack())
}
type human struct {
name string
hp int
ap int
}
func (h *human) init(name string, hp, ap int) {
h.name = name
h.hp = hp
h.ap = ap
}
func (h *human) hello() string {
return fmt.Sprintf("Bonjour, je%s.", h.name)
}
func (h *human) attack() string {
return fmt.Sprintf("%s attaque!%dommage!", h.name, h.ap)
}
type wizard struct {
human
mp int
}
func newWizard(name string, hp, ap, mp int) *wizard {
w := new(wizard)
w.init(name, hp, ap)
w.mp = mp
return w
}
func (w *wizard) magic() string {
if w.mp <= 0 {
return fmt.Sprintf("%s n'a pas de pouvoir", w.name)
}
w.mp -= 1
return fmt.Sprintf("%s utilisé la magie! 30 dégâts!", w.name)
}
type warrior struct {
human
}
func newWarrior(name string, hp, ap, mp int) *warrior {
w := new(warrior)
w.init(name, hp, ap)
return w
}
func (w *warrior) attack() string {
return fmt.Sprintf("%s attaque!%dommage!", w.name, w.ap*2)
}
Résultat d'exécution
Bonjour, je suis une fille magique.
Bonjour, je+‡ † Berserker † ‡+est.
--------------------
Attaque de fille magique! 10 dégâts!
+‡ † Berserker † ‡+Attaque! 30 dégâts!
--------------------
La fille magique a utilisé la magie! 30 dégâts!
+‡ † Berserker † ‡+Attaque! 30 dégâts!
Homme professionnel de RPG commun
type human struct {
name string
hp int
ap int
}
Définir les propriétés communes
func (h *human) init(name string, hp, ap int) {
h.name = name
h.hp = hp
h.ap = ap
}
Il n'y a pas de structure dans Go, vous pouvez donc définir n'importe quelle méthode qui fait le travail du constructeur. Je le nomme ici, mais tout va bien
func (h *human) hello() string {
return fmt.Sprintf("Bonjour, je%s.", h.name)
}
func (h *human) attack() string {
return fmt.Sprintf("%s attaque!%dommage!", h.name, h.ap)
}
type wizard struct {
human
mp int
}
type warrior struct {
human
}
En spécifiant la classe parent (structure), les propriétés et méthodes définies dans la classe parent (structure) peuvent être incluses (non héritées). Petite classe (structure) Si vous souhaitez augmenter les propriétés par vous-même, vous pouvez continuer à décrire (avant ou après)
func newWizard(name string, hp, ap, mp int) *wizard {
w := new(wizard)
w.init(name, hp, ap)
w.mp = mp
return w
}
func newWarrior(name string, hp, ap, mp int) *warrior {
w := new(warrior)
w.init(name, hp, ap)
return w
}
Créez une instance de la classe parent (structure) et appelez le constructeur. Si vous souhaitez rendre les paramètres initiaux uniques à la classe enfant (structure), décrivez-les successivement.
func (w *wizard) magic() string {
if w.mp <= 0 {
return fmt.Sprintf("%s n'a pas de pouvoir", w.name)
}
w.mp -= 1
return fmt.Sprintf("%s utilisé la magie! 30 dégâts!", w.name)
}
Il est également possible de générer une méthode dédiée à une petite classe (structure)
func (w *warrior) smash() string {
return fmt.Sprintf("%Forte attaque de s!%dommage!", w.name, w.ap*2)
}
Vous pouvez créer votre propre comportement en définissant une méthode du même nom.
func main() {
wiz := newWizard("Fille magique", 10, 10, 5)
war := newWarrior("+‡ † Berserker † ‡+", 10, 15, 30)
fmt.Println(wiz.hello())
fmt.Println(war.hello())
fmt.Println(line)
fmt.Println(wiz.attack())
fmt.Println(war.attack())
fmt.Println(line)
fmt.Println(wiz.magic())
fmt.Println(war.smash())
}
Créez une instance en appelant la fabrique de la classe enfant (structure) sans vous soucier de la classe parent (structure). Profitez en appelant des méthodes courantes ou des méthodes uniques.
Vous pouvez même utiliser le langage Go! Et une bonne sensation. La mise en œuvre est devenue simple. Je pense qu'il vaut mieux l'utiliser dans la mesure où le traitement n'est pas compliqué.
Je suis sûr que j'ai récupéré des informations dans de nombreux articles et sites et les ai implémentées, mais lorsque j'ai initialisé mon PC, j'ai oublié l'URL. Nous nous excusons et vous remercions, et notons que ce n'est pas un article complètement original. Tout le monde sauvegarde fréquemment.
Recommended Posts