Wann ist ein Java-Methodenname zu lang? [geschlossen]

In den letzten Wochen habe ich einige Leute gesehen, die wirklich lange Namen für eine Methode oder Klasse (50 Zeichen) verwendet haben. Dies setzt normalerweise voraus, dass dies die Lesbarkeit verbessert. Meiner Meinung nach ist ein langer Name wie dieser ein Indikator dafür, dass wir es sind Ich habe versucht, in einer Methodenklasse viel oder zu viel zu tun, wenn wir einen so langen Namen brauchen, aber ich wollte wissen, was ihr darüber denkt.

Ein Beispiel ist:

getNumberOfSkinCareEligibleItemsWithinTransaction

Ein Name in Java oder einer anderen Sprache ist zu lang, wenn ein kürzerer Name vorhanden ist, der das Verhalten der Methode gleichermaßen vermittelt.

Einige Techniken zum Reduzieren der Länge von Methodennamen:

1. Wenn es in Ihrem gesamten Programm, Ihrer Klasse oder Ihrem Modul um „Hautpflegeprodukte“ geht, können Sie die Hautpflege fallen lassen. Wenn zum Beispiel Ihre Klasse aufgerufen SkinCareUtilswird, bringt Sie das zugetNumberOfEligibleItemsWithinTransaction

2. Sie können innerhalb von in ändern ,getNumberOfEligibleItemsInTransaction

3. Sie können die Transaktion in Tx ändern, wodurch Sie zu gelangen getNumberOfEligibleItemsInTx.

4. Oder wenn die Methode einen Parameter vom Typ akzeptiert Transaction, können Sie den InTx insgesamt löschen:getNumberOfEligibleItems

5. Sie ändern die Anzahl nach Anzahl: getEligibleItemsCount

Das ist sehr vernünftig. Und es ist 60% kürzer.

Zur Abwechslung eine nicht subjektive Antwort: 65536 Zeichen.

A.java:1: Die UTF8-Darstellung für die Zeichenfolge "xxxxxxxxxxxxxxxxxxxx ..." ist zu lang für den konstanten Pool

;-);

Ich stimme allen zu: Methodennamen sollten nicht zu lang sein. Ich möchte jedoch eine Ausnahme hinzufügen:

Die Namen der JUnit-Testmethoden können jedoch lang sein und sollten Sätzen ähneln.

Warum?

• Weil sie in keinem anderen Code aufgerufen werden.
• Weil sie als Testnamen verwendet werden.
• Weil sie dann als Sätze geschrieben werden können, die Anforderungen beschreiben. (Zum Beispiel mit AgileDox )

Beispiel:

    @Test
    public void testDialogClosesDownWhenTheRedButtonIsPressedTwice() {
        ...
    }

Weitere Informationen zu dieser Idee finden Sie unter " Verhaltensorientiertes Design ".

Der Kontext "... WithinTransaction" sollte offensichtlich sein. Darum geht es bei der Objektorientierung.

Die Methode ist Teil einer Klasse. Wenn die Klasse nicht "Transaktion" bedeutet - und wenn Sie nicht die ganze Zeit "WithinTransaction" sagen müssen, haben Sie Probleme.

Ich neige dazu, die Haiku-Regel für Namen zu verwenden:

 Seven syllable class names 
 five for variables
 seven for method and other names

Dies sind Faustregeln für maximale Namen. Ich verletze dies nur, wenn es die Lesbarkeit verbessert. So etwas wie recalculateMortgageInterest (currentRate, quoteSet ...) ist besser als recalculateMortgageInterestRate oder recalculateMortgageInterestRateFromSet, da die Tatsache, dass es sich um Raten und eine Reihe von Anführungszeichen handelt, aus den eingebetteten Dokumenten wie javadoc oder dem .NET-Äquivalent ziemlich klar hervorgehen sollte.

HINWEIS: Kein echtes Haiku, da es 7-5-7 statt 5-7-5 ist. Aber ich nenne es immer noch lieber Haiku.

Java hat die Kultur, lange Namen zu fördern, möglicherweise weil die IDEs eine gute automatische Vervollständigung aufweisen.

Diese Seite sagt, dass der längste Klassenname in der JRE InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedState92 Zeichen lang ist.

Als längsten Methodennamen habe ich diesen gefunden supportsDataDefinitionAndDataManipulationTransactions, der aus 52 Zeichen besteht.

Verwenden Sie niemals ein langes Wort, wenn ein kleines Wort ausreicht.

Ich glaube nicht, dass Ihre These von "Länge des Methodennamens proportional zur Länge der Methode" wirklich Wasser enthält.

Nehmen Sie das von Ihnen angegebene Beispiel: "getNumberOfSkinCareEligibleItemsWithinTransaction". Das klingt für mich so, als würde es nur eines tun: Es zählt die Anzahl der Elemente in einer Transaktion, die in eine bestimmte Kategorie fallen. Natürlich kann ich nicht beurteilen, ohne den tatsächlichen Code für die Methode zu sehen, aber das klingt für mich nach einer guten Methode.

Andererseits habe ich viele Methoden mit sehr kurzen und prägnanten Namen gesehen, die viel zu viel Arbeit leisten, wie "processSale" oder das immer beliebte "doStuff".

Ich denke, es wäre schwierig, eine feste Regel für die Länge des Methodennamens zu geben, aber das Ziel sollte sein: lang genug, um zu vermitteln, was die Funktion tut, kurz genug, um lesbar zu sein. In diesem Beispiel würde ich denken, dass "getSkinCareCount" wahrscheinlich ausreichend gewesen wäre. Die Frage ist, was Sie unterscheiden müssen. Wenn Sie eine Funktion haben, die für Hautpflege geeignete Elemente in Transaktionen zählt, und eine andere, die Hautpflege-fähige Elemente in etwas anderem zählt, dann bietet "insideTransactions" einen Mehrwert. Wenn es jedoch nichts bedeutet, außerhalb einer Transaktion über solche Elemente zu sprechen, macht es keinen Sinn, den Namen mit solchen überflüssigen Informationen zu überladen.

Zweitens halte ich es für unrealistisch anzunehmen, dass ein Name von überschaubarer Länge genau sagt, was die Funktion in allen außer den trivialsten Fällen tut. Ein realistisches Ziel ist es, einen Namen zu finden, der dem Leser einen Hinweis gibt und an den man sich später erinnern kann. Wenn ich beispielsweise versuche, den Code zu finden, der berechnet, wie viel Antimaterie wir verbrauchen müssen, um die Warp-Geschwindigkeit zu erreichen, wenn ich mir die Funktionsnamen ansehe und "kalibriere Transporter", "firePhasers" und "calcAntimatterBurn" sehe, ist das ziemlich klar die ersten beiden sind es nicht, aber die dritte könnte es sein. Wenn ich überprüfe und feststelle, dass dies tatsächlich das ist, wonach ich suche, fällt es mir leicht, mich daran zu erinnern, wenn ich morgen zurückkomme, um an diesem Problem weiter zu arbeiten. Das ist gut genug.

Drei lange Namen, die ähnlich sind, sind verwirrender als kurze Namen. Wenn ich zwei Funktionen namens "calcSalesmanPay" und "calcGeekPay" habe, kann ich auf einen Blick erraten, welche welche ist. Aber wenn sie "berechneMonatlyCheckAmountForSalesmanForExportToAccountingSystemAndReconciliation" und "berechneMonatlyCheckAmountForProgrammersForExportToAccountingSystemAndReconciliation" heißen, muss ich die Namen studieren, um zu sehen, welche welche sind. Die zusätzlichen Informationen im Namen sind in solchen Fällen wahrscheinlich kontraproduktiv. Aus einem halben Sekunden-Denken wird ein 30-Sekunden-Denken.

Entwerfen Sie Ihre Benutzeroberfläche so, wie Sie es möchten, und passen Sie die Implementierung an.

Zum Beispiel würde ich das vielleicht als schreiben

getTransaction().getItems(SKIN_CARE).getEligible().size()

oder mit Java 8 Streams:

getTransaction().getItems().stream()
    .filter(item -> item.getType() == SKIN_CARE)
    .filter(item -> item.isEligible())
    .count();

Meine Regel lautet wie folgt: Wenn ein Name so lang ist, dass er in einer eigenen Zeile erscheinen muss, ist er zu lang. (In der Praxis bedeutet dies, dass ich selten über 20 Zeichen bin.)

Dies basiert auf Untersuchungen, die zeigen, dass die Anzahl der sichtbaren vertikalen Codezeilen positiv mit der Codierungsgeschwindigkeit / -effektivität korreliert. Wenn Klassen- / Methodennamen dies erheblich beeinträchtigen, sind sie zu lang.

Fügen Sie einen Kommentar hinzu, in dem die Methode / Klasse deklariert ist, und lassen Sie sich von der IDE dorthin führen, wenn Sie eine ausführliche Beschreibung des Verwendungszwecks wünschen.

Die Länge der Methode selbst ist wahrscheinlich ein besserer Indikator dafür, ob sie zu viel bewirkt, und selbst das gibt Ihnen nur eine grobe Vorstellung. Sie sollten nach Prägnanz streben, aber die Beschreibung ist wichtiger. Wenn Sie nicht die gleiche Bedeutung in einem kürzeren Namen vermitteln können, ist der Name selbst wahrscheinlich in Ordnung.

Wenn Sie das nächste Mal einen Methodennamen schreiben, denken Sie einfach an das folgende Zitat

"The man who is going to maintain your code is a phyco who knows where you stay"

Dieser Methodenname ist definitiv zu lang. Meine Gedanken neigen dazu zu wandern, wenn ich so große Methodennamen lese. Es ist, als würde man einen Satz ohne Leerzeichen lesen.

Persönlich bevorzuge ich so wenige Wörter in Methoden wie möglich. Ihnen wird geholfen, wenn der Paket- und Klassenname Bedeutung vermitteln kann. Wenn die Verantwortung der Klasse sehr präzise ist , ist kein riesiger Methodenname erforderlich. Ich bin gespannt warum "WithinTransaction" dort ist.

"getNumberOfSkinCareEligibleItemsWithinTransaction" könnte werden:

com.mycompany.app.product.SkinCareQuery.getNumEligibleItems ();

Bei Verwendung könnte die Methode dann wie folgt aussehen: "query.getNumEligibleItems ()"

Ein Variablenname ist zu lang, wenn ein kürzerer Name eine bessere Lesbarkeit des Codes über das gesamte Programm oder die wichtigen Teile des Programms ermöglicht.

Wenn Sie mit einem längeren Namen mehr Informationen über einen Wert übermitteln können. Wenn ein Name jedoch zu lang ist, wird der Code unübersichtlich und die Fähigkeit, den Rest des Codes zu verstehen, wird verringert. Dies geschieht normalerweise, indem Zeilenumbrüche verursacht und andere Codezeilen von der Seite verschoben werden.

Der Trick besteht darin, zu bestimmen, welche eine bessere Lesbarkeit bietet. Wenn die Variable häufig oder mehrmals auf engstem Raum verwendet wird, ist es möglicherweise besser, ihr einen kurzen Namen zu geben und einen Kommentar zu verwenden. Der Leser kann leicht auf den Kommentar zurückgreifen. Wenn die Variable häufig im gesamten Programm verwendet wird, häufig als Parameter oder in anderen komplizierten Operationen, ist es möglicherweise am besten, den Namen zu kürzen oder Akronyme als Erinnerung an den Leser zu verwenden. Sie können jederzeit auf einen Kommentar in der Variablendeklaration verweisen, wenn sie die Bedeutung vergessen.

Dies ist kein einfacher Kompromiss, da Sie überlegen müssen, was der Codeleser wahrscheinlich zu verstehen versucht, und auch berücksichtigen müssen, wie sich der Code im Laufe der Zeit ändert und wächst. Deshalb ist es schwierig, Dinge zu benennen.

Aus Gründen der Lesbarkeit ist es akzeptabel, i anstelle von DescriptiveLoopCounterName als Schleifenzähler zu verwenden. Da dies die häufigste Verwendung für eine Variable ist, können Sie am wenigsten Platz auf dem Bildschirm verwenden, um zu erklären, warum sie vorhanden ist. Der längere Name verschwendet nur Zeit, indem er es schwieriger macht zu verstehen, wie Sie die Schleifenbedingung testen oder in ein Array indizieren.

Wenn eine Funktion oder Variable am anderen Ende des Spektrums selten wie bei einer komplexen Operation verwendet wird, z. B. wenn sie an einen Funktionsaufruf mit mehreren Parametern übergeben wird, können Sie es sich leisten, ihr einen übermäßig beschreibenden Namen zu geben.

Wie bei jeder anderen Sprache: Wenn die einzelne Aktion, die die Funktion ausführt, nicht mehr beschrieben wird.

Ich würde sagen, verwenden Sie eine Kombination der guten Antworten und seien Sie vernünftig.

Beschreiben Sie vollständig, klar und lesbar, was die Methode bewirkt.

Wenn der Methodenname zu lang erscheint, überarbeiten Sie die Methode, um weniger zu tun.

Es ist zu lang, wenn der Name der Methode in eine andere Zeile eingeschlossen wird und der Aufruf der Methode das einzige in der Zeile ist und ziemlich nahe am Rand beginnt. Sie müssen die durchschnittliche Größe des Bildschirms der Personen berücksichtigen, die ihn verwenden werden.

Aber! Wenn der Name zu lang erscheint, ist er wahrscheinlich zu lang. Um dies zu umgehen, schreiben Sie Ihren Code so, dass Sie sich in einem Kontext befinden und der Name kurz ist, aber in anderen Kontexten dupliziert wird. Dies ist wie wenn Sie "sie" oder "er" auf Englisch anstelle des vollständigen Namens einer Person sagen können.

Es ist zu lang, wenn es zu ausführlich erklärt, worum es geht.

Zum Beispiel sind diese Namen funktional äquivalent.

in Java: java.sql.SQLIntegrityConstraintViolationException

in Python / Django: django.db.IntegrityError

Fragen Sie sich in einem SQL / DB-Paket, wie viele weitere Arten von Integritätsfehlern Sie finden können. ;) Daher db.IntegrityErrorist ausreichend.

Ein Bezeichnername ist zu lang, wenn er die Länge überschreitet, die Ihr Java-Compiler verarbeiten kann.

Hier gibt es zwei Möglichkeiten oder Gesichtspunkte: Zum einen spielt es keine Rolle, wie lang der Methodenname ist, solange es so aussagekräftig wie möglich ist, um zu beschreiben, was die Methode tut (Grundregel für bewährte Java-Methoden). Andererseits stimme ich dem Flybywire-Post zu. Wir sollten unsere Intelligenz nutzen, um zu versuchen, den Methodennamen so weit wie möglich zu reduzieren, ohne jedoch seine Beschreibbarkeit zu verringern. Beschreibbarkeit ist wichtiger :)

Ein Name ist zu lang, wenn:

• Das Lesen dauert länger als 1 Sekunde
• Nimmt mehr RAM in Anspruch, als Sie für Ihre JVM reservieren
• Ist etwas absurd benannt
• Wenn ein kürzerer Name durchaus Sinn macht
• Wenn es in Ihrer IDE herumläuft

Ehrlich gesagt muss der Name nur den Entwicklern seinen Zweck mitteilen, die ihn als öffentliche API-Methode verwenden, oder den Code beim Verlassen beibehalten. Denken Sie daran, KISS (halten Sie es einfach dumm)