Ist das Überschreiben konkreter Methoden ein Codegeruch?

Stimmt es, dass das Überschreiben konkreter Methoden ein Codegeruch ist? Weil ich denke, wenn Sie konkrete Methoden überschreiben müssen:

public class A{
    public void a(){
    }
}

public class B extends A{
    @Override
    public void a(){
    }
}

es kann umgeschrieben werden als

public interface A{
    public void a();
}

public class ConcreteA implements A{
    public void a();
}

public class B implements A{
    public void a(){
    }
}

und wenn B ein () in A wiederverwenden möchte, kann es wie folgt umgeschrieben werden:

public class B implements A{
    public ConcreteA concreteA;
    public void a(){
        concreteA.a();
    }
}

Wofür ist keine Vererbung erforderlich, um die Methode zu überschreiben?

Nein, es ist kein Codegeruch.

• Wenn eine Klasse nicht endgültig ist, kann sie in Unterklassen unterteilt werden.
• Wenn eine Methode nicht endgültig ist, kann sie überschrieben werden.

Es liegt in der Verantwortung jeder Klasse, sorgfältig zu prüfen, ob eine Unterklasse angemessen ist und welche Methoden möglicherweise überschrieben werden .

Die Klasse kann sich selbst oder eine Methode als endgültig definieren oder Einschränkungen (Sichtbarkeitsmodifikatoren, verfügbare Konstruktoren) dahingehend festlegen, wie und wo sie Unterklassen aufweist.

Der übliche Fall für das Überschreiben von Methoden ist eine Standardimplementierung in der Basisklasse, die in der Unterklasse angepasst oder optimiert werden kann (insbesondere in Java 8 mit dem Aufkommen von Standardmethoden in Schnittstellen).

class A {
    public String getDescription(Element e) {
        // return default description for element
    }
}

class B extends A {
    public String getDescription(Element e) {
        // return customized description for element
    }
}

Eine Alternative zum Überschreiben von Verhalten ist das Strategy Pattern , bei dem das Verhalten als Schnittstelle abstrahiert wird und die Implementierung in der Klasse festgelegt werden kann.

interface DescriptionProvider {
    String getDescription(Element e);
}

class A {
    private DescriptionProvider provider=new DefaultDescriptionProvider();

    public final String getDescription(Element e) {
       return provider.getDescription(e);
    }

    public final void setDescriptionProvider(@NotNull DescriptionProvider provider) {
        this.provider=provider;
    }
}

class B extends A {
    public B() {
        setDescriptionProvider(new CustomDescriptionProvider());
    }
}

Stimmt es, dass das Überschreiben konkreter Methoden ein Codegeruch ist?

Ja, im Allgemeinen ist das Überschreiben konkreter Methoden ein Codegeruch.

Da mit der Basismethode ein Verhalten verbunden ist, das Entwickler normalerweise respektieren, führt eine Änderung zu Fehlern, wenn Ihre Implementierung etwas anderes ausführt. Schlimmer noch, wenn sie das Verhalten ändern, kann Ihre zuvor korrekte Implementierung das Problem verschlimmern. Und im Allgemeinen ist es ziemlich schwierig, das Liskov-Substitutionsprinzip für nicht-triviale konkrete Methoden zu respektieren .

Jetzt gibt es Fälle, in denen dies möglich und sinnvoll ist. Semi-triviale Methoden können einigermaßen sicher übersteuert werden. Basismethoden , die nur als „gesund default“ Art von Verhalten gibt , die ist gemeint sein übergangen haben einige gute Anwendungen.

Daher scheint mir das ein Geruch zu sein - manchmal gut, normalerweise schlecht, schauen Sie, um sicherzugehen.

Wenn Sie konkrete Methoden überschreiben müssen, [...] kann dies als "" umgeschrieben werden

Wenn es auf diese Weise umgeschrieben werden kann, haben Sie die Kontrolle über beide Klassen. Aber dann wissen Sie, ob Sie Klasse A so entworfen haben und wenn ja, ist es kein Codegeruch.

Wenn Sie andererseits keine Kontrolle über die Basisklasse haben, können Sie nicht auf diese Weise neu schreiben. Entweder wurde die Klasse so entworfen, dass sie auf diese Weise abgeleitet wird. In diesem Fall handelt es sich nicht um einen Codegeruch. In diesem Fall haben Sie zwei Möglichkeiten: Suchen Sie nach einer anderen Lösung oder gehen Sie trotzdem vor , weil das Arbeiten die Reinheit des Designs übertrumpft.

Lassen Sie mich zunächst darauf hinweisen, dass diese Frage nur in bestimmten Schreibsystemen anwendbar ist. Zum Beispiel in Structural Typing- und Duck-Typing- Systemen - eine Klasse mit einer Methode mit demselben Namen und derselben Signatur würde bedeuten, dass die Klasse typkompatibel ist (zumindest für diese bestimmte Methode im Fall von Duck-Typing).

Dies unterscheidet sich (offensichtlich) stark vom Bereich statisch typisierter Sprachen wie Java, C ++ usw. sowie von der Art der starken Typisierung , wie sie sowohl in Java und C ++ als auch in C # und anderen verwendet wird.

Ich vermute, Sie kommen aus einem Java-Hintergrund, in dem Methoden explizit als endgültig markiert werden müssen, wenn der Vertragsgestalter beabsichtigt, dass sie nicht überschrieben werden. In Sprachen wie C # ist jedoch das Gegenteil der Standard. Methoden werden (ohne Dekoration, spezielle Schlüsselwörter) " versiegelt " (C # -Version von final) und müssen explizit deklariert werden, als virtualob sie überschrieben werden dürfen .

Wenn eine API oder Bibliothek in diesen Sprachen mit einer konkreten Methode entworfen wurde, die überschrieben werden kann, muss dies (zumindest in einigen Fällen) sinnvoll sein, damit sie überschrieben wird. Daher ist es kein Codegeruch, eine nicht versiegelte / virtuelle / nicht finalkonkrete Methode zu überschreiben .     _{(Dies setzt natürlich voraus, dass die Designer der API Konventionen befolgen und entweder als virtual(C #) oder als final(Java) die geeigneten Methoden für das, was sie entwerfen , markieren .)}

Siehe auch

• Strukturtypsystem
• Ente tippen
• Statische Eingabe
• Starkes Tippen
• Liskov-Substitutionsprinzip

Ja, das liegt daran, dass es zu einem Super- Anti-Pattern kommen kann. Es kann auch den ursprünglichen Zweck der Methode denaturieren, Nebenwirkungen hervorrufen (=> Bugs) und Tests zum Scheitern bringen. Würden Sie eine Klasse verwenden, deren Unit-Tests rot (failling) sind? Werde ich nicht.

Ich gehe noch weiter und sage, der anfängliche Codegeruch ist, wenn eine Methode weder abstractnoch ist final. Weil es erlaubt, das Verhalten einer konstruierten Entität (durch Überschreiben) zu ändern (dieses Verhalten kann verloren gehen oder geändert werden). Mit abstractund finaldie Absicht ist eindeutig:

• Abstract: Sie müssen ein Verhalten angeben
• Final: Sie dürfen das Verhalten nicht ändern

Der sicherste Weg, einer vorhandenen Klasse Verhalten hinzuzufügen, ist das, was Ihr letztes Beispiel zeigt: das Dekorationsmuster verwenden.

public interface A{
    void a();
}

public final class ConcreteA implements A{
    public void a() {
        ...
    }
}

public final class B implements A{
    private final ConcreteA concreteA;
    public void a(){
        //Additionnal behaviour
        concreteA.a();
    }
}