Boa tarde
Estou começando a programar em java e me surgiu uma duvida quanto ArrayLists.
E possivel armazenar um objeto em um ArrayList?
Estou tentando fazer a seguinte coisa.
Estou criando um cadastro de NF.
Criei um objeto NF e um outro objeto ItemNf.
O objeto NF possui um arraylist em que eu quero armazenar os itens de NF
a duvida e a seguinte, como eu faço para utilizar um metodo do itemNF a partir do arraylist?
eu criei um metodo na NF para me listar os produtos dos itens da NF.
O metodo getProduto e do objeto ItemNf.
Como eu faço para chama-lo?
Segue como eu coloquei mas que deu errado. acho q deve haver outra forma para chamar este metodo mas eu nao sei qual e. Alguem poderia me ajudar?
public void listaItemNf(){
for (int i = 0;i < item.size(); i++){
System.out.println("teste " + i + ": " + item.get(i).getProduto);
}
}
Se vc usa ArrayList simples, ele contém objetos da classe Object ( ou seja, quaisquer)
mas isso implica que ao fazer get(i) ele retorna um Object que não tem o método getProduto()
Então existem duas soluções. No java 5.0 e seguints vc usa generics. Defina o array assim ArrayList
Isto significa “é um arrayList de ItemNF” , ai o codigo vai funcionar.
Em qq versão do java vc deve fazer cast
public void listaItemNf(){
for (int i = 0;i < item.size(); i++){
System.out.println("teste " + i + ": " + ((ItemNF)item.get(i)).getProduto);
}
}
Que é meio chato. Por favor use java 6 se quer ter um codigo limpo
[quote=LPJava]se vc usar o recurso de genericos nao precisa fazer o cast.
ArrayList <Integer>lista= new ArrayList<Integer>();
recurso java 1.5…[/quote]
Lembrando que ArrayList é uma classe que implementa a interface List. Existem outras classes que também implementam esta interface e que podem substituir o ArrayList com funcionalidades similares.
É mais interessante declarar a variável como interface e não como a classe concreta, o que torna o código mais flexível.
Considere o exemplo besta abaixo, onde o método recebe uma lista de Strings e retorna uma String com tudo concatenado
public String listToString(List<String> lista) {
StringBuffer sb = new StringBuffer();
for(String s : lista) {
sb.append(s);
}
return sb.toString();
}
O método acima pode receber um ArrayList, um Vector ou um LinkedList, sem a necessidade de alteração do código.
Programe sempre voltado para interfaces e não para classes concretas
[quote=sergiotaborda][quote=cassio]
É mais interessante declarar a variável como interface e não como a classe concreta, o que torna o código mais flexível.
Considere o exemplo besta abaixo, onde o método recebe uma lista de Strings e retorna uma String com tudo concatenado
public String listToString(List<String> lista) {
StringBuffer sb = new StringBuffer();
for(String s : lista) {
sb.append(s);
}
return sb.toString();
}
[/quote]
Bom então deveria ser:
public String listToString(List<String> lista) {
Appendable sb = new StringBuffer();
for(String s : lista) {
sb.append(s);
}
return sb.toString();
}
;)[/quote]
Poderia, mas nesse caso não faz a menor diferença, já que sua declaração começou e morreu dentro do próprio método. No exemplo que eu dei, o uso de interfaces tornou o método suficientemente flexível para receber qualquer objeto que seja instância de uma classe que implemente a interface List. No seu exemplo, o Appendable é um StringBuffer e pronto
public String listToString(List<String> lista) {
Appendable sb = new StringBuffer();
for(String s : lista) {
sb.append(s);
}
return sb.toString();
}
;)[/quote]
Poderia, mas nesse caso não faz a menor diferença, já que sua declaração começou e morreu dentro do próprio método. (…) No seu exemplo, o Appendable é um StringBuffer e pronto :-)[/quote]
Apenas levando o conceito de “programe para interfaces” às suas ultimas conseqüências. :roll:
E faz diferença sim, porque meu Appendable é agora um StringBuilder
public String listToString(List<String> lista) {
Appendable sb = new StringBuilder();
for(String s : lista) {
sb.append(s);
}
return sb.toString();
}
Mesmo quando o objeto é usando apenas dentro de um método é interessante usar interfaces em vez de classes, isto porque um dia no futuro vc pode querer mudar a classe real que é usada. Os motivos são vários , mas o principal deles é que vc pode querer usar uma implementação mais recente da interface que tem maior eficiência.
Como vc mesmo disse " É mais interessante declarar a variável como interface e não como a classe concreta, o que torna o código mais flexível. " 8)
