Quante linee per classe sono troppe in Java? [chiuso]

Alcune metriche interessanti:

            junit  fitnesse testNG    tam     jdepend    ant     tomcat
            -----  -------- ------    ---     -------    ---     ------
max           500       498   1450    355         668   2168       5457
mean         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
total lines  5756     49063   72273  6575        7085 206001     384026

Uso FitNesse come punto di riferimento perché ho avuto molto a che fare con la scrittura. In FitNesse la classe media è lunga 77 linee. Nessuno ha una lunghezza superiore a 498 linee. E la deviazione standard è di 76 linee. Ciò significa che la stragrande maggioranza delle classi ha meno di 150 righe. Anche Tomcat, che ha una classe superiore a 5000 linee, ha la maggior parte delle classi meno di 500 linee.

Dato questo possiamo probabilmente usare 200 linee come una buona linea guida per rimanere sotto.

Per me, le linee di codice sono irrilevanti in questo contesto. Riguarda il numero di diversi motivi per cui venivo in questa classe per cambiarlo.

Se venissi in questa classe quando voglio cambiare le regole per convalidare una persona, non voglio venire alla stessa classe per cambiare le regole per convalidare un Ordine, né voglio venire qui per cambia dove continuo una Persona.

Detto questo, se hai intenzione di farlo, raramente troverai classi di oltre 200 linee. Succederanno, per validi motivi, ma saranno rari. Quindi, se stai cercando una metrica con bandiera rossa, allora non è un brutto posto da cui iniziare; ma rendilo una linea guida, non una regola.

Mi dispiace ma sono molto sorpreso che molte risposte affermino che "non ha molta importanza". È MOLTO che conta quante linee sono in una classe. Perché? Considera questi principi per scrivere un buon codice Java ...

• Testabilità
• di coesione
• Accoppiamento
• comprensibilità

Le classi con molte linee in esse violeranno molto probabilmente tutti questi principi.

Per coloro che lo hanno dichiarato "non ha molta importanza" ... quanto è stato divertente per te provare e capire una classe con oltre 5000 linee? Oppure, per modificarlo? Se dici che è divertente, hai una strana affinità con il dolore ...

Direi che qualsiasi classe che ha più di 1000 righe dovrebbe essere almeno in essere interrogata su come potrebbero violare i principi sopra e possibilmente analizzata in più classi "off-shoot".

I miei commenti si basano sulla lettura e sullo studio di autori come Martin Fowler, Joshua Bloch e Misko Hevery. Sono risorse eccellenti da consultare per scrivere un buon codice Java.

Fai il prossimo (che potrebbe essere tu tra un paio d'anni) un favore e sforzati di scrivere classi che contengono meno righe piuttosto che più.

Dipende dalla complessità, non dal numero di linee. Ho scritto roba stupida di facile comprensione e che ha fatto esattamente una cosa e ha funzionato bene, ma ho continuato per centinaia di righe. Ho scritto funzioni abbastanza brevi che erano difficili da capire (e fare il debug).

Un'altra cosa che potresti guardare è il numero di funzioni pubbliche in una classe. Questo può anche essere un segnale di avvertimento.

Non ho buoni conti disponibili, ma suggerirei di guardare un codice decente che faccia cose utili nel tuo negozio e basandoci su quello. Certamente dovresti guardare le classi più lunghe e le API più grandi.

La risposta corretta è 42. Sto scherzando.
In realtà, le righe massime consigliate per classe sono 2000 linee.

"Convenzioni sul codice Java" dal 1999 lo hanno dichiarato in questo modo:
I file più lunghi di 2000 righe sono ingombranti e dovrebbero essere evitati.

Avendo seguito le convenzioni Sun / Oracle Coding da quando è stato inventato Java, Ho trovato questa regola empirica sulle righe per classe per essere ragionevole. Il 99% del codice Java deve essere conforme ... E se supera il 2000, basta mettere un TODO in cima dicendo che la classe ha bisogno di lavoro.

La cosa peggiore è il caso opposto quando i programmatori creano troppi minuscoli piccole classi con quasi nessuna reale funzionalità in ogni classe. Ignorando il consiglio di "Favorisci la composizione", i programmatori creano centinaia di classi ereditanti che creano modelli di oggetti complicati che sono di gran lunga peggiori rispetto al problema della grande classe (che almeno di solito mantiene la funzionalità con un nome di classe rilevante).

link

Ci sono troppe righe di codice se la classe sta facendo troppe cose diverse. In sostanza, se segui il principio della Responsabilità Singola per le classi, c'è un limite alla crescita della classe.

Riguardo alle limitazioni fisiche che puoi avere (fonte: Formato file di classe Java5 ):

• 65.536 costanti, interfacce applicate, campi, metodi e attributi - ciascuno. NOTA: si esaurirà lo spazio costante prima di esaurire qualsiasi degli altri elementi. NOTA 2: gli attributi sono costrutti di file di classe, da non confondere con i marcatori "@Attribute" (ad esempio, le informazioni di debug e il codice byte vengono memorizzati come attributi separati per un metodo).
• Ogni metodo può essere 4GB (32 bit) di codice byte generato. NOTA: le versioni di Java precedenti alla 1.5 potevano avere solo 64 KB (16 bit) di codice byte generato per ciascun metodo.

In breve, il file di classe può essere molto più grande di chiunque potrebbe considerare utile. Se rispetti il principio della responsabilità unica, i tuoi file di classe avranno le dimensioni giuste.

Pulisci codice:

Classes Should Be Small!

The first rule of classes is that they should be small. The second rule of classes is that they should be smaller than that. No, we’re not going to repeat the exact same text from the Functions chapter. But as with functions, smaller is the primary rule when it comes to designing classes. As with functions, our immediate question is always “How small?”

** With functions we measured size by counting physical lines. With classes we use a different measure. We count responsibilities.**

The name of a class should describe what responsibilities it fulfills. In fact, naming is probably the first way of helping determine class size. If we cannot derive a concise name for a class, then it’s likely too large. The more ambiguous the class name, the more likely it has too many responsibilities. For example, class names including weasel words like Processor or Manager or Super often hint at unfortunate aggregation of responsibilities.

Quindi:

• Assicurati che i tuoi metodi facciano solo una cosa.
• Quindi assicurati che la classe non abbia troppe responsabilità.

Finirai con una classe di dimensioni gestibili.

Il numero di linee è una metrica piuttosto scadente per la qualità della classe. Per quanto mi riguarda, mi piace guardare (come altri hanno menzionato) i metodi pubblici, così come ogni proprietà pubblicamente esposta (credo che i getter / setter pubblici in Java). Se dovessi tirare fuori un numero per quando potrebbe attirare la mia attenzione, direi quando ce ne sono più di 10. In realtà, se si tratta di più di circa 5 di proprietà o metodi, darò un'occhiata e spesso troverò dei modi per fare il refactoring, ma qualsiasi cosa su 10 è di solito un segnale di avvertimento che qualcosa è abbastanza probabile che sia poco esposto.

È un'altra conversazione completamente, ma i metodi e i campi privati sono meno di un odore per me, quindi se stanno contribuendo molto al numero di linee, allora potrei non essere così preoccupato. Per lo meno, mostra che probabilmente non esiste un controller di Dio che manipoli l'oggetto da lontano, il che è un problema di progettazione piuttosto problematico.

Prova a utilizzare una metrica migliore.

Un esempio è la metrica ABC . È più una misura di quanto lavoro viene svolto dal codice rispetto a quanto codice ci sia.

Qualsiasi riga che rientra nel dominio problematico della classe scritta al di fuori della classe è una riga troppo piccola e una troppa nella classe in cui vive. Pensa a una lezione come a un argomento. Devi coprirlo. Il più conciso possibile è l'ideale, ma se impiega 500 linee, ci vogliono 500 linee. Se 100 di queste linee coprono un altro argomento, esse appartengono ad altro. Rompere i sottodomini più piccoli all'interno della classe come classi interne ha senso, ma definirei solo quelli al di fuori della classe se fossero usati altrove.