Was ist falsch mit überschreibbare Methode aufrufen in Konstruktoren?

Auf überschreibbare Methode aufrufen von Konstruktoren

Einfach ausgedrückt, ist dies falsch, weil es unnötig eröffnet Möglichkeiten zu VIELE bugs. Wenn die @Override aufgerufen wird, wird der Zustand des Objekts kann sein, widersprüchlich und/oder unvollständig sind.

Einem Zitat aus Effektive Java-2. Auflage, Artikel 17: Entwerfen und dokumentieren für die Vererbung oder anderes verbieten es:

Gibt es ein paar Einschränkungen, die einer Klasse müssen befolgt die Vererbung zulassen. Konstruktoren müssen nicht überschreibbaren Methoden aufrufen, direkt oder indirekt. Wenn Sie gegen diese Regel verstoßen, Programm-Fehler führt. Die superclass-Konstruktor ausgeführt wird, bevor der Unterklasse-Konstruktor, so dass das überschreiben der Methode in der Unterklasse aufgerufen, bevor der Konstruktor der Unterklasse ausgeführt wurde. Wenn die überschreibende Methode hängt die Initialisierung erfolgt durch die Unterklasse-Konstruktor, die Methode wird nicht so verhält wie erwartet.

Hier ein Beispiel zur Veranschaulichung:

public class ConstructorCallsOverride {
    public static void main(String[] args) {

        abstract class Base {
            Base() {
                overrideMe();
            }
            abstract void overrideMe(); 
        }

        class Child extends Base {

            final int x;

            Child(int x) {
                this.x = x;
            }

            @Override
            void overrideMe() {
                System.out.println(x);
            }
        }
        new Child(42); //prints "0"
    }
}

Hier, wenn Base Konstruktor ruft overrideMe, Child noch nicht fertig initialisiert die final int x, und die Methode erhält den falschen Wert. Dies führt fast zwangsläufig zu bugs und Fehler.

Fragen

• Aufruf einer Überschriebenen Methode von einer Übergeordneten Klasse Konstruktor
• Status von Objekt Abgeleitete Klasse als Basisklasse Konstruktor ruft die überschriebene Methode in Java
• Über abstrakte init () - Funktion in der abstrakten Klasse einen Konstruktor

Siehe auch

• FindBugs - Lesen von nicht-Initialisierten Feld Methode aufgerufen Konstruktor der Superklasse

Auf Objekt-Konstruktion mit vielen Parametern

Konstruktoren viele Parameter führen zu schlechter Lesbarkeit und bessere alternativen vorhanden sind.

Hier ein Zitat aus Effektive Java, 2nd Edition, Artikel 2: Betrachten Sie ein builder pattern, wenn konfrontiert mit vielen Konstruktor-Parameter:

Traditionell haben die Programmierer verwendet die Teleskop-Konstruktor Muster, in die Sie einen Konstruktor mit nur die erforderlichen Parameter, ein weiterer mit einem einzigen optionalen Parameter, der Dritte mit zwei optionale Parameter, und so weiter...

Den Teleskop-Konstruktor-Muster ist im wesentlichen so etwas wie dieses:

public class Telescope {
    final String name;
    final int levels;
    final boolean isAdjustable;

    public Telescope(String name) {
        this(name, 5);
    }
    public Telescope(String name, int levels) {
        this(name, levels, false);
    }
    public Telescope(String name, int levels, boolean isAdjustable) {       
        this.name = name;
        this.levels = levels;
        this.isAdjustable = isAdjustable;
    }
}

Und jetzt können Sie einen der folgenden Schritte aus:

new Telescope("X/1999");
new Telescope("X/1999", 13);
new Telescope("X/1999", 13, true);

Können Sie jedoch nicht, die derzeit nur die name und isAdjustable, und verlassen levels im Verzug ist. Sie können mehrere Konstruktor-überladungen, aber offensichtlich würde die Zahl explodieren, wie die Anzahl der Parameter, die wachsen, und Sie können sogar mehrere boolean und int Argumente, die würden das wirklich machen ein Durcheinander von Dingen.

Wie Sie sehen können, ist dies nicht eine angenehme Muster zu schreiben, und noch weniger angenehm zu bedienen ist (Was bedeutet "das wahre" hier bedeuten? Was ist 13?).

Bloch empfiehlt die Verwendung eines builder-Muster, die es erlauben würde, Sie zu schreiben, so etwas wie dies:

Telescope telly = new Telescope.Builder("X/1999").setAdjustable(true).build();

Beachten Sie, dass die Parameter benannt sind, und Sie können Sie in beliebiger Reihenfolge Sie wollen, und Sie können überspringen diejenigen, die Sie behalten möchten, auf default-Werte. Dies ist sicherlich viel besser als Teleskop-Konstruktoren, vor allem, wenn es eine große Anzahl von Parametern, gehören viele der gleichen Arten.

Siehe auch

• Wikipedia/Builder pattern
• Effektive Java, 2nd Edition, Artikel 2: Betrachten Sie ein builder pattern, wenn konfrontiert mit vielen Konstruktor-Parameter (Auszug online)

Fragen

• Bei der würden Sie das Builder-Pattern?
• Ist dies ein bekanntes design-pattern? Was ist sein name?

InformationsquelleAutor polygenelubricants

Aufruf einer überschreibbaren Methode im Konstruktor ermöglicht es Unterklassen zu unterlaufen, den code, Sie können also nicht garantieren, dass es nicht mehr arbeitet. Das ist, warum Sie eine Verwarnung bekommen.

In deinem Beispiel, was passiert, wenn eine Unterklasse überschreibt getTitle() und gibt null zurück ?

Zu "reparieren", können Sie verwenden eine die factory-Methode statt eines Konstruktors, es ist ein gemeinsames Muster von Objekten der Instanziierungen.

InformationsquelleAutor KeatsPeeks

Hier ist ein Beispiel, das zeigt der logische Probleme, die auftreten können, wenn der Aufruf einer überschreibbaren Methode in der super-Konstruktor.

class A {

    protected int minWeeklySalary;
    protected int maxWeeklySalary;

    protected static final int MIN = 1000;
    protected static final int MAX = 2000;

    public A() {
        setSalaryRange();
    }

    protected void setSalaryRange() {
        throw new RuntimeException("not implemented");
    }

    public void pr() {
        System.out.println("minWeeklySalary: " + minWeeklySalary);
        System.out.println("maxWeeklySalary: " + maxWeeklySalary);
    }
}

class B extends A {

    private int factor = 1;

    public B(int _factor) {
        this.factor = _factor;
    }

    @Override
    protected void setSalaryRange() {
        this.minWeeklySalary = MIN * this.factor;
        this.maxWeeklySalary = MAX * this.factor;
    }
}

public static void main(String[] args) {
    B b = new B(2);
    b.pr();
}

Das Ergebnis wäre eigentlich:

minWeeklySalary: 0

maxWeeklySalary: 0

Dies ist der Konstruktor der Klasse B ruft zunächst den Konstruktor der Klasse A, wo die überschreibbare Methode in B ausgeführt. Aber innerhalb der Methode verwenden wir die Instanz-variable Faktor die noch nicht initialisiert (da der Konstruktor der Eine noch nicht fertig), also Faktor ist 0 und nicht 1 ist, und definitiv nicht 2 (die Sache, die der Programmierer könnte denken, es wird sein). Vorstellen, wie schwer würde es sein, zu verfolgen ist ein Fehler, wenn die Berechnung Logik war zehn mal mehr verdreht.

Ich hoffe, dass jemand helfen würde.

InformationsquelleAutor kirilv

Denke ich, Wicket, es ist besser, rufen Sie add Methode in der onInitialize() (siehe Komponenten-Lebenszyklus) :

public abstract class BasicPage extends WebPage {

    public BasicPage() {
    }

    @Override
    public void onInitialize() {
        add(new Label("title", getTitle()));
    }

    protected abstract String getTitle();
}

InformationsquelleAutor sanluck