Quando um nome de método Java é muito longo? [fechadas]

Nas últimas semanas, eu vi alguns caras usando nomes muito longos para um Método ou Classe (50 caracteres), isso geralmente é sob a premissa de que melhora a legibilidade, minha opinião é que um nome longo como esse é um indicador de que estamos tentando fazer muito ou muito em uma classe de método se precisarmos de um nome tão longo, no entanto, eu queria saber o que vocês acham disso.

Um exemplo é:

getNumberOfSkinCareEligibleItemsWithinTransaction

Um nome em Java ou qualquer outra linguagem é muito longo quando existe um nome mais curto que transmite igualmente o comportamento do método.

Algumas técnicas para reduzir o comprimento dos nomes dos métodos:

1. Se todo o seu programa, classe ou módulo for sobre 'itens de cuidados com a pele', você poderá descartar os cuidados com a pele. Por exemplo, se sua classe é chamada SkinCareUtils, isso leva você agetNumberOfEligibleItemsWithinTransaction

2. Você pode mudar dentro para dentro ,getNumberOfEligibleItemsInTransaction

3. Você pode alterar Transação para Tx, o que leva você a getNumberOfEligibleItemsInTx.

4. Ou, se o método aceitar um parâmetro do tipo, Transactionvocê poderá descartar o InTx completamente:getNumberOfEligibleItems

5. Você altera o númeroDe por contagem: getEligibleItemsCount

Agora isso é muito razoável. E é 60% menor.

Apenas para variar, uma resposta não subjetiva: 65536 caracteres.

A.java:1: A representação UTF8 para a cadeia "xxxxxxxxxxxxxxxxxxxxxx ..." é muito longa para o conjunto constante

;-)

Concordo com todos: os nomes dos métodos não devem ser muito longos. Eu quero adicionar uma exceção, porém:

Os nomes dos métodos de teste JUnit, no entanto, podem ser longos e devem se parecer com sentenças.

Por quê?

• Porque eles não são chamados em outro código.
• Porque eles são usados ​​como nomes de teste.
• Porque eles podem ser escritos como frases que descrevem requisitos. (Por exemplo, usando o AgileDox )

Exemplo:

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

Consulte " Design orientado a comportamento " para obter mais informações sobre essa idéia.

O contexto "... WithinTransaction" deve ser óbvio. É disso que se trata a orientação a objetos.

O método faz parte de uma classe. Se a classe não significa "Transação" - e se isso não o impede de dizer "Dentro de Transação" o tempo todo, você tem problemas.

Eu costumo usar a regra haiku para nomes:

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

Estas são regras práticas para nomes máximos. Eu violei isso apenas quando melhora a legibilidade. Algo como recalculateMortgageInterest (currentRate, quoteSet ...) é melhor que recalculateMortgageInterestRate ou recalculateMortgageInterestRateFromSet, pois o fato de envolver taxas e um conjunto de cotações deve ficar bem claro nos documentos incorporados, como javadoc ou equivalente no .NET.

NOTA: Não é um haiku real, pois é 7-5-7 em vez de 5-7-5. Mas ainda prefiro chamá-lo de haiku.

Java tem uma cultura de encorajar nomes longos, talvez porque os IDEs tenham um bom preenchimento automático.

Este site diz que o nome de classe mais longo no JRE InternalFrameInternalFrameTitlePaneInternalFrameTitlePaneMaximizeButtonWindowNotFocusedStatetem 92 caracteres.

Quanto ao nome do método mais longo, encontrei este supportsDataDefinitionAndDataManipulationTransactions, com 52 caracteres.

Nunca use uma palavra longa quando uma diminuta for suficiente.

Eu não acho que sua tese de "comprimento do nome do método é proporcional ao comprimento do método" realmente retém a água.

Tome o exemplo que você fornece: "getNumberOfSkinCareEligibleItemsWithinTransaction". Parece-me que faz apenas uma coisa: conta o número de itens em uma transação que se enquadram em uma determinada categoria. É claro que não posso julgar sem ver o código real do método, mas isso me parece um bom método.

Por outro lado, vi muitos métodos com nomes muito curtos e concisos que dão muito trabalho, como "processSale" ou o sempre popular "doStuff".

Eu acho que seria difícil estabelecer uma regra rígida sobre o tamanho do nome do método, mas o objetivo deve ser: longo o suficiente para transmitir o que a função faz, curto o suficiente para ser legível. Neste exemplo, eu acho que "getSkinCareCount" provavelmente seria suficiente. A questão é o que você precisa distinguir. Se você tem uma função que conta itens elegíveis para cuidados com a pele em transações e outra que conta itens elegíveis para cuidados com a pele em outra coisa, "dentro de Transações" agrega valor. Mas se isso não significa nada para falar sobre esses itens fora de uma transação, não faz sentido atrapalhar o nome com essas informações supérfluas.

Segundo, acho que não é realista supor que um nome de qualquer tamanho gerenciável lhe diga exatamente o que a função faz em todos os casos, exceto nos mais triviais. Um objetivo realista é criar um nome que dê ao leitor uma pista e que possa ser lembrado mais tarde. Por exemplo, se estou tentando encontrar o código que calcula quanta antimatéria precisamos consumir para atingir a velocidade da dobra, se eu olhar os nomes das funções e vir "calibrateTransporter", "firePhasers" e "calcAntimatterBurn", é bem claro que os dois primeiros não são, mas o terceiro pode ser. Se eu verificar e descobrir que esse é realmente o que estou procurando, será fácil lembrar que, quando voltar amanhã para trabalhar um pouco mais sobre esse problema. Isso é bom o suficiente.

Três, nomes longos semelhantes são mais confusos do que nomes abreviados. Se eu tiver duas funções chamadas "calcSalesmanPay" e "calcGeekPay", posso adivinhar qual é qual rapidamente. Mas se eles são chamados "calculeMonthlyCheckAmountForSalesmanForExportToAccountingSystemAndReconciliation" e "calculeMonthlyCheckAmountForProgrammersForExportToAccountingSystemAndReconciliation", preciso estudar os nomes para ver qual é qual. As informações extras no nome provavelmente são contraproducentes nesses casos. Transforma um pensamento de meio segundo em um pensamento de 30 segundos.

Projete sua interface da maneira que deseja e faça a implementação corresponder.

Por exemplo, talvez eu escreva isso como

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

ou com fluxos Java 8:

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

Minha regra é a seguinte: se um nome é tão longo que precisa aparecer em uma linha própria, é muito longo. (Na prática, isso significa que raramente estou acima de 20 caracteres.)

Isso se baseia em pesquisas que mostram que o número de linhas verticais de código visíveis se correlaciona positivamente com a velocidade / eficácia da codificação. Se os nomes de classe / método começarem a prejudicar significativamente isso, eles serão muito longos.

Adicione um comentário em que o método / classe é declarado e deixe o IDE levá-lo até lá, se você quiser uma descrição longa do que serve.

O tamanho do método em si provavelmente é um indicador melhor de que ele está fazendo muito, e mesmo isso apenas lhe dá uma idéia aproximada. Você deve procurar concisão, mas a descrição é mais importante. Se você não pode transmitir o mesmo significado em um nome mais curto, provavelmente o nome em si provavelmente está correto.

Quando você escrever um nome de método da próxima vez, pense na citação abaixo

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

Esse nome do método é definitivamente muito longo. Minha mente tende a vagar quando estou lendo nomes de métodos de tamanho tão grande. É como ler uma frase sem espaços.

Pessoalmente, prefiro o mínimo de palavras possível nos métodos. Você será ajudado se o nome do pacote e da classe puder transmitir significado. Se a responsabilidade da classe é muito concisa , não há necessidade de um nome de método gigante. Estou curioso para saber por que "WithinTransaction" está lá.

"getNumberOfSkinCareEligibleItemsWithinTransaction" pode se tornar:

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

Então, quando estiver em uso, o método poderá se parecer com "query.getNumEligibleItems ()"

Um nome de variável é muito longo quando um nome mais curto permitirá uma melhor legibilidade do código em todo o programa ou nas partes importantes do programa.

Se um nome mais longo permitir transmitir mais informações sobre um valor. No entanto, se um nome for muito longo, ele sobrecarregará o código e reduzirá a capacidade de compreender o restante do código. Isso normalmente ocorre causando quebra de linha e empurrando outras linhas de código para fora da página.

O truque é determinar qual oferecerá melhor legibilidade. Se a variável for usada frequentemente ou várias vezes em um curto espaço de espaço, pode ser melhor dar um nome curto e usar um esclarecimento de comentário. O leitor pode consultar o comentário facilmente. Se a variável for usada frequentemente em todo o programa, como parâmetro ou em outras operações complicadas, talvez seja melhor aparar o nome ou usar siglas como lembrete para o leitor. Eles sempre podem fazer referência a um comentário pela declaração da variável se esquecerem o significado.

Não é fácil fazer isso, pois é necessário considerar o que o leitor de código provavelmente está tentando compreender e também levar em consideração como o código mudará e crescerá com o tempo. É por isso que nomear as coisas é difícil.

A legibilidade é o motivo pelo qual é aceitável usar i como um contador de loop, em vez de DescriptiveLoopCounterName. Como esse é o uso mais comum para uma variável, você pode gastar a menor quantidade de espaço na tela explicando por que ela existe. O nome mais longo vai desperdiçar tempo, tornando mais difícil entender como você está testando a condição do loop ou indexando em uma matriz.

No outro extremo do espectro, se uma função ou variável for usada raramente como em uma operação complexa, como ser passada para uma chamada de função com vários parâmetros, você pode dar um nome excessivamente descritivo.

Como em qualquer outro idioma: quando não descreve mais a ação única que a função executa.

Eu diria que use uma combinação das boas respostas e seja razoável.

Descreva de forma completa, clara e legível o que o método faz.

Se o nome do método parecer muito longo - refatorar o método para fazer menos.

É muito longo quando o nome do método se agrupa em outra linha e a chamada para o método é a única coisa na linha e começa bem perto da margem. Você deve levar em consideração o tamanho médio da tela das pessoas que a usarão.

Mas! Se o nome parece muito longo, provavelmente é muito longo. A maneira de contornar isso é escrever seu código de forma que você esteja dentro de um contexto e o nome seja curto, mas duplicado em outros contextos. É como quando você pode dizer "ela" ou "ele" em inglês, em vez do nome completo de alguém.

É muito longo quando explica de maneira muito detalhada o que é a coisa.

Por exemplo, esses nomes são funcionalmente equivalentes.

em Java: java.sql.SQLIntegrityConstraintViolationException

em Python / Django: django.db.IntegrityError

Pergunte a si mesmo, em um pacote SQL / db, quantos outros tipos de erros de integridade você pode encontrar? ;) Portanto, db.IntegrityErroré suficiente.

Um nome de identificador é muito longo quando excede o comprimento que seu compilador Java pode suportar.

Existem duas maneiras ou pontos de vista aqui: Uma é que realmente não importa quanto tempo o nome do método seja, desde que seja o mais descritivo possível para descrever o que o método está fazendo (regra básica das melhores práticas de Java). Por outro lado, concordo com o post flybywire. Deveríamos usar nossa inteligência para tentar reduzir o máximo possível o nome do método, mas sem reduzir sua descrição. A descrição é mais importante :)

Um nome é muito longo se:

• Leva mais de 1 segundo para ler
• Consome mais RAM do que você aloca para sua JVM
• É algo absurdamente chamado
• Se um nome mais curto fizer todo sentido
• Se envolver o seu IDE

Honestamente, o nome só precisa transmitir seu objetivo aos Desenvolvedores que o utilizarão como um método público da API ou terão que manter o código quando sair. Apenas lembre-se do KISS (mantenha-o estúpido)