** Nachtrag ** Nicht objektorientiert in der Go-Sprache, sondern Go-like objektorientiert! Es scheint ein schlechtes Wort zu geben Ich habe im Kommentarbereich verschiedene Vorschläge erhalten, daher würde ich mich freuen, wenn Sie sie überprüfen könnten.
Ich bin auf halbem Weg zu Dip Co., Ltd. gekommen und habe API in Go-Sprache erstellt. Bis jetzt habe ich jeden Tag über lose objektorientierte Sprachen wie PHP und Ruby gesprochen.
Trotzdem hatte ich die Möglichkeit, meine bisherigen Arbeitserfahrungen zu nutzen. Dieses Mal möchte ich über "Ich habe dafür gesorgt, dass sich die Quelle der Go-Sprache gut anfühlt, indem ich meine früheren Arbeitserfahrungen genutzt habe."
Wie jeder weiß, der mit der Go-Sprache arbeitet, gibt es in der Go-Sprache keine Objektorientierung. Es gibt keine Klassen, keine Vererbung, keine Konstruktoren. Das Objektdenken (keine Tippfehler), das ich bisher kultiviert habe, ist wie Müll.
Wenn Sie es in Go implementieren möchten, sollten Sie es gehorsam wie Go implementieren, aber dennoch ist die Idee, dass "wenn dies objektorientiert ist, sollte es so implementiert werden", überwältigend. Als ich lange im Internet gesucht habe, habe ich einige "Möglichkeiten gefunden, objektorientierte Dinge in der Go-Sprache zu tun". Ich habe eine schöne Implementierung in Bezug auf sie gemacht, daher werde ich sie mit einem Beispiel zusammenfassen.
Es gibt verschiedene Dinge, die objektorientiert sind, aber dieses Mal werden wir diesen Bereich anstreben.
package main
import (
"fmt"
)
const line = "--------------------"
func main() {
wiz := newWizard("Magisches Mädchen", 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("Hallo ich%s.", h.name)
}
func (h *human) attack() string {
return fmt.Sprintf("%s Angriff!%d Schaden!", 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 hat keine Macht", w.name)
}
w.mp -= 1
return fmt.Sprintf("%s benutzte Magie! 30 Schaden!", 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 Angriff!%d Schaden!", w.name, w.ap*2)
}
Ausführungsergebnis
Hallo, ich bin ein magisches Mädchen.
Hallo ich+‡†Berserker†‡+ist.
--------------------
Magischer Mädchenangriff! 10 Schaden!
+‡†Berserker†‡+Attacke! 30 Schaden!
--------------------
Das magische Mädchen benutzte Magie! 30 Schaden!
+‡†Berserker†‡+Attacke! 30 Schaden!
Gewöhnlicher RPG-Profi
type human struct {
name string
hp int
ap int
}
Definieren Sie gemeinsame Eigenschaften
func (h *human) init(name string, hp, ap int) {
h.name = name
h.hp = hp
h.ap = ap
}
In Go gibt es keine Struktur, sodass Sie jede Methode definieren können, die die Arbeit des Konstruktors erledigt. Ich nenne es hier "init", aber alles ist in Ordnung
func (h *human) hello() string {
return fmt.Sprintf("Hallo ich%s.", h.name)
}
func (h *human) attack() string {
return fmt.Sprintf("%s Angriff!%d Schaden!", h.name, h.ap)
}
type wizard struct {
human
mp int
}
type warrior struct {
human
}
Durch Angabe der übergeordneten Klasse (Struktur) können die in der übergeordneten Klasse (Struktur) definierten Eigenschaften und Methoden einbezogen (nicht vererbt) werden. Kleine Klasse (Struktur) Wenn Sie die Eigenschaften selbst erhöhen möchten, können Sie weiter beschreiben (vorher oder nachher)
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
}
Erstellen Sie eine Instanz der übergeordneten Klasse (Struktur) und rufen Sie den Konstruktor auf. Wenn Sie die Anfangseinstellungen für die untergeordnete Klasse (Struktur) eindeutig festlegen möchten, beschreiben Sie sie nacheinander.
func (w *wizard) magic() string {
if w.mp <= 0 {
return fmt.Sprintf("%s hat keine Macht", w.name)
}
w.mp -= 1
return fmt.Sprintf("%s benutzte Magie! 30 Schaden!", w.name)
}
Es ist auch möglich, eine Methode zu generieren, die einer kleinen Klasse (Struktur) gewidmet ist.
func (w *warrior) smash() string {
return fmt.Sprintf("%Starker Angriff von s!%d Schaden!", w.name, w.ap*2)
}
Sie können Ihr eigenes Verhalten festlegen, indem Sie eine Methode mit demselben Namen definieren.
func main() {
wiz := newWizard("Magisches Mädchen", 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())
}
Erstellen Sie eine Instanz, indem Sie die Factory der untergeordneten Klasse (Struktur) aufrufen, ohne sich um die übergeordnete Klasse (Struktur) kümmern zu müssen. Genießen Sie es, indem Sie gängige Methoden oder einzigartige Methoden aufrufen.
Sie können sogar mit Go-Sprache gehen! Und ein gutes Gefühl. Die Implementierung ist einfach geworden. Ich denke, es ist eine Ameise, es in dem Maße zu verwenden, in dem die Verarbeitung nicht kompliziert ist.
Ich bin sicher, ich habe Informationen aus vielen Artikeln und Websites aufgenommen und implementiert, aber als ich meinen PC initialisierte, habe ich die URL vergessen. Wir entschuldigen uns und danken Ihnen und stellen fest, dass dies kein vollständig origineller Artikel ist. Jeder sichert häufig.
Recommended Posts