Arquivo Discussoes de Programacao e Tecnologia Pessoas, boa noite!
Estou tentando executar um método com callback aqui, porém, não consigo sair do lugar.
Se não me engano, quando estudei isso na faculdade há 4 anos, eu poderia criar uma nova instância como parâmetro de um método, porém, isso não é mais possível.
Algum link, pdf ou ideia que ajude a clarear as idéias?
Muito obrigado desde já, abraços!
Boa tarde pessoas,
Acho que não deixei muito claro o problema aqui. Eu estou fazendo um projeto - apenas pelo desafio e aprendizado - utilizando Reflection, o qual eu passo um objeto para o método da minha classe e ele percorre todos os atributos do objeto dado, criando elementos com a API JDom2 para gerar um xml com base no mesmo ao final.
O que acontece é: estou usando recursividade, pois o objeto passado por parâmetro pode conter atributos dos tipos primitivos ou tipos definidos pelo usuário. Quando é encontrado um tipo definido pelo usuário, chamo o mesmo método recursivamente para ele poder percorrer os atributos do tipo definido pelo usuário dentro do objeto.
Método que usa reflection para ler os objetos:
public void lerObjeto(Object objeto) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
Field[] campos = objeto.getClass().getDeclaredFields();
for (int i = 0; i < campos.length; i++) {
if ((!campos[i].getType().isPrimitive()) && (!campos[i].getType().isSynthetic()) && (!campos[i].getType().getSimpleName().equalsIgnoreCase("List")) && (!campos[i].getType().getSimpleName().equalsIgnoreCase("String"))) {
System.out.println(campos[i].getType() + " É UM TIPO DEFINIDO PELO USUÁRIO!");
campos[i].setAccessible(true);
lerObjeto(campos[i].get(objeto));
if (campos[i].get(objeto).getClass().isPrimitive()) {
System.out.println("VALOR DO CAMPO " + campos[i].getName() + ": " + campos[i].get(objeto));
}
campos[i].setAccessible(false);
} else if (campos[i].getType().getSimpleName().equalsIgnoreCase("List")) {
System.out.println(campos[i].getType() + " É ATRIBUTO DO TIPO LISTA!");
campos[i].setAccessible(true);
List valores = (List)campos[i].get(objeto);
for (int j= 0; j < valores.size(); j++) {
System.out.println("VALOR DO CAMPO " + campos[i].getName() + ": " + valores.get(j));
}
campos[i].setAccessible(false);
}
else {
campos[i].setAccessible(true);
System.out.println("VALOR DO CAMPO " + campos[i].getName() + ": " + campos[i].get(objeto));
campos[i].setAccessible(false);
}
}
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
List<String> lista = new ArrayList<>();
lista.add("valor 1");
lista.add("valor 2");
lista.add("valor 3");
Fornecedor fornecedor = new Fornecedor(1, "FORNECEDOR 1", "123.321/123");
Endereco endereco = new Endereco("Rua das Maritacas", 171, "Bairro das Pombas");
fornecedor.setEndereco(endereco);
Nota nota = new Nota(1, "123123", 35.50, lista, fornecedor);
Teste teste = new Teste();
teste.lerObjeto(nota);
}
Reparem que na linha 10 da primeira listagem é usada a recursividade caso o atributo lido seja um tipo definido pelo usuário - nesse exemplo poderia ser um fornecedor dentro da nota.
Até ai beleza, fiz alguns testes e funciona tranquilo - é claro que ainda faltam muitas verificações de tipos de objetos, mas isso vou incrementando com o tempo. O problema é que usa recursividade, algo que acho bem procedural. Me lembro de ter estudado callback durante a faculdade, e se não me engano, callback pode fazer o mesmo que a recursividade, mas de maneira orientada a objetos. A dúvida é: estou certo, callback é a recursividade da OO, e posso usá-la com algum critério de parada? Caso a resposta seja sim, vocês tem algum material pra me passar pra eu poder estudar? Os exemplos que encontrei no google parecem que nada tem a ver com o que preciso.
Qualquer dúvida, caso eu não tenha sido muito claro, basta perguntar.
Muito obrigado, abraços!
Up!
Qual é seu conceito de callback?
Você pode usar recursividade em OO sem problema algum.
Geralmente usar iteração é mais eficiente, mas há problemas que são mais facilmente resolvidos com recursão.