Beseitigt der Einbettungsansatz von Go das Problem der fragilen Basisklasse?

Fragile Base Class-Problem in Go: Ein subtiler Unterschied

Obwohl Komposition über Vererbung als Designprinzip steht, bleibt die Frage bestehen: Funktioniert das? Gibt es in Go ein Problem mit der fragilen Basisklasse?

Definieren des Problems mit der fragilen Basisklasse

Das Problem mit der fragilen Basisklasse entsteht, wenn eine Änderung in der Basisklasse ihre abgeleiteten Klassen in beeinflusst unbeabsichtigte Wege. Dies ist auf Polymorphismus zurückzuführen, bei dem Methoden in abgeleiteten Klassen diejenigen in der Basisklasse überschreiben können. Wenn die Basisklassenmethode dann geändert wird, kann dies unbeabsichtigt das Verhalten der abgeleiteten Klassen beeinträchtigen.

Gos Perspektive auf das Problem

In Go fehlt Polymorphismus auf den Mangel an virtuellen Methoden. Stattdessen nutzt Go die Einbettung, bei der eine Struktur eine andere Struktur enthalten und direkt auf deren Methoden zugreifen kann. Während dieser Ansatz die direkten Auswirkungen des fragilen Basisklassenproblems beseitigt, führt er eine subtile Nuance ein.

Einbettung und Methodenförderung

Wenn eine Struktur eingebettet ist, werden alle ihre Methoden werden in die umschließende Struktur hochgestuft. Diese Methoden können jedoch in der umschließenden Struktur nicht überschrieben werden. Stattdessen können neue Methoden mit demselben Namen hinzugefügt werden, aber der Aufruf der heraufgestuften Methode innerhalb der eingebetteten Struktur ruft immer noch die ursprüngliche Definition auf.

Ein Beispiel im Kontext

Betrachten wir das folgende Java-Beispiel, das das Problem der fragilen Basisklasse demonstriert:

<code class="java">class Counter {
    int value;
    void inc() { value++; }
    void incBy(int n) { value += n; }
}
class MyCounter extends Counter {
    @Override
    void inc() { incBy(1); }
}</code>

Hier würde das Ändern von Counter.incBy() zum Iterieren und Aufrufen von inc() MyCounter.inc() beschädigen, was zu einem führt Endlosschleife.

In Go würde ein ähnliches Beispiel jedoch aufgrund des fehlenden Polymorphismus nicht zu einem solchen Bruch führen. Die eingebetteten Counter-Methoden können nicht überschrieben werden, daher würde immer die ursprüngliche Counter.Inc()-Methode aufgerufen, unabhängig vom aufrufenden Kontext.

<code class="go">type Counter struct {
    value int
}
func (c *Counter) Inc() { c.value++ }
func (c *Counter) IncBy(n int) { c.value += n }
type MyCounter struct {
    Counter
}
func (m *MyCounter) Inc() { m.IncBy(1) }</code>

In diesem Fall hätte eine Änderung von Counter.IncBy() keine Auswirkungen MyCounter.Inc(), das den Zähler weiterhin um 1 erhöhen würde.

Fazit

Während Go das fragile Basisklassenproblem aufgrund des Fehlens virtueller Methoden entschärft , es beseitigt es nicht vollständig. Die Förderung von Methoden bei der Einbettung führt zu einer differenzierten Form des Themas. Allerdings ist diese Nuance weniger störend und vorhersehbarer als das klassische Problem der fragilen Basisklasse.

Das obige ist der detaillierte Inhalt vonBeseitigt der Einbettungsansatz von Go das Problem der fragilen Basisklasse?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!