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

Alternativa correta: C - certo

A questão aborda o padrão de projeto Strategy, que é um padrão comportamental no âmbito da programação orientada a objetos. Esse padrão é utilizado para definir uma família de algoritmos, encapsular cada um deles e torná-los intercambiáveis. O Strategy permite que o algoritmo varie independentemente dos clientes que o utilizam.

Os benefícios mencionados na questão são realmente atribuídos ao padrão Strategy. Vou explicar cada um deles:

• Clarificar algoritmos ao diminuir ou remover uma lógica condicional: O uso de Strategy ajuda a evitar múltiplos if ou switch statements relacionados à seleção de algoritmos, pois cada algoritmo é encapsulado em sua própria classe, seguindo uma interface comum.
• Simplificar uma classe ao mover variações de um algoritmo para uma hierarquia: Isso permite que uma classe seja simplificada, delegando comportamentos que podem variar para outras classes que implementam uma interface comum, a estratégia.
• Habilitar um algoritmo para ser substituído por outro em tempo de execução: Graças à implementação do padrão Strategy, é possível alterar o algoritmo utilizado por um objeto em tempo de execução simplesmente trocando a instância da estratégia que ele está usando.
• Permitir que o algoritmo varie independentemente dos clientes que o utilizem: Como os algoritmos são encapsulados em suas próprias estratégias, e os clientes operam com essas estratégias através de uma interface comum, os clientes são desacoplados dos algoritmos específicos, permitindo variações sem impactar o cliente.

O entendimento correto do padrão Strategy é essencial para responder a esta questão, e a alternativa C está correta pois reflete precisamente os benefícios que o padrão Strategy traz para o design de software.

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.