Março 10, 2021

Âmbito de variáveis em java

reduzindo o escopo

a próxima frase que você deve queimar sobre sua cabeça a partir deste momento:

Toda variável deve ser declarada no escopo mais curto possível.

Quando uma variável é declarada com um escopo mais extenso Do que o necessário, é apenas uma questão de tempo que usamos essa variável incorretamente, causando confusão e nos convidamos a introduzir o bug’s (se o escopo errado não estiver em si mesmo e um bug …). Vamos ilustrá-lo com um exemplo:

public class MiClase {int contarUsuariosPorNombreIncompleto(String fragmentoNombreUsuario, String nombreUsuarios) {boolean encontrado = false;int totalEncontrados = 0;for (Usuario nombreUsuarioActual : nombreUsuarios) {if (nombreUsuarioActual.contains(fragmentoNombreUsuario)) {encontrado = true;}if (encontrado) {totalEncontrados++;}}return totalEncontrados;}public static void main(String args) {String fragmentoNombreUsuario = "Michael";String nombreUsuarios = {"Jhon Doole", "Michael Fletcher", "James 'Jimmy X' Donald"};int resultado = new MiClase().contarUsuariosPorNombreIncompleto(fragmentoNombreUsuario, nombreUsuarios);System.out.println("Total resultados: " + resultado);}}

Ao executar a classe anterior, podemos ver a seguinte saída pelo console:

Total resultados: 2

O que aconteceu? Apenas um dos usuários tem a cadeia de Michael em seu nome, mas somos informados de que existem dois nomes de usuários correspondentes. Nós virtualmente cobrimos a execução da chamada para

  1. início da primeira iteração:
    • encontrado é false
    • totalmente encontrado 0
  2. fim da primeira iteração:
    • encontrado é
  • totalmente encontrado 0
  • Iniciando a segunda iteração:
    • encontrado é
  • Totalmente encontrado é 0
  • final da segunda iteração:
    • encontrado é true
    • totalmente encontrado 1
  • início da terceira e última iteração:
    • Acho que é true (mas deve ser false)
    • totalmente encontrado 1
  • fim da terceira e última iteração:
    • encontrado é true
    • totalmente encontrado 2
  • sem valor do que o uso de Dois blocos if para a lógica do nosso problema (Encontre um usuário para um fragmento do seu nome) é totalmente desnecessário, é o resultado da variável encontrado O que determina que aumentamos o contador totalEncontrados. O problema é que a variável deve ser reiniciada para FALSE no início (ou fim) de cada iteração, ou de outra forma no momento em que encontramos uma coincidência, o restante das iterações dará a Falso positivo:

    public class MiClase {int contarUsuariosPorNombreIncompleto(String fragmentoNombreUsuario, String nombreUsuarios) {boolean encontrado = false;int totalEncontrados = 0;for (Usuario nombreUsuarioActual : nombreUsuarios) {if (nombreUsuarioActual.contains(fragmentoNombreUsuario)) {encontrado = true;}if (encontrado) {totalEncontrados++;}encontrado = false;}return totalEncontrados;}// ...}

    Agora ao executar nossa classe novamente, obtemos o resultado esperado para os dados que fornecemos:

    Bem, já resolvemos nosso bug odioso. Agora é a hora de parar e avaliar a situação. Se você está pensando em deixar o código como é isso: você é inexperiente (perdoável), ou tem pressa (não perdoável), ou simplesmente não se importa (punível).

    Esqueça o tipo de programador Você quer ser, vamos continuar. Você não acha que estamos fazendo um pequeno uso torcido da variável encontrado?:

    • Nós declaramos isso como uma variável de bloco (escopo local) ..
    • … dentro do método
    • … mas estamos apenas usando dentro do bloco for (um escopo local mais concreto)

    Você se lembra dessa frase que você deve gravar para disparar na sua cabeça?

    Qualquer variável deve ser declarada na área mais pequena possível.

    Nossa variável está sendo declarada em uma área mais alta do que na qual é Usado, e por nós devemos reduzir seu escopo:

    public class MiClase {int contarUsuariosPorNombreIncompleto(String fragmentoNombreUsuario, String nombreUsuarios) {int totalEncontrados = 0;for (Usuario nombreUsuarioActual : nombreUsuarios) {boolean encontrado = false;if (nombreUsuarioActual.contains(fragmentoNombreUsuario)) {encontrado = true;}if (encontrado) {totalEncontrados++;}}return totalEncontrados;}// ...}

    Agora que a variável está em seu escopo apropriado, o código original é livre de erros e temos reduziu o uso da variável de três a dois lugares, o que significa código mais limpo. Poderíamos reduzir ainda mais o escopo da variável booleana? Neste caso particular, sim, eliminá-lo completamente (não há variável, não há escopo):

    public class MiClase {int buscarNumeroUsuarios(String nombreParcialUsuarioBusqueda, String nombreUsuarios) {int totalEncontrados = 0;for (Usuario nombreUsuarioActual : nombreUsuarios) {if (nombreUsuarioActual.contains(nombreParcialUsuarioBusqueda)) {totalEncontrados++;}}return totalEncontrados;}// ...}

    Agora, nossa lógica de negócios é bastante simples de entender. A remoção da variável encontrado não é tecnicamente uma redução do escopo, se não uma refatoração (melhoria de código).

    Deixe uma resposta

    O seu endereço de email não será publicado. Campos obrigatórios marcados com *