Wie viele Zeilen pro Klasse sind in Java zu viele? [geschlossen]

Was ist Ihrer Erfahrung nach eine nützliche Faustregel für die Anzahl der Codezeilen, die für eine Klasse in Java zu groß sind?

Um es klar auszudrücken, ich weiß, dass die Anzahl der Zeilen nicht einmal annähernd dem tatsächlichen Standard entspricht, der für das verwendet werden soll, was in einer bestimmten Klasse sein soll und was nicht. Der Unterricht sollte gemäß der richtigen OOP-Philosophie (Kapselung usw.) gestaltet werden. Allerdings könnte eine Faustregel einen nützlichen Ausgangspunkt für Überlegungen zum Refactoring bieten (z. B. "Hmmm, diese Klasse enthält> n Codezeilen; sie ist wahrscheinlich unlesbar und erledigt miese Arbeit bei der Verkapselung, also möchte ich vielleicht sehen, ob dies der Fall ist irgendwann überarbeitet werden ").

Auf der anderen Seite haben Sie vielleicht Beispiele für sehr große Klassen gefunden, die sich noch gut an das OOP-Design halten und trotz ihrer Länge lesbar und wartbar sind?

Hier ist eine verwandte, nicht doppelte Frage zu Zeilen pro Funktion .

Einige interessante Kennzahlen:

            junit fitnesse testNG tam jdepend ant tomcat
            ----- -------- ------ --- ------- --- ------
max 500 498 1450 355 668 2168 5457
Mittelwert 64,0 77,6 62,7 95,3 128,8 215,9 261,6
min 4 6 4 10 20 3 12
Sigma 75 76 110 78 129 261 369
files 90 632 1152 69 55 954 1468
Gesamtzeilen 5756 49063 72273 6575 7085 206001 384026

Ich benutze FitNesse als Benchmark, weil ich viel damit zu tun hatte, es zu schreiben. In FitNesse ist die durchschnittliche Klasse 77 Zeilen lang. Keiner ist länger als 498 Zeilen. Die Standardabweichung beträgt 76 Zeilen. Das bedeutet, dass die überwiegende Mehrheit der Klassen weniger als 150 Zeilen umfasst. Selbst Tomcat, der eine Klasse mit mehr als 5000 Zeilen hat, hat die meisten Klassen mit weniger als 500 Zeilen.

In Anbetracht dessen können wir wahrscheinlich 200 Zeilen als gute Richtlinie verwenden, um darunter zu bleiben.

Codezeilen sind für mich in diesem Zusammenhang irrelevant. Es hängt alles von der Anzahl der verschiedenen Gründe ab, warum ich in diese Klasse gekommen bin, um sie zu ändern.

Wenn ich zu dieser Klasse kommen würde, wenn ich die Regeln für die Validierung einer Person ändern möchte, möchte ich nicht zu derselben Klasse kommen, um die Regeln für die Validierung eines Auftrags zu ändern, und ich möchte auch nicht hierher kommen, um zu ändern, wo ich bin eine Person bestehen.

Das heißt, wenn Sie danach streben, werden Sie selten Klassen mit mehr als 200 Zeilen finden. Sie werden aus triftigen Gründen passieren, aber sie werden selten sein. Wenn Sie also nach einer Kennzahl mit roter Fahne suchen, ist dies kein schlechter Ausgangspunkt. Aber machen Sie es zu einer Richtlinie, nicht zu einer Regel.

Es tut mir leid, aber ich bin sehr überrascht, dass in vielen Antworten festgestellt wird, dass es "nicht wirklich wichtig" ist. Es ist sehr wichtig, wie viele Zeilen in einer Klasse sind. Warum? Beachten Sie diese Grundsätze, wenn Sie guten Java-Code schreiben ...

• Testbarkeit
• Zusammenhalt
• Kupplung
• Verständlichkeit

Klassen mit vielen Zeilen verstoßen höchstwahrscheinlich gegen all diese Prinzipien.

Für diejenigen, die es als "egal" bezeichnet haben ... Wie viel Spaß hat es Ihnen gemacht, eine Klasse mit über 5000 Zeilen zu verstehen? Oder um es zu ändern? Wenn du sagst, dass das Spaß macht, hast du eine seltsame Affinität zu Schmerz ...

Ich würde sagen, jede Klasse, die mehr als 1000 Zeilen enthält, sollte zumindest dahingehend befragt werden, wie sie möglicherweise gegen die oben genannten Prinzipien verstoßen und möglicherweise in mehrere "Off-Shoot" -Klassen aufgeteilt werden.

Meine Kommentare basieren auf dem Lesen und Studieren von Autoren wie Martin Fowler, Joshua Bloch und Misko Hevery. Sie sind ausgezeichnete Ressourcen für das Schreiben von gutem Java-Code.

Tun Sie dem nächsten (der Sie in ein paar Jahren sein könnte) einen Gefallen und bemühen Sie sich, Klassen zu schreiben, die weniger als mehr Zeilen enthalten.

Es kommt auf die Komplexität an, nicht auf die Anzahl der Zeilen. Ich habe große dumme Routinen geschrieben, die einfach zu verstehen waren und genau eines taten und es gut machten, aber Hunderte von Zeilen weitergingen. Ich habe ziemlich kurze Funktionen geschrieben, die schwer zu verstehen (und zu debuggen) waren.

Eine andere Sache, die Sie sich ansehen können, ist die Anzahl der öffentlichen Funktionen in einer Klasse. Das kann auch ein Warnzeichen sein.

Ich habe keine guten Zahlen zur Verfügung, aber ich würde vorschlagen, sich einen anständigen Code anzusehen, der nützliche Dinge in Ihrem Geschäft leistet, und ihn darauf abzustützen. Auf jeden Fall sollten Sie sich die längsten Klassen und die größten APIs ansehen.

Es gibt zu viele Codezeilen, wenn die Klasse zu viele verschiedene Aufgaben ausführt. Wenn Sie dem Prinzip der Einzelverantwortung für Klassen folgen, ist die Größe der Klasse im Wesentlichen begrenzt.

In Bezug auf physische Einschränkungen, die Sie haben können (Quelle: Klassendateiformat Java5 ):

• Es werden jeweils 65.536 Konstanten, Schnittstellen, Felder, Methoden und Attribute angewendet. ANMERKUNG: Sie haben keinen konstanten Speicherplatz mehr, bevor Sie keine anderen Elemente mehr haben. ANMERKUNG 2: Attribute sind Klassendateikonstrukte - nicht zu verwechseln mit '@Attribute'-Markierungen (dh Debug-Informationen und Bytecode werden als separate Attribute für eine Methode gespeichert).
• Bei jeder Methode kann es sich um 4 GB (32 Bit) generierten Bytecode handeln. ANMERKUNG: Java-Versionen vor 1.5 konnten für jede Methode nur 64 KB (16 Bit) generierten Byte-Code enthalten.

Kurz gesagt, die Klassendatei kann viel größer sein, als jeder für nützlich halten würde. Wenn Sie sich an das Prinzip der Einzelverantwortung halten, haben Ihre Klassendateien die richtige Größe.

Die richtige Antwort ist 42. Nur ein Scherz.
Die maximal empfohlenen Zeilen pro Klasse sind 2000 Zeilen.

"Java Code Conventions" seit 1999 haben es so ausgedrückt:
Dateien, die länger als 2000 Zeilen sind, sind umständlich und sollten vermieden werden.

Nachdem ich seit der Erfindung von Java die Sun / Oracle-Codierungskonventionen befolgt habe, habe ich festgestellt, dass diese Faustregel für Zeilen pro Klasse vernünftig ist. 99% Ihres Java-Codes sollten konform sein ... Und wenn es über 2000 geht, setzen Sie einfach ein TODO an die Spitze und sagen, dass die Klasse Arbeit braucht.

Das Schlimmste ist der umgekehrte Fall, wenn Programmierer zu viele kleine Klassen erstellen, die in jeder Klasse fast keine echte Funktionalität aufweisen. Ohne den Rat zu "Favor Composition" zu beachten, erstellen Programmierer Hunderte von vererbenden Klassen, die komplizierte Objektmodelle erzeugen, die weitaus schlimmer sind als das große Klassenproblem (die zumindest normalerweise die Funktionalität mit einem relevanten Klassennamen beibehalten).

http://www.oracle.com/technetwork/java/javase/documentation/codeconventions-141855.html#3043

Code bereinigen:

Klassen sollten klein sein!

Die erste Regel der Klassen ist, dass sie klein sein sollten. Die zweite Regel der Klassen ist, dass sie kleiner sein sollten. Nein, wir wiederholen nicht genau denselben Text aus dem Kapitel Funktionen. Aber wie bei Funktionen ist auch beim Entwerfen von Klassen die Kleinheit die Hauptregel. Wie bei Funktionen lautet unsere unmittelbare Frage immer: Wie klein?

** Bei Funktionen haben wir die Größe durch Zählen der physischen Linien gemessen. Bei Klassen verwenden wir ein anderes Maß. Wir zählen die Verantwortlichkeiten. **

Der Name einer Klasse sollte beschreiben, welche Aufgaben sie erfüllt. Tatsächlich ist die Benennung wahrscheinlich die erste Möglichkeit, die Klassengröße zu bestimmen. Wenn wir keinen genauen Namen für eine Klasse ableiten können, ist sie wahrscheinlich zu groß. Je mehrdeutiger der Klassenname ist, desto wahrscheinlicher ist es, dass er zu viele Verantwortlichkeiten hat. Beispielsweise deuten Klassennamen mit Wieselwörtern wie "Prozessor", "Manager" oder "Super" häufig auf eine unglückliche Zusammenfassung von Verantwortlichkeiten hin.

Dann:

• Stellen Sie einfach sicher, dass Ihre Methoden nur eine Sache tun.
• Stellen Sie dann sicher, dass die Klasse nicht zu viele Verantwortlichkeiten hat.

Sie erhalten eine Klasse von überschaubarer Größe.

Die Anzahl der Zeilen ist eine ziemlich schlechte Metrik für die Klassenqualität. Für mich mag ich es (wie andere bereits erwähnt haben), öffentliche Methoden sowie öffentlich zugängliche Eigenschaften zu betrachten (ich vermute öffentliche Getter / Setter in Java). Wenn ich eine Nummer aus der Luft ziehen müsste, um meine Aufmerksamkeit zu erregen, würde ich sagen, wenn es mehr als 10 von jeder gibt. Wirklich, wenn es mehr als 5 Eigenschaften oder Methoden sind, werde ich einen Blick darauf werfen und oft Wege zur Umgestaltung finden, aber alles über 10 ist normalerweise ein Warnsignal dafür, dass etwas ziemlich wahrscheinlich schlecht exponiert ist.

Es ist eine ganz andere Konversation, aber private Methoden und Felder riechen für mich weniger. Wenn sie also viel zur Anzahl der Zeilen beitragen, bin ich vielleicht nicht so besorgt. Zumindest zeigt es, dass es wahrscheinlich keinen Gott-Controller gibt, der das Objekt aus der Ferne manipuliert, was ein ziemlich problematisches Designproblem darstellt.

Versuchen Sie es mit einer besseren Metrik.

Ein Beispiel ist die ABC-Metrik . Es ist eher ein Maß dafür, wie viel Arbeit der Code leistet, als wie viel Code vorhanden ist.

Jede Zeile, die in die außerhalb der Klasse geschriebene Problemdomäne Ihrer Klasse fällt, ist eine Zeile zu wenig und eine Zeile zu viel in der Klasse, in der sie lebt. Stellen Sie sich eine Klasse als Thema vor. Sie müssen es abdecken. So kurz wie möglich ist ideal, aber wenn es 500 Zeilen dauert, dauert es 500 Zeilen. Wenn 100 dieser Zeilen ein anderes Thema behandeln, gehören sie woanders hin. Das Aufteilen in kleinere Unterdomänen innerhalb der Klasse als innere Klassen ist sinnvoll, aber ich würde diejenigen außerhalb der Klasse nur definieren, wenn sie anderweitig verwendet würden.