Este artigo descreve os dez principais mandamentos que os desenvolvedores Java precisam conhecer. Compartilhe com todos para sua referência, os detalhes são os seguintes:
Como desenvolvedor Java, melhorar a qualidade e a capacidade de manutenção do seu próprio código é um tópico constante. Vi este artigo online e usei-o para me encorajar.
Existem muitos padrões e práticas recomendadas para desenvolvedores Java. Este artigo lista as dez regras básicas que todo desenvolvedor deve seguir. Se houver regras que possam ser seguidas, mas não seguidas, isso levará a um final muito trágico;
1. Adicione comentários ao seu código
Todo mundo sabe disso, mas de alguma forma se esquece de segui-lo. Conte quantas vezes você “esqueceu” de adicionar uma anotação? É verdade: os comentários não contribuem substancialmente para a funcionalidade do programa. No entanto, você precisa voltar ao código que escreveu há duas semanas repetidas vezes, talvez por toda a vida, e não deve se lembrar por que o código se comporta dessa maneira. Se esses códigos forem seus, você está com sorte. Porque pode trazer de volta memórias. Mas, infelizmente, na maioria das vezes, o código pertence a outra pessoa e há uma boa chance de ele ter deixado a empresa.
2. Não complique as coisas
Já fiz isso antes e tenho certeza de que todo mundo já fez. Os desenvolvedores geralmente encontram uma solução para um problema simples. Introduzimos EJBs para uma aplicação com apenas 5 usuários. Usamos um framework para uma aplicação que nem precisa dele. Adicionamos arquivos de propriedades, soluções orientadas a objetos e threads ao aplicativo, mas ele não precisava deles. Por que fazemos isso? Alguns de nós fazem isso porque não sabemos fazer melhor, mas alguns de nós fazem isso para aprender novos conhecimentos e tornar a aplicação mais interessante para nós mesmos.
3. Lembre-se – “menos é mais” nem sempre é bom
A eficiência do código é ótima, mas em muitos casos, escrever menos linhas de código não o torna mais eficiente. Por favor, deixe-me mostrar um exemplo simples.
if(newStatusCode.equals("SD") && (sellOffDate == null || todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null && todayDate.compareTo(lastUsedDate)>0)) || (newStatusCode.equals ("OBS") && (OBSDate == null || hojeDate.compareTo(OBSDate)<0))){ newStatusCode = "NYP";} Quero perguntar: é fácil saber o que a condição if do código acima deseja fazer? Agora, vamos supor que quem escreveu este código não seguiu a regra número um – adicione comentários ao seu código.
Não seria mais simples se dividíssemos esta condição em duas instruções if separadas? Agora, considere o seguinte código corrigido:
if(newStatusCode.equals("SD") && (sellOffDate == null || todayDate.compareTo(sellOffDate)<0 || (lastUsedDate != null && todayDate.compareTo(lastUsedDate)>0))){ newStatusCode = "NYP ";}else if(newStatusCode.equals("OBS") && (OBSDate == null || TodayDate.compareTo(OBSDate)<0)){ newStatusCode = "NYP";}Não seria melhor legível? Sim, repetimos a condição da declaração. Sim, temos um “SE” extra e dois pares extras de parênteses. Mas o código é melhor legível e compreensível.
4. Por favor, sem código rígido
Os desenvolvedores muitas vezes esquecem ou ignoram conscientemente essa regra porque, como sempre, estamos com pressa. Se seguirmos esta regra, poderemos ficar atrasados. Talvez não consigamos encerrar nosso estado atual. Mas quanto tempo nos custaria escrever uma linha extra de código definindo constantes estáticas?
Aqui está um exemplo.
classe pública A { public static final String S_CONSTANT_ABC = "ABC"; public boolean methodA(String sParam1){ if(A.S_CONSTANT_ABC.equalsIgnoreCase(sParam1)){ return true } return false }}Agora, toda vez que precisarmos comparar a string "ABC" com alguma variável, precisamos apenas referenciar S_CONSTANT_ABC em vez de lembrar qual é o código real. Também tem a vantagem de facilitar a modificação de uma constante em um só lugar, em vez de procurá-la em todo o código.
5. Não invente suas próprias estruturas
Milhares de frameworks foram lançados e a maioria deles é de código aberto. Muitas dessas estruturas são soluções excelentes e são usadas em milhares de aplicações. Você precisa acompanhar essas novas estruturas, pelo menos superficialmente. Entre esses frameworks excelentes e amplamente utilizados, um dos melhores e mais diretos exemplos é o Struts. De todos os frameworks que você pode imaginar, este framework web de código aberto é um candidato perfeito para aplicativos baseados na web. Mas você deve se lembrar da segunda regra: não complique as coisas. Se você desenvolver uma aplicação com apenas três páginas - por favor, não use o Struts. Para tal aplicação, não há nada para "controlar" as solicitações.
6. Não imprima linhas e adicione strings
Eu sei que, para fins de depuração, os desenvolvedores gostam de adicionar System.out.println em todos os lugares que acharem adequado, e dizemos a nós mesmos que excluiremos esse código mais tarde. Mas muitas vezes esquecemos de excluir essas linhas de código ou simplesmente não queremos excluí-las. Usamos System.out.println para testar. Depois de concluir o teste, por que ainda podemos acessá-los? Podemos excluir uma linha de código que realmente precisamos simplesmente porque você subestimou o dano causado por System.out.println. Considere o seguinte código:
classe pública BadCode { public static void calculatorWithPrint(){ double someValue = 0D; for (int i = 0; i <10000; i++) { System.out.println(someValue = someValue + i); ){ double algumValor = 0D; for (int i = 0; i < 10000; i++) { algumValor = algumValor + i; } } public static void main(String [] n) { BadCode.calculationWithPrint();Na tabela abaixo, você pode ver que o método calculatorWithOutPrint() levou 0,001204 segundos para ser executado. Em comparação, a execução do método calculatorWithPrint() levou surpreendentes 10,52 segundos.
(Se você não sabe como obter uma tabela como esta, consulte meu artigo "Java Profiling with WSAD" Java Profiling with WSAD)
A melhor maneira de evitar esse desperdício de CPU é introduzir um método wrapper, como o seguinte
classe pública BadCode { public static final int DEBUG_MODE = 1; public static final int PRODUCTION_MODE = 2; public static void calculatorWithPrint(int logMode){ double someValue = 0D; algumValor + i; meuPrintMethod(logMode, algumValor } } public static void); myPrintMethod (int logMode, valor duplo) { if (logMode > BadCode.DEBUG_MODE) { return } System.out.println (valor } public static void main (String [] n) { BadCode.calculationWithPrint (BadCode.PRODUCTION_MODE) ;}}Na figura abaixo, você verá que o método que usa StringBuffer levou apenas 0,01 segundos para ser executado, enquanto o método que usa adição de string levou 0,08 segundos para ser executado. A escolha é óbvia.
7. Siga a GUI
Não importa o quão ridículo isso pareça, direi repetidamente: a GUI é tão importante para os clientes empresariais quanto a funcionalidade e o desempenho. A GUI é uma parte essencial de um sistema bem-sucedido. (No entanto), as revistas de TI geralmente tendem a ignorar a importância das GUIs. Muitas organizações economizam dinheiro ao não contratar designers com vasta experiência no design de GUIs "amigáveis". Os desenvolvedores Java dependem de seu próprio conhecimento de HTML, mas seu conhecimento nesta área é muito limitado. Já vi muitos aplicativos como este: eles são "amigáveis ao computador", não "amigáveis ao usuário". Raramente vejo desenvolvedores proficientes em desenvolvimento de software e desenvolvimento de GUI. Se você é o azarado desenvolvedor designado para desenvolver uma interface de usuário, você deve seguir estes três princípios:
1. Não reinvente a roda. Procure sistemas existentes com requisitos de interface de usuário semelhantes.
2. Primeiro crie um protótipo. Este é um passo muito importante. Os clientes gostam de ver o que vão conseguir. Também é ótimo para você, porque você recebe o feedback deles antes de fazer tudo e criar uma interface de usuário que os deixará irritados.
3. Use o chapéu do usuário. Em outras palavras, examine os requisitos da aplicação do ponto de vista do usuário. Por exemplo, se uma página de resumo deve ser paginada. Como desenvolvedor de software, você tende a ignorar a paginação em um sistema porque isso deixa você com menos complexidade de desenvolvimento. No entanto, esta não é a melhor solução do ponto de vista do usuário porque os dados resumidos terão centenas ou milhares de linhas.
8. Sempre prepare requisitos documentados
Cada requisito de negócios deve ser documentado. Isto pode ser verdade em alguns contos de fadas, mas não é possível no mundo real. Não importa o quão apertado seja o tempo para o seu desenvolvimento, ou se a data de entrega está próxima, você deve sempre saber que todos os requisitos do negócio estão documentados.
9. Teste unitário, teste unitário, teste unitário
Não entrarei em detalhes sobre qual é a melhor maneira de testar seu código. O que vou dizer é que o teste unitário deve ser feito. Esta é a regra mais básica da programação. Esta é a mais importante de todas as leis acima e que não pode ser ignorada. É melhor se você tiver colegas que possam criar e testar testes de unidade para o seu código. Mas se ninguém fizer isso por você, você terá que fazer isso sozinho. Ao criar seu plano de teste de unidade, siga estas regras:
1. Escreva testes unitários antes de escrever código.
2. Escreva comentários em testes unitários.
3. Teste todos os métodos públicos que executam funções "interessantes" ("interessantes" significa métodos não-setters ou getters, a menos que executem métodos set e get de uma maneira especial).
10. Lembre-se: qualidade, não quantidade.
Não fique muito tarde no escritório (quando não for necessário). Entendo que, às vezes, problemas com produtos, prazos apertados e eventos inesperados podem nos impedir de sair do trabalho na hora certa. Porém, em circunstâncias normais, o gestor não valoriza e recompensa os funcionários que saem do trabalho tarde demais. Ele os valoriza pela qualidade dos produtos que produzem. Se você seguir as regras que forneci acima, descobrirá que seu código tem menos bugs e é mais fácil de manter. E essa é a parte mais importante do seu trabalho.
Resumir
Neste artigo, apresento dez regras importantes para desenvolvedores Java. É importante não apenas conhecer essas regras, mas também segui-las durante o processo de codificação. Esperamos que essas regras nos ajudem a nos tornarmos melhores programadores e profissionais.
Espero que este artigo seja útil para todos na programação Java.