SóProvas


ID
2608033
Banca
CESPE / CEBRASPE
Órgão
CGM de João Pessoa - PB
Ano
2018
Provas
Disciplina
Programação
Assuntos

Acerca de padrões de projeto, JSE e JME, julgue o item a seguir.


O padrão Strategy possui benefícios como: clarificar algoritmos ao diminuir ou remover uma lógica condicional; simplificar uma classe ao mover variações de um algoritmo para uma hierarquia; habilitar um algoritmo para ser substituído por outro em tempo de execução; permitir que o algoritmo varie independentemente dos clientes que o utilizem.

Alternativas
Comentários
  • Strategy (Família de Algoritmo)

    Encapsula cada um deles e os torna intercambiáveis. O Strategy permite que o algoritmo varie independentemente dos clientes que o utilizam.

     

     

    Certo

     

     

    https://uploaddeimagens.com.br/imagens/padroes_de_projetos-png--3

     

     

  • Segundo o sítio DevMedia.com.br um dos grandes problemas das organizações empresariais é o excesso de lógica condicional (if .. else..if.. else if....) nas estruturas de softwares corporativos.

    Lógicas condicionais tendem a crescer em complexidade por causa do número crescente de restrições a serem tratadas nos programas tornando-os mais difíceis de se manter com o passar do tempo.

    Senão vejamos o exemplo (disponível em: https://medium.com/collabcode/strategy-padr%C3%B5es-de-projeto-em-java-43889a3afc5a)

    public class CalculadaDeImpostos{

    public double calcular(String imposto, double valor) {

    if (imposto.equals("ICMS")) return valor * 0.10;

    else if (imposto.equals("IPI")) return valor * 0.20;

    else if (imposto.equals("NOVO IMPOSTO")) return valor * 0.50;

    return valor;

    }

    }

    Com a aplicação do Padrão Strategy no código acima ficaria:

    public interface Imposto{

    double calcular();

    }

    public class ICMS implements Imposto

    private double valor;

    // construtor da classe ICMS, implementa a interface Imposto

    public ICMS(double valor) { this.valor = valor; }

    // sobrescreve o método << calcular() >> defino na interface Imposto.

    @Override

    public double calcular() { return this.valor * 0.10; }

    }

    Dessa forma, todos os outros impostos seriam criados como classes Java, ao invés de vários IFs e ELSEs.

    Uma das vantagens é reutilizar código; a mesma classe só mudaria o nome da classe (ICMA -> IPI), por exemplo e o cálculo no outro imposto, no caso valor * 0.20. Outras vantagens seria quando fosse preciso criar um novo imposto, bastava copiar uma das classes e recalcular o valor do imposto.

    // Agora, então, a classe abaixo passa a interface "imposto" como parâmetro, assim, todas as classes que implementem a // interface Imposto hedaram o método calcular(), implicitamente.

    public class CalculadoraDeImposto {

    public double calcular(Imposto imposto) { return imposto.calcular(); }

    }

    Não hora de executar as classes acima:

    public class TesteCalculadora {

    public static void main(String [] args){

    CalculadoraDeImposto calculadora = new CalculadoraDeImposto();

    ICMS icms = new ICMS(100.0);

    IPI ipi = new IPI(100.0);

    System.out.println(calculadora.calcular(icms));

    System.out.println(calculadora.calcular(ipi));

    }

    }

    Assim, se amanhã surgir um novo imposto basta criar a classe correspondente ao imposto (copia e cola dos outros impostos já calculados) tudo ainda continua a funcionar, sem prejuízo do que já foi feito antes.