Verwenden des Modifikators "final", wann immer dies in Java anwendbar ist [geschlossen]

In Java gibt es die Praxis, jede Variable (lokal oder Klasse) als Parameter final zu deklarieren, wenn dies tatsächlich der Fall ist.

Dies macht den Code zwar viel ausführlicher, erleichtert jedoch das Lesen / Erfassen des Codes und verhindert Fehler, da die Absicht klar gekennzeichnet ist.

Was denkst du darüber und was folgst du?

Ich denke, das hat alles mit einem guten Codierungsstil zu tun. Natürlich können Sie gute, robuste Programme schreiben, ohne finalirgendwo viele Modifikatoren zu verwenden, aber wenn Sie darüber nachdenken ...

Das Hinzufügen finalzu allen Dingen, die sich nicht ändern sollten, schränkt lediglich die Möglichkeiten ein, dass Sie (oder der nächste Programmierer, der an Ihrem Code arbeitet) den Denkprozess, der zu Ihrem Code geführt hat, falsch interpretieren oder missbrauchen. Zumindest sollte es einige Glocken läuten, wenn sie jetzt Ihr zuvor unveränderliches Ding ändern wollen.

Zuerst sieht es etwas umständlich aus, viele finalSchlüsselwörter in Ihrem Code zu sehen, aber schon bald werden Sie das Wort selbst nicht mehr bemerken und einfach denken, dass sich das Ding von diesem Punkt an nie ändern wird. auf (du kannst es mir nehmen ;-)

Ich denke, es ist eine gute Praxis. Ich benutze es nicht die ganze Zeit, aber wenn ich kann und es Sinn macht, etwas zu beschriften, finalwerde ich es tun.

Bessesen von:

• Endgültige Felder - Wenn Sie Felder als endgültig markieren, müssen sie bis zum Ende der Konstruktion festgelegt werden, sodass diese Feldreferenz unveränderlich ist. Dies ermöglicht die sichere Veröffentlichung von Feldern und vermeidet die Notwendigkeit einer Synchronisation bei späteren Lesevorgängen. (Beachten Sie, dass für eine Objektreferenz nur die Feldreferenz unveränderlich ist - Dinge, auf die sich die Objektreferenz bezieht, können sich noch ändern und dies wirkt sich auf die Unveränderlichkeit aus.)
• Endgültige statische Felder - Obwohl ich jetzt in vielen Fällen, in denen ich statische endgültige Felder verwendet habe, Aufzählungen verwende.

Betrachten Sie, aber verwenden Sie mit Bedacht:

• Letzte Klassen - Framework / API-Design ist der einzige Fall, in dem ich es betrachte.
• Endgültige Methoden - Grundsätzlich gleich wie Abschlussklassen. Wenn Sie Muster für Vorlagenmethoden wie "Verrückt" und "Endgültiges Markieren" verwenden, verlassen Sie sich wahrscheinlich zu sehr auf die Vererbung und nicht genug auf die Delegierung.

Ignorieren, es sei denn, Sie fühlen sich anal:

• Methodenparameter und lokale Variablen - Ich mache das selten, weil ich faul bin und finde, dass es den Code unübersichtlich macht. Ich gebe voll und ganz zu, dass das Markieren von Parametern und lokalen Variablen, die ich nicht ändern werde, "richtiger" ist. Ich wünschte, es wäre die Standardeinstellung. Aber das ist es nicht und ich finde den Code schwieriger zu verstehen, wenn das Finale vorbei ist. Wenn ich in einem anderen Code bin, werde ich ihn nicht herausziehen, aber wenn ich neuen Code schreibe, werde ich ihn nicht einfügen. Eine Ausnahme ist der Fall, in dem Sie etwas Endgültiges markieren müssen, damit Sie darauf zugreifen können es aus einer anonymen inneren Klasse.

Sie müssen wirklich die vollständige Verwendung des endgültigen Schlüsselworts verstehen, bevor Sie es verwenden können. Es kann auf Variablen, Felder, Methoden und Klassen angewendet werden und hat unterschiedliche Auswirkungen darauf

Ich würde empfehlen, den unten verlinkten Artikel für weitere Details zu lesen.

Letztes Wort zum letzten Schlüsselwort

Der finalModifikator, insbesondere für Variablen, ist ein Mittel, mit dem der Compiler eine Konvention erzwingen kann, die im Allgemeinen sinnvoll ist: Stellen Sie sicher, dass eine (lokale oder Instanz-) Variable genau einmal zugewiesen wird (nicht mehr und nicht weniger). Indem Sie sicherstellen, dass eine Variable definitiv zugewiesen ist, bevor sie verwendet wird, können Sie häufige Fälle von a vermeiden NullPointerException:

final FileInputStream in;
if(test)
  in = new FileInputStream("foo.txt");
else
  System.out.println("test failed");
in.read(); // Compiler error because variable 'in' might be unassigned

Indem Sie verhindern, dass eine Variable mehr als einmal zugewiesen wird, verhindern Sie das Scoping im Ausland. An Stelle von:

 String msg = null;
 for(int i = 0; i < 10; i++) {
     msg = "We are at position " + i;
     System.out.println(msg);
 }
 msg = null;

Sie werden aufgefordert, dies zu verwenden:

 for(int i = 0; i < 10; i++) {
     final String msg = "We are at position " + i;
     System.out.println(msg);
 }

Einige Links:

• Die letzte Geschichte (kostenloses Kapitel des Buches "Hardcore Java")
• Einige abschließende Muster
• Bestimmte Zuordnung

Ich bin ziemlich dogmatisch, wenn es darum geht, jede mögliche Variable zu deklarieren final. Dies umfasst Methodenparameter, lokale Variablen und selten Wertobjektfelder. Ich habe drei Hauptgründe, um überall endgültige Variablen zu deklarieren:

1. Absichtserklärung: Mit der Deklaration einer endgültigen Variablen erkläre ich, dass diese Variable nur einmal geschrieben werden soll. Es ist ein subtiler Hinweis für andere Entwickler und ein großer Hinweis für den Compiler.
2. Durchsetzen von Einwegvariablen: Ich glaube an die Idee, dass jede Variable nur einen Lebenszweck haben sollte. Indem Sie jeder Variablen nur einen Zweck geben, reduzieren Sie die Zeit, die erforderlich ist, um den Zweck dieser bestimmten Variablen beim Debuggen zu ermitteln.
3. Ermöglicht die Optimierung: Ich weiß, dass der Compiler früher Tricks zur Leistungssteigerung hatte, die sich speziell auf die Unveränderlichkeit einer Variablenreferenz stützten. Ich denke gerne, dass einige dieser alten (oder neuen) Performance-Tricks vom Compiler verwendet werden.

Ich denke jedoch, dass endgültige Klassen und Methoden bei weitem nicht so nützlich sind wie endgültige Variablenreferenzen. Das finalSchlüsselwort, wenn sie mit diesen Erklärungen verwendet einfach zur Verfügung stellen Hindernisse für automatisierte Tests und die Verwendung des Codes in einer Weise , dass man nie erwartet hätte.

Effektives Java hat ein Element mit der Aufschrift "Unveränderliche Objekte bevorzugen". Wenn Sie Felder als endgültig deklarieren, können Sie einige kleine Schritte in diese Richtung unternehmen, aber wirklich unveränderliche Objekte bieten natürlich noch viel mehr.

Wenn Sie wissen, dass Objekte unveränderlich sind, können sie ohne Synchronisierungsprobleme zum Lesen für viele Threads / Clients freigegeben werden, und es ist einfacher, über die Ausführung des Programms nachzudenken.

Ich war noch nie in einer Situation, in der ein endgültiges Schlüsselwort für eine Variable mich davon abgehalten hat, einen Fehler zu machen. Daher halte ich es im Moment für eine riesige Zeitverschwendung.

Wenn es keinen wirklichen Grund dafür gibt (wie in einem bestimmten Punkt, dass diese Variable endgültig ist), würde ich es lieber nicht tun, da ich finde, dass der Code dadurch weniger lesbar wird.

Wenn Sie jedoch nicht feststellen, dass der Code schwerer zu lesen oder länger zu schreiben ist, sollten Sie ihn unbedingt verwenden.

Bearbeiten: Als Klarstellung (und als Versuch, Rückstimmen zurückzugewinnen) sage ich nicht, dass Konstanten nicht als endgültig markiert werden, ich sage, dass Sie keine Dinge tun wie:

public String doSomething() {
  final String first = someReallyComplicatedExpressionToGetTheString();
  final String second = anotherReallyComplicatedExpressionToGetAnother();

  return first+second;
}

Es macht Code (meiner Meinung nach) nur schwerer zu lesen.

Es ist auch erwähnenswert, dass alles , was endgültig ist, Sie daran hindert, eine Variable neu zuzuweisen, sie nicht unveränderlich macht oder so etwas.

Final sollte immer für Konstanten verwendet werden. Es ist sogar nützlich für kurzlebige Variablen (innerhalb einer einzelnen Methode), wenn die Regeln zum Definieren der Variablen kompliziert sind.

Beispielsweise:

final int foo;
if (a)
    foo = 1;
else if (b)
    foo = 2;
else if (c)
    foo = 3;
if (d)        // Compile error:  forgot the 'else'
    foo = 4;
else
    foo = -1;

Klingt nach einem der größten Argumente dagegen Verwendung des endgültigen Schlüsselworts: "Es ist unnötig" und "es verschwendet Platz".

Wenn wir die vielen Vorteile von "final" anerkennen, auf die viele großartige Beiträge hier hinweisen, und gleichzeitig zugeben, dass es mehr Eingabe und Platz erfordert, würde ich argumentieren, dass Java die Variablen standardmäßig "final" hätte machen müssen und verlangen muss, dass die Dinge markiert werden. " veränderlich "wenn der Codierer es will.

Ich benutze die finalganze Zeit für Objektattribute.

Das finalSchlüsselwort hat eine Sichtbarkeitssemantik, wenn es für Objektattribute verwendet wird. Grundsätzlich erfolgt das Festlegen des Werts eines endgültigen Objektattributs, bevor der Konstruktor zurückkehrt. Dies bedeutet, dass Sie die thisReferenz nicht aus dem Konstruktor entkommen lassen und finalfür alle verwenden Ihr Objekt (unter Java 5-Semantik) garantiert ist, dass es ordnungsgemäß erstellt wird, Ihre Attribute verwenden. Da es auch unveränderlich ist, kann es sicher veröffentlicht werden zu anderen Threads.

Bei unveränderlichen Objekten geht es nicht nur um Fadensicherheit. Sie machen es auch viel einfacher zu Grunde , über die Zustandsübergänge in Ihrem Programm, weil der Raum von dem, was kann ändern ist bewusst , und wenn konsequent genutzt, gründlich beschränkt auf nur die Dinge , die sollten geändert werden .

Ich mache manchmal auch Methoden endgültig, aber nicht so oft. Ich mache selten Klassen endgültig. Ich mache das im Allgemeinen, weil ich wenig brauche. Ich benutze Vererbung im Allgemeinen nicht viel. Ich bevorzuge stattdessen die Verwendung von Schnittstellen und Objektkompositionen - dies eignet sich auch für ein Design, das meiner Meinung nach oft einfacher zu testen ist. Wenn Sie anstelle konkreter Klassen auf Schnittstellen codieren, brauchen Sie das nicht , um die Verwendung Vererbung , wenn Sie testen, wie es ist, mit Frameworks wie JMock, viel einfacher zu Mock-Objekte mit Schnittstellen zu schaffen , als es mit konkreten Klassen ist.

Ich denke, ich sollte den Großteil meiner Klassen endgültig machen, aber ich bin noch nicht in den Habbit gekommen.

Ich muss viel Code für meinen Job lesen. Das Fehlen endgültiger Instanzvariablen ist eines der wichtigsten Dinge, die mich nerven und das Verständnis des Codes unnötig erschweren. Für mein Geld verursacht die endgültige Festlegung lokaler Variablen mehr Unordnung als Klarheit. Die Sprache sollte so gestaltet sein, dass dies die Standardeinstellung ist, aber wir müssen mit dem Fehler leben. Manchmal ist es nützlich, insbesondere bei Schleifen und bestimmten Zuweisungen mit einem If-else-Baum, aber meistens zeigt es an, dass Ihre Methode zu kompliziert ist.

final sollte natürlich für Konstanten und zur Durchsetzung der Unveränderlichkeit verwendet werden, aber es gibt noch eine andere wichtige Verwendung für Methoden.

Effektives Java enthält einen ganzen Punkt (Punkt 15), der auf die Fallstricke einer unbeabsichtigten Vererbung hinweist. Wenn Sie Ihre Klasse nicht für die Vererbung entworfen und dokumentiert haben, kann das Erben von ihr zu unerwarteten Problemen führen (das Element gibt ein gutes Beispiel). Die Empfehlung lautet daher, dass Sie final für jede Klasse und / oder Methode verwenden, von der nicht geerbt werden sollte.

Das mag drakonisch erscheinen, macht aber Sinn. Wenn Sie eine Klassenbibliothek zur Verwendung durch andere schreiben, möchten Sie nicht, dass sie von Dingen erben, die nicht dafür entwickelt wurden. Sie werden sich aus Gründen der Rückenkompatibilität an eine bestimmte Implementierung der Klasse binden. Wenn Sie in einem Team programmieren, hindert nichts ein anderes Mitglied des Teams daran, das Finale zu entfernen, wenn es wirklich muss. Das Schlüsselwort lässt sie jedoch darüber nachdenken, was sie tun, und warnt sie, dass die Klasse, von der sie erben, nicht dafür ausgelegt ist. Daher sollten sie besonders vorsichtig sein.

Eine weitere Einschränkung ist, dass viele Leute final verwechseln, um zu bedeuten, dass sich der Inhalt der Instanzvariablen nicht ändern kann, anstatt dass sich die Referenz nicht ändern kann.

Selbst für lokale Variablen bedeutet das Wissen, dass es als endgültig deklariert ist, dass ich mir keine Sorgen machen muss, dass die Referenz später geändert wird. Dies bedeutet, dass ich beim Debuggen und wenn ich diese Variable später sehe, sicher bin, dass sie sich auf dasselbe Objekt bezieht. Das ist eine Sache weniger, über die ich mir Sorgen machen muss, wenn ich nach einem Fehler suche. Ein Bonus ist, dass wenn 99% der Variablen als endgültig deklariert werden, die wenigen Variablen, die wirklich variabel sind, besser hervorstechen. Außerdem kann der Compiler im Finale weitere mögliche dumme Fehler finden, die sonst möglicherweise unbemerkt bleiben.

Die Wahl, finalfür jeden Parameter in jeder Methode zu tippen , wird sowohl für Codierer als auch für Codeleser so irritierend sein.

Sobald die Irritation über den vernünftigen Wert hinausgeht, wechseln Sie zu Scala, wo die Argumente standardmäßig endgültig sind.

Sie können auch jederzeit Code-Styling-Tools verwenden, die dies automatisch für Sie erledigen. Alle IDEs haben sie implementiert oder als Plugins.

Final bei Verwendung mit Variablen in Java bietet einen Ersatz für Konstanten in C ++. Wenn also final und static für eine Variable verwendet wird, wird sie unveränderlich. Gleichzeitig macht migrierte C ++ - Programmierer ziemlich glücklich ;-)

Bei Verwendung mit Referenzvariablen können Sie das Objekt nicht erneut referenzieren, obwohl das Objekt bearbeitet werden kann.

Wenn final mit einer Methode verwendet wird, kann die Methode nicht von den Unterklassen überschrieben werden.

Sobald die Verwendung sehr klar ist, sollte sie mit Vorsicht verwendet werden. Dies hängt hauptsächlich vom Design ab, da die Verwendung von final auf der Methode den Polymorphismus nicht unterstützen würde.

Man sollte es nur für Variablen verwenden, wenn man verdammt sicher ist, dass der Wert der Variablen niemals geändert wird / werden sollte. Stellen Sie außerdem sicher, dass Sie die von SUN empfohlene Codierungskonvention befolgen, z. B.: Final int COLOR_RED = 1; (Großbuchstaben durch Unterstrich getrennt)

Verwenden Sie eine Referenzvariable nur, wenn Sie eine unveränderliche Referenz auf ein bestimmtes Objekt benötigen.

In Bezug auf den Lesbarkeitsteil ist zu beachten, dass Kommentare bei der Verwendung des endgültigen Modifikators eine sehr wichtige Rolle spielen.

Ich benutze sie nie für lokale Variablen, es gibt wenig Sinn für die zusätzliche Ausführlichkeit. Selbst wenn Sie nicht der Meinung sind, dass die Variable neu zugewiesen werden sollte, hat dies für die nächste Person, die den Code ändert, der anders denkt, kaum einen Unterschied. Da der Code geändert wird, ist möglicherweise der ursprüngliche Zweck, ihn endgültig zu machen, möglicherweise nicht mehr gültig. Wenn es nur um Klarheit geht, glaube ich, dass es an den negativen Auswirkungen der Ausführlichkeit scheitert.

Ähnliches gilt auch für Mitgliedsvariablen, da sie mit Ausnahme von Konstanten nur einen geringen Nutzen bringen.

Es hat auch keinen Einfluss auf die Unveränderlichkeit, da der beste Indikator dafür, dass etwas unveränderlich ist, darin besteht, dass es als solches dokumentiert ist und / oder keine Methoden hat, die das Objekt verändern können (dies ist zusammen mit dem Abschluss der Klasse der einzige Weg, dies zu gewährleisten es ist unveränderlich).

Aber hey, das ist nur meine Meinung :-)

Ich habe Eclipse so eingerichtet, dass alle Felder und Attribute, die nicht geändert werden, endgültig hinzugefügt werden. Dies funktioniert hervorragend mit den Eclipse-Aktionen "Speichern", mit denen diese endgültigen Modifikatoren (unter anderem) beim Speichern der Datei hinzugefügt werden.

Sehr empfehlenswert.

Schauen Sie sich meinen Blog-Beitrag von Eclipse Save Actions an.

Für Argumente denke ich, dass sie nicht benötigt werden. Meistens verletzten sie nur die Lesbarkeit. Das Neuzuweisen einer Argumentvariablen ist so wahnsinnig dumm, dass ich ziemlich sicher sein sollte, dass sie sowieso als Konstanten behandelt werden können.

Die Tatsache, dass Eclipse das endgültige Rot färbt, erleichtert das Erkennen von Variablendeklarationen im Code, was meiner Meinung nach die Lesbarkeit meistens verbessert.

Ich versuche, die Regel durchzusetzen, dass alle Variablen endgültig sein sollten, es gibt keinen extrem gültigen Grund, dies nicht zu tun. Es ist so viel einfacher, die Frage "Was ist diese Variable?" Zu beantworten. Frage, ob du nur die Initilierung finden und sicher sein musst, dass es das ist.

Ich werde heutzutage ziemlich nervös wegen nicht endgültiger Variablen. Es ist wie der Unterschied, ob ein Messer in einem Faden über Ihrem Kopf hängt oder nur eine Küchenschublade ...

Eine letzte Variable ist nur ein guter Weg, um Werte zu beschriften.

Eine nicht endgültige Variable ist an einen Teil eines fehleranfälligen Algorithmus gebunden.

Eine nette Funktion ist, dass, wenn die Option, eine Variable für einen Algorithmus nicht in Frage zu stellen, die meiste Zeit darin besteht, stattdessen eine Methode zu schreiben, die normalerweise den Code erheblich verbessert.

Ich programmiere jetzt schon eine Weile und benutze final, wann immer ich kann. Nachdem ich dies eine Weile getan habe (für Variablen, Methodenparameter und Klassenattribute), kann ich sagen, dass 90% (oder mehr) meiner Variablen tatsächlich endgültig sind. Ich denke, der Vorteil, dass Variablen NICHT geändert werden, wenn Sie dies nicht möchten (ich habe das schon einmal gesehen und es ist manchmal schmerzhaft), zahlt sich für die zusätzliche Eingabe und die zusätzlichen "endgültigen" Schlüsselwörter in Ihrem Code aus.

Wenn ich jedoch eine Sprache entwerfen würde, würde ich jede Variable endgültig machen, sofern sie nicht durch ein anderes Schlüsselwort geändert wird.

Ich benutze final nicht oft für Klassen und Methoden, dachte ich. Dies ist eine mehr oder weniger komplizierte Entwurfsauswahl, es sei denn, Ihre Klasse ist eine Utility-Klasse (in diesem Fall sollten Sie nur einen privaten Konstruktor haben).

Ich benutze auch Collections.unmodizable ..., um bei Bedarf nicht modifizierbare Listen zu erstellen.

Die Verwendung anonymer lokaler Klassen für Ereignis-Listener und dergleichen ist in Java ein gängiges Muster. Das häufigste Schlüsselwort wird verwendet, um sicherzustellen, dass Variablen im Gültigkeitsbereich für den geraden Listener zugänglich sind.

Wenn Sie jedoch feststellen, dass Sie viele endgültige Anweisungen in Ihren Code einfügen müssen. Das könnte ein guter Hinweis sein, dass Sie etwas falsch machen.

Der oben veröffentlichte Artikel enthält dieses Beispiel:

public void doSomething(int i, int j) {
    final int n = i + j; // must be declared final

    Comparator comp = new Comparator() {
        public int compare(Object left, Object right) {
            return n; // return copy of a local variable
        }
    };
}

Ich benutze es für Konstanten innerhalb und außerhalb von Methoden.

Ich benutze es nur manchmal für Methoden, weil ich nicht weiß, ob eine Unterklasse eine bestimmte Methode NICHT überschreiben möchte (aus welchen Gründen auch immer).

In Bezug auf Klassen habe ich nur für einige Infrastrukturklassen die Abschlussklasse verwendet.

IntelliJ IDEA warnt Sie, wenn ein Funktionsparameter in eine Funktion geschrieben wird. Daher habe ich die Verwendung von final für Funktionsargumente eingestellt. Ich sehe sie auch nicht in der Java Runtime-Bibliothek.

Ich verwende final kaum für Methoden oder Klassen, weil ich es gerne zulasse, dass Leute sie überschreiben.

Ansonsten benutze ich endlich nur wenn es ein ist public/private static final type SOME_CONSTANT;

Das Markieren des Klassenfinales kann auch dazu führen, dass einige Methodenbindungen zur Kompilierungszeit statt zur Laufzeit ausgeführt werden. Betrachten Sie unten "v2.foo ()" - der Compiler weiß, dass B keine Unterklasse haben kann, daher kann foo () nicht überschrieben werden, sodass die aufzurufende Implementierung zur Kompilierungszeit bekannt ist. Wenn Klasse B NICHT als endgültig markiert ist, ist es möglich, dass der tatsächliche Typ von v2 eine Klasse ist, die B erweitert und foo () überschreibt.

class A {
    void foo() {
        //do something
    }
}
final class B extends A {
    void foo() {
    }
}
class Test {
    public void t(A v1, B v2) {
        v1.foo();
        v2.foo();
    }
}

Die Verwendung von final für Konstanten wird dringend empfohlen. Ich würde es jedoch nicht für Methoden oder Klassen verwenden (oder zumindest eine Weile darüber nachdenken), da es das Testen schwieriger, wenn nicht unmöglich macht. Wenn Sie unbedingt eine Klasse oder Methode endgültig machen müssen, stellen Sie sicher, dass diese Klasse eine Schnittstelle implementiert, damit Sie einen Mock haben können , der dieselbe Schnittstelle implementiert.