Instruções #

Instruções simples #

Cada linha deverá conter no máximo uma instrução. Exemplos:

argv++;         // correto
argc++;         // correto
argv++; argc--; // evitar!

Instruções compostas #

Instruções compostas são instruções que possuem uma lista de instruções contidas entre chaves, isto é, no bloco delimitado por “{” e “}”. Veja alguns exemplos nas sessões seguintes.

Eis algumas regras a serem seguidas no que tange as instruções compostas:

• instruções contidas no bloco devem ser indentadas em um ou mais níveis além do início da instrução composta;
• a chave aberta “{“ deve estar no final da linha onde se inicia a instrução composta, e a chave fechada “}” deve começar em uma linha indentada com o início da instrução composta;
• as chaves são usadas ao redor de todas as instruções, exceto para instruções simples, quando elas são partes de uma estrutura de controle, tais como uma instrução if-else ou for. Isso faz com que seja mais fácil incluir instruções sem a introdução acidental de bugs acidentais por se esquecer de se abrir as chaves.

Instruções de retorno #

A instrução return com um valor não deverá usar parênteses a menos que este valor torne-se mais claro com o uso destes. Eis alguns exemplos:

return;

return meuDisco.calcularTamanho();

return (tamanho != null ? tamanho : tamanhoPadrao);

Instruções condicionais “if” #

A classe de instruções condicionais “if-else” deverá utilizar uma das seguintes formas:

if (condição) {
      instruções;
}

if (condição) {
      instruções;
} else {
      instruções;
}

if (condição) {
       instruções;
} else if (condição) {
       instruções;
} else if (condição) {
       instruções;
} else {
       instruções;
}

As instruções condicionais do tipo “if” devem sempre utilizar chaves {}. Evite usar a seguinte forma propensa a erros:

if (condição)     // evite omitir as chaves neste caso!
       instrução;

Instruções de repetição “for” #

Uma instrução de repetição do tipo “for” deverá ter a seguinte forma:

for (inicialização; condição; iteração) {
       instruções;
}

Quando utilizar o operador vírgula na cláusula de inicialização ou iteração de uma instrução “for”, evite usar mais de três variáveis. Se necessário, use instruções em separado antes do laço “for” (para a cláusula de inicialização) ou ao final do loop (para a cláusula de iteração).

Instruções de repetição “while” #

Uma instrução de repetição do tipo “while” deverá ter a seguinte forma:

while (condição) {
       instruções;
}

Instruções de repetição “do-while” #

Uma instrução de repetição do tipo “do-while” deverá ter a seguinte forma:

do {
       instruções;
} while (condição);

Instruções condicionais “switch” #

Uma instrução condicional do tipo “switch” deverá utilizar a seguinte forma:

switch (variável) {
case ABC:
      instruções;
      /* falsa passagem */
case DEF:
      instruções;
      break;
case XYZ:
      instruções;
      break;
default:
      instruções;
      break;
}

Toda vez que houver um caso em que ocorra falsa passagem, isto é, quando não houver a instrução break, inclua um comentário justificando essa abordagem justamente onde o break deveria estar. De qualquer forma, sempre que possível evite utilizar a falsa passagem.

Toda instrução switch deverá apresentar um caso padrão através da cláusula default. O uso do break em uma instrução default é redundante, porém previne erros de falsas passagens se outra instrução case for adicionada ao final.

Instruções de tratamento de exceção “try-catch” #

Uma instrução do tipo “try-catch” deverá ter o seguinte formato:

try {
      instruções;
} catch (ClasseException e) {
      instruções;
}

Uma instrução do tipo “try-catch” também pode ser seguida da instrução “finally”:

try {
      instruções;
} catch (ClasseException e) {
      instruções;
} finally {
      instruções;
}