Evitar o uso de Ifs[RESOLVIDO]

Sim, ifs pesam demais no processamento do algoritmo, e fora polimorfismo trazer a vantagem de dispensar o uso dos ifs, ele deixa o código mais elegante.

Ao longo de seus estudos você vai perceber que polimorfismo pode “fazer decisoes” dinamicamente em tempo de execução, algo que seria similar ao controle de fluxo if, porém bem mais elegante. (Não quis dizer que polimorfismo pode funcionar como if)

Então até entendi, mas se alguem puder me mostrar um exemplo ou link onde eu possa encontrar algo como este exemplo, que eu estou planejando meu TCC, é sempre bom aprender coisas novas para poder usar

mas vlw mesmo pela explicação, e é interessante, já que nunca gostei mutio de Ifs mesmo, acho que fica feio pakas…rsrs
mas nunca tinha pensando que podia ser tão “desusado” assim

tbm não sabia que pesava, pensei que fosse bem simples e leve…rsrs

Muita calma nessa hora, e bom senso pelo amor de Deus!!!

Esse pensamento é correto, mas não pode ser tomado ao pé da letra. Por exemplo, há alguns dias eu fiz um trabalho que era um editor de imagens vetoriais. A área de edição nada mais é do que um JPanel com o método de pintura sobrescrito. Em um determinado momento, as figuras armazenada em uma lista tem que ser desenhadas:

for (int i = 0; i < shapeList.getSize(); i++) {
     Shape shape = (Shape) shapeList.get(i);
     shape.drawMe(g2d);
}

Como cada podem existir vários tipo de figura - linhas, quadrados, elipses - eu implementei isso em subclasses de Shape de forma que cada uma tem o conhecimento de como ser desenhada. Fiz assim ao invés de criar uma variável tipo e testar dentro do for o tipo com if’s.

Porém, em um determinado momento, o painel pode ser exibido quando uma figura específica não acabou de ser desenhada:

if (currentShape != null) {
            currentShape.drawMe(g2d);
        }

Nesse caso, preciso usar o if pra testar se a variável é nula ou não.

Resumindo, evitar if’s não significa começar uma caça às bruxas no seu código. Significa simplificar o seu código.

não tem como vc não usar ifs, se vc vai fazer uma comparação simples tem que usar if, agora se vc vai fazer 300 comparações dentro de um laço então o bom senso diz que vc tem que usar
um switch case, até para facilitar a legibilidade do código. existem alguns compiladores que otimizam o código gerado , não sei se é o caso do java.

sds

j.silvestre

eu entendi +/-…mas acho que tem coisa que só fazendo mesmo, para conseguiur entender, mas sim sempre com bom senso, tbm nõ vamos exagerar imaginando que nunca devemos usar if né…

mas vlw mesmo pela explicação galera, vou ter que testar umas formas de fazer isso, que ainda não consigo imaginar…rsrs

Segue um outo exemplo: imagine que sua loja tenha varios tipos de funcionarios Gerente, Balconista e Faixineiro e o escritorio de contabilidade precise recuperar os valores dos salarios de cada um. Para isso criei 2 metodos

import java.util.ArrayList;
import java.util.List;


public class EscritorioContabilidade {
	
	//metodo para recuperar a informacao salarial utilizando os IF´s da pior maneira....rsrsr
	public double getSalarioFuncionario(String tipoFuncionario){
		double salario = -1;
		if("gerente".equals(tipoFuncionario)){
			salario = 1000;
		}
		else if("balconista".equals(tipoFuncionario)){
			salario = 900;
		}
		else if("faixineiro".equals(tipoFuncionario)){
			salario = 550;
		}
		return salario;
	}
	
	//metodo para recuperar a informacao salarial utilizando os IF´s. Nao melhoramos muito
	public double getSalarioFuncionario(Object funcionario){
		double salario = -1;
		if(funcionario instanceof Gerente){
			salario = 1000;
		}
		else if(funcionario instanceof Balconista){
			salario = 900;
		}
		else if(funcionario instanceof Faixineiro){
			salario = 550;
		}
		return salario;
	}
	
	//metodo para recuperar a informacao salarial utilizando polimorfismo. Agora sim!
	public double getSalarioFuncionario(Funcionario funcionario){
		return funcionario.informarSalario();
	}
	
	public static void main(String [] asdf){
		EscritorioContabilidade escritorioContabilidade = new EscritorioContabilidade();
		double folhaPagamento = 0;
		
		List<Funcionario> listaFuncionario = new ArrayList<Funcionario>();
		
		//adicionando os funcionarios 
		listaFuncionario.add(new Gerente());
		listaFuncionario.add(new Balconista());
		listaFuncionario.add(new Faixineiro());
		
		//usando o polimorfismo para determinar a folha de pagamento
		for (Funcionario funcionario : listaFuncionario) {
			folhaPagamento += escritorioContabilidade.getSalarioFuncionario(funcionario);
		}
		System.out.println("folha de pagamento: "+folhaPagamento);
		
		//agora vamos usar um dos metodos que utilizam os IFs e voces podem ver a clareza em ambos os trechos de codigo
		folhaPagamento = 0;
		folhaPagamento +=  escritorioContabilidade.getSalarioFuncionario("gerente");
		folhaPagamento +=  escritorioContabilidade.getSalarioFuncionario("balconista");
		folhaPagamento +=  escritorioContabilidade.getSalarioFuncionario("faixineiro");
		
		System.out.println("folha de pagamento: "+folhaPagamento);
	}
}


public abstract class Funcionario {
	public abstract double informarSalario();
}


public class Gerente extends Funcionario {

	@Override
	public double informarSalario() {
		return 1000;
	}

}

class Balconista extends Funcionario{

	@Override
	public double informarSalario() {
		return 900;
	}
	
}

class Faixineiro extends Funcionario{

	@Override
	public double informarSalario() {
		return 550;
	}
	
}

Criei uma classe Funcionario para abstracao desse conceito para que cada uma de suas implementacoes (Gerente, Balconista e Faixineiro) informem um valor salarial. Eh exatamente o ultimo metodo que utiliza o recurso do polimorfismo, pois caso nao existisse a classe abstracta Funcionario a implementacao do ultimo metodo seria impossivel, sendo assim, teriamos que escolher entre a primeira implementacao ou a segunda, isto eh, restariam apenas os IFs.

abrs

j.silvestre:

não tem como vc não usar ifs, se vc vai fazer uma comparação simples tem que usar if, agora se vc vai fazer 300 comparações dentro de um laço então o bom senso diz que vc tem que usar
um switch case, até para facilitar a legibilidade do código. existem alguns compiladores que otimizam o código gerado , não sei se é o caso do java.

sds

j.silvestre

Tem sim como vc evitar o uso de if’s, através do polimorfismo, utilizando alguns design patterns e boas práticas de orientação a objetos. É claro que vc não vai poder fazer isso em todos os casos, mas na maioria pode sim. Existe até um movimento chamado de “campanha anti-if”:
http://www.antiifcampaign.com/

E também tem um post no blog da caelum, relacionado ao assunto:
http://blog.caelum.com.br/como-nao-aprender-orientacao-a-objetos-o-excesso-de-ifs/

Vlw mesmo galera, acho que entendi a idéia do Vini Fernandes é a de não utilizar os IF no código em si, mas numa classe auxiliar, isso é mutio legal, fica muito mais legivel, e aquele post da caelum tbm é excelente,um jeito bem diferente, gostei muito, agora só tenho que dar uma treinada.

VLW msm

PS: No off-topic tbm põe [resolvido]…rsrs

Veja um exemplo:

Movi o tópico para Java Básico. É você mesmo que coloca o tópico como resolvido.

1. Vá ao seu PRIMEIRO post.
2. Clique em editar;
3. Escreva [Resolvido] no início do título;
4. Clique em enviar, e pronto!

vlw viny

mto legal aquele post, explica bem tbm

Pessoal, a um tempo atrás eu também estava com essa dúvida, sobre os uso de if´s em um código. O fato é que eu estava trabalhando com um arquivo .txt e nele continha dados separados apenas pelo caracter pipe ( "|" ). Cada linha desse arquivo .txt era um registro, e dentro dessa linha eu tinha que comparar as posições para eliminar, ou acrescentar dados entre os pipes.

Infelizmente, meu código acabou ficando muito feio, por se tratar de um "filtro" e como sou novo na área de programação com Java, fiquei meio sem ter pra onde correr, e o código ainda está com esse monte de if/else, vou postar uma parte do código do filtro para que vocês possam entender melhor o que estou fazendo:

for (int indice = 1; indice < campos.length; indice++) {
        if (campos[1].equalsIgnoreCase("0005")) {

                // Idem anterior
	        if ((indice >= 1 & indice < 11)) {

        	// Idem anterior
	        	camposFiltrados.add(campos[indice]);
        	}
        } else if (campos[1].equalsIgnoreCase("0100")) {
        	if ((indice >= 1 & indice < 15)) {
	        	camposFiltrados.add(campos[indice]);
        	}
        } else if (campos[1].equalsIgnoreCase("0150")) {
	        if ((indice >= 1 & indice < 14)) {
        		camposFiltrados.add(campos[indice]);
	        }
        } else if (campos[1].equalsIgnoreCase("0190")) {
	        if ((indice >= 1 & indice < 4)) {
		        camposFiltrados.add(campos[indice]);
        	}
        } else if (campos[1].equalsIgnoreCase("0200")) {
	        if ((indice >= 1 & indice < 13)) {
		        camposFiltrados.add(campos[indice]);
        	}
        }
}

Eu uso um BufferedReader e a linha que eu capturo através deste eu utilizo o método String.split( “|” ) e ele me retorna o array chamado ‘campos’ com todo o conteúdo da linha separado por vírgulas. E nessa parte do método eu verifico se o primeiro elemento do array ‘campos’ é igual a “0005”, “0100”, etc.
E de acordo com o resultado desse if eu filtro os dados de cada registro, inserindo no ArrayList de Strings ‘camposFiltrados’. Poderiam me dizer como esse código ficaria mais limpo?

Vlw

Rafael,

Crie um outro tópico com a sua dúvida já que este já foi marcado como resolvido

Abs

Ifs fazem parte do grupo de operações com maior velocidade de processamento, pois podem ser traduzidos diretamente para um respectivo bytecode da JVM ou mesmo do bytecode do processador. Tá certo que dependendo da comparação, pode requerer um pouco mais de esforço (comparações com valores não-nativos ex: Obj ao invés de int).

Dizer que If é mais lento é bobagem. O causador de lentidão tá muito mais ligado a implementação do algoritimo.

Já ví códigos For…Next com Ifs internos desnecessários que poderiam ter sido executados fora do loop uma única vez !
Já vi código que nem precisava de if. Uma operação matémática resolvia a situação.

Polimorfismo é daqueles assuntos que vc aprenderá mais com revistas e estudando por conta do que achar que vai sair craque disto na facul. Lá vc vai aprender que isto existe, mas para aprender mesmo vc vai ter que procurar fora de lá.

OliveirakunJava

a ultima vez que eu vi uma discussão parecida com esta, foi vendo dois programadores C, discutindo o uso do GOTO em C.
Depois de duas horas a discussão acabou. cada um permaneceu com sua opinião. depois nunca mais tocaram no assunto.
Vai ser a mesma coisa com o uso do if. eu particularmente não vou conseguir de deixar de usar os ifs, mas com moderação é claro.

sds

j.silvestre

GOTO é a coisa mais linda que existe. (Sim, tb possui seu próprio opcode).

Sou partidário de que se existe na linguagem suporte para este tipo de comando, que se use, ao invés de ficar pregando que é coisa do demo !

Há usos legítimos mas acho que a quantidade de abusos existentes, é que acabam denigrindo esta funcionalidade.