Certificação Java SCJA
Prof.: Aníbal Fernandes
https://sites.google.com/site/wizard2javadevelopers/
Hands-On: Java Collections Frameworks:
Aula 17
24/05/2012
Por que Framework Collection?
Resp.: Complexidade do Software
Um Framework representa uma
aplicação reutilizável e semicompleta
que pode ser especializada para
produzir aplicações personalizadas.
O Framework oferece um conjunto de interfaces e
classes que podem ser reutilizadas e especializadas para
a representação e a manipulação de objetos que através
de vetores dinâmicos em Java.
Todos os algoritmos disponíveis no Framework
Collection e representados pelas suas classes concretas
foram desenvolvidos com base na eficiência, nos
Java disponibiliza classes que facilitam o
agrupamento e processamento de objetos
em conjuntos:
– Coleções (Java Collections Framework).
– Estruturas de dados + algoritmos para sua
manipulação.
Java Collections Framework
– Arquitetura unificada para representar e
manipular coleções, de forma independente dos
detalhes de sua representação.
Coleções
O desenvolvedor utiliza as Estruturas de Dados sem
se preocupar com os detalhes de implementação.
Vantagens:
– Reutilização de Código
– Desempenho Superior
• Maior velocidade de execução.
• Utilização eficiente de memória.
• Algoritmos Otimizados.
Coleções
De forma simplificada,
são objetos capazes de
armazenar conjuntos de
referências para outros
objetos;
• Possui as principais estruturas: Listas, Pilhas, Árvores, etc
– Correspondem a classes oferecidas na biblioteca
padrão de Java;
– Armazenam referências do tipo Object;
– Obrigatório o uso de Polimorfismo.
Coleções
Os elementos que compreendem a estrutura
de coleções estão no pacote java.util.
Java separa a representação da coleção em: Interfaces
Interfaces
• Definem métodos que podem ser usados para
manipulação dos objetos nas coleções.
Implementações
• Classes que implementam as interfaces, mas,
Interface
Interfaces podem ser utilizadas para separar a especificação do
comportamento de um objeto de sua implementação concreta.
Trazem a especificação do conjunto de operações públicas
A Interface age como um contrato, o qual define explicitamente
quais métodos uma classe deve obrigatoriamente implementar.
Revisão de
Interface
em Java
Uma interface é um conjunto de métodos relacionados que
não tem corpo, ou seja, sem implementação, tais como:
public
interface
Eletronico {
public abstract void ligar();
public void desligar();
}
public class Televisao implements Eletronico {
// obrigatório implementar os métodos da interface public void ligar() {
System.out.println("Liguei a televisão"); // aqui o algoritmo para ligar a televisão }
public void desligar() {
System.out.println("Desliguei a televisão"); // aqui o algoritmo para desligar a televisão }
public interface Imprimivel { void imprimir();
}
public class Impressora implements Eletronico { // impressora desligada por padrão
private boolean ligada = false;
// método para imprimir uma nota fiscal
public void imprimirNotaFiscal(Imprimivel objImprimivel){ // verifica se a impressora esta ligada!
if(this.ligada){
objImprimivel.imprimir();
} else { // Se o objeto passado não der pra imprimir
System.out.println("Problema: Impressora desligada!"); }
}
// implementamos o método da interface Eletronico public void ligar() { // ligamos a impressora ....
this.ligada = true;
System.out.println("Impressora ligada!"); }
public void desligar() { this.ligada = false;
System.out.println("Impressora desligada!"); }
Como exemplo didático, vamos criar dois tipos de nota fiscal, uma é possível imprimir e a outra não aceita pode ser impressa porque é útil apenas para visualização.
public class NotaFiscal implements Imprimivel { private int numero;
private double valor;
public NotaFiscal(int numero, double valor){ this.numero = numero;
this.valor = valor; }
public void imprimir() {
System.out.println("Número: " + this.getNumero() + ", Valor: "+ this.getValor()); }
public double getValor() { return valor; } public int getNumero() { return numero; }
public void setValor(double valor) { this.valor = valor; }
public void setNumero(int numero) { this.numero = numero; } }
A classe de Nota Fiscal que é somente para visualização. Não é obrigada a implementar a função imprimir().
public class NotaFiscalOnline { private int numero;
private double valor;
public NotaFiscalOnline(int numero, double valor){ this.numero = numero;
this.valor = valor; }
public double getValor() { return valor; } public int getNumero() { return numero; }
public void setValor(double valor) { this.valor = valor; }
public void setNumero(int numero) { this.numero = numero; } }
public class TesteNotaFiscal {
public static void main(String[] args) {
// instanciar uma impressora HP
Impressora impressoraHP1000 = new Impressora();
// ligamos a impressora!
impressoraHP1000.ligar();
// simular a criação de 10 notas fiscais
for (int i = 1; i <= 10; i++) {
// numero da nota atual recebe o valor de i
int numeroNota = i;
// Criamos um valor i * 10, só para esta demonstração // 10.0 , 20.0, 30.0, 40.0, 50.0 .... 100.0
double valor = (double) (10 * i); // Criamos um nota fiscal
NotaFiscal notaf = new NotaFiscal(numeroNota, valor);
// por parâmetro, passamos um objeto que implementa a classe // Imprimivel para o método da impressora que espera um objeto // do tipo Imprimivel
impressoraHP1000.imprimirNotaFiscal(notaf); }
} }
As regras de nomenclatura para
interfaces
são as mesmas que
para as classes, embora seja usual o emprego de nomes que
denotem, ou indiquem, suas funcionalidades ali definidas:
- Uma interface chamada
Imprimivel
, somente terá métodos
relacionados com impressão;
- Uma interface Editavel terá métodos relacionados a edição.
As interfaces também fazem uso do mecanismo de herança
que em Java esta relacionada com a palavra
extends
. Assim,
suas funcionalidades podem ser reescritas, ou podem ganhar
novas funcionalidades através da herança.
public interface Editavel {
void editar(String conteudo); }
public interface EmailEditavel extends Editavel {
void editarAssunto(String assunto); void editarDe(String de);
void editarPara(String para); }
Uma classe pode implementar diversas interfaces, por exemplo: Um e-mail pode ser Imprimivel e Editavel…
public class Email implementsImprimivel, EmailEditavel { private String de;
private String para; private String assunto; private String mensagem;
public void imprimir() { // implementando o método imprimir() da interface Imprimivel System.out.println(
"De:" + this.getDe() + ",\n" + "Para:" + this.getPara() + ",\n" + "Assunto: " + this.getAssunto() + ",\n" +
"Mensagem:" + this.getMensagem()); }
// E implementamos os métodos da interface EmailEditavel!
public void editarAssunto(String assunto) { this.setAssunto(assunto); } public void editarDe(String de) { this.setDe(de); }
public void editarPara(String para) { this.setPara(para); }
public void editar(String conteudo) { this.setMensagem(conteudo); } public String getDe() { return de; }
public void setDe(String de) { this.de = de; } public String getPara() { return para; }
public void setPara(String para) { this.para = para; } public String getAssunto() { return assunto; }
public void setAssunto(String assunto) { this.assunto = assunto; } public String getMensagem() { return mensagem; }
public void setMensagem(String mensagem) { this.mensagem = mensagem; } }
Java Não tem herança múltipla, mas uma classe pode implementar mais de uma interface.
1- É possível declarar
atributos
privados em uma Interface?
Resposta: Não.
As interfaces não podem ter atributos privados, todos os seus
atributos são public final e static. Isso se deve pelo fato de que o
objetivo das interfaces é que sejam implementadas. As classes que
farão a implementação devem fazer uso de seus atributos, se tivesse
atributos private seria inútil, pois as classes que farão a
implementação Não “enxergarão” os atributos. Por este motivo que
não é permitido criar atributos ou métodos private em interfaces.
2-É possível declarar
métodos
static em uma interface.
Resposta: Não.
Uma interface não pode ter métodos com corpo. Para que um
método
static
? Se os métodos de interfaces não podem ter corpo.
Os métodos das interfaces, serão implementados em outras classes.
Estudo de Caso 1 – Listas
- Uma lista é uma coleção linear de elementos que podem ser
percorridos sequencialmente e permite inserção e remoção
de elementos em qualquer posição.
- Conceitualmente, não possui um tamanho máximo.
As operações disponíveis sobre listas estão definidas na
interface List
- A documentação da API de Java lista possui todas as
operações permitidas sobre uma lista.
Estudo de Caso 1 - Listas
Alguns métodos:
– add(indice,objeto) adiciona um objeto na posição do índice
– add(objeto) adiciona um objeto na posição final da lista
– get(indice) retorna o objeto armazenado na posição do
índice indicado
– remove(indice) remove e retorna o objeto armazenado
na posição do índice indicado
– clear() limpa a lista
– isEmpty() retorna verdadeiro se a lista está vazia
– size() retorna o número de elementos da lista
Estudo de Caso 1 - Listas
Duas implementações diferentes da
interface List são as classes
ArrayList e LinkedList.
Por que? Temos implementações com performance
diferente para operações diferentes.
Declaração: Devemos informar o tipo dos elementos da lista
ao declararmos uma Coleção
List<Tipo> umaLista = new ArrayList<Tipo>();
List<Tipo> umaLista = new LinkedList<Tipo>();
Estudo de Caso 1 – Listas
Classes ArrayList e LinkedList
Implementações da interface List.
– ArrayList é uma implementação sob a forma de vetor de
tamanho variável.
– LinkedList é uma implementação da mesma interface sob
a forma de lista encadeada.
– Vantagem:
• Escolhe-se o tipo de estrutura conforme a necessidade
da aplicação, porém, a forma de usá-las é exatamente a
mesma.
/* Classe que usa uma ArrayList para guardar os nomes dos professores. * Permite a utilização de vários métodos nessa ArrayList. */
import java.util.*;
import static java.lang.System.out; public class List {
//Declaração da ArrayList
ArrayList<String> professores = new ArrayList<String>(); List() { professores = new ArrayList<String>(); }
//Adiciona um professor à lista
public void adicionaProf(String nomeProf) { professores.add(nomeProf);
out.println ("Foi adicionado um professor com o nome "+nomeProf); out.println ("==========================================="); }
public void listarProfessores(){
out.println("Lista de Professores"); for (String nome : professores) out.println(nome);
out.println("========================================"); }
public void tamanhoDaLista(){ int a = professores.size();
out.println("A lista tem "+a+" elementos"); out.println("=========================="); }
public void existe(String nome){ int i=0;
for (String profs : professores) { if (profs.contains(nome)==true){ i++; } } if (i==0) out.println("Não Existe"); if (i>0)
out.println("Foram encontradas "+i+" ocorrencias do nome "+nome); out.println("================================================="); }
public void apagarTudo(){ professores.clear();
out.println("Todos os registos foram apagados"); }
public void apagaElemento(String nome){ professores.remove(nome);
}
public void verificarVazio(){
if (professores.isEmpty()==true) out.println("Está Vazio");
else if (professores.isEmpty()==false) out.println("Não está vazio"); }
} // fim da classe List
public class TestaLista {
public static void main(String args[]){ List turma3Sem = new List();
turma3Sem.adicionaProf("Albert Einstein"); turma3Sem.adicionaProf("Isaac Newton"); turma3Sem.adicionaProf("Galileu Galilei"); turma3Sem.listarProfessores(); } }
Exemplo didático utilização de Listas
Implementar um cofrinho de moedas com a capacidade de
receber moedas e calcular o total depositado no cofrinho.
Exemplo didático utilização de Listas
Implementar um cofrinho de moedas com a capacidade de
receber moedas e calcular o total depositado no cofrinho.
Exercícios 1
Altere a classe Cofrinho de modo que ela implemente métodos para:
– Contar o número de moedas armazenadas
– Contar o número de moedas de um determinado valor
– Informar qual a moeda de maior valor
Exercício 2
Escreva um programa Java que crie 5 objetos Circulo de tamanho
diferentes, insira-os em uma lista e depois percorra a lista imprimindo
a área de cada círculo armazenado.
Exercícios 3
Implementar uma classe Cadastro que funcione como cadastro de
professores (classe Professor desenvolvida em aulas anteriores).
Através desta classe deve ser possível adicionar um professor, buscar
um professor pelo seu número de matrícula e remover um professor
pelo seu número de matrícula. Depois, escreva um programa em
Java para testar a classe desenvolvida.
Estudo de Caso 2 - Mapas
Um mapa é um tipo de dado que mantém associações entre
chaves e valores.
– Não possui valores duplicados de chaves
– Cada chave somente é associada com um único valor
Por exemplo: nome de pessoa e sua cor favorita
Estudo de Caso 2 – Mapas
As operações disponíveis sobre Mapas estão definidas na
interface Map
Duas implementações diferentes são as classes
HashMap e TreeMap.
Declaração:
Map<TipoChave,TipoValor> umMapa = new
Estudo de Caso 2 - Mapas
Alguns métodos:
– put(chave, valor) associa o valor à chave informada,
armazenando na coleção
– get(chave) retorna o valor associado à chave
– remove(chave) remove da coleção a chave e o valor, e retorna
o valor associado à chave
– containsKey(chave) retorna verdadeiro se a coleção contém a
chave informada
Exercícios 1
Implemente uma classe em Java com as funcionalidades de
uma agenda telefônica, associando um nome a um número
telefônico. A classe deve possuir a interface abaixo:
Exercícios 2
Faça um aplicativo Java para testar a classe AgendaTelefonica
desenvolvida no exercício anterior.
Teste a classe com pelo menos 5 contatos diferentes na agenda
de telefones.
Hands-On 1- Desenvolver a classe ExemploDadosPessoais ,
contendo a seguinte estrutura:
• Atributos privados: nome,telefone e idade
• Criar os métodos de acesso getters() e setters() para os atributos.
A classe ExemploDadosPessoais deve implementar a interface Comparable e ser parametrizada para ExemploDadosPessoais, conforme exemplo:
Comparable<ExemploDadosPessoais>
Como a classe ExemploDadosPessoais implementa a interface Comparable, esta deverá implementar o método compareTo(). Esse método deverá ser codificado de forma a
classificarmos os objetos usando o atributo nome. Conforme comentado, toda classe que implementa a interface Comparable deve implementar o método compareTo(). Esse método realiza a comparação entre um objeto recebido como parâmetro e o próprio objeto. Validar a idade com o método setIdade(). Caso a idade recebida seja menor ou iguala 0 ou maior que 110, apresentar uma mensagem de erro usando o controle de exceções. Caso contrário, realizar a atribuição do parâmetro recebido para o atributo idade.
Hands-On 2 -2Criar a segunda classe ExemploDadosPessoaisPrincipal, contendo os seguintes
conteúdos:
• Atributo privado conjOrdenado do tipo SortedSet parametrizado para o tipo ExemploDadosPessoais. Adicionar um objeto do tipo TreeSet ao atributo criado. Em seguida, criar os seguintes métodos:
• O método main() deverá apresentar um menu com três opções: a primeira para
cadastrar os dados, a segunda para listar os dados usando o atributo do tipo SortedSet e a terceira para encerrar o sistema. A primeira opção deverá realizar a execução do método cadastrar() e a segunda executar o método listar()
• O método cadastrar() deverá solicitar os dados para leitura do teclado. Atribuir esses dados lidos aos atributos de um objeto a ser criado do tipo ExemploDadosPessoais. Em seguida, adicionar esse objeto criado ao atributo conjOrdenado por meio do método add(). É importante observar que qualquer objeto do tipo da classe ExemploDadosPessoais
implementa o método compareTo() assim, o objeto, ao ser adicionado a uma coleção (com a capacidade de ordenação), será ordenado automaticamente. Outro ponto importante é que não será possível adicionar objetos com o mesmo nome. Essa regra é garantida para todas as coleções que implementam a interface Set
.• O método listar() deverá apresentar na tela os valores cadastrados no atributo conjOrdenado usando um iterador. Criar um iterador parametrizado para o tipo ExemploDadosPessoais.
Montar um loop com o método hasNext() e para cada objeto presente no conjunto atribuí-lo a uma variável do tipo ExemploDadosPessoais
Hands-On 3 Criar a segunda classe ExemploDadosPessoaisPrincipalMapa, contendo os seguintes conteúdos:
• Atributo privado mapaOrdenado do tipo Map parametrizado para o tipo String como chave e ExemploDadosPessoais como elemento do mapa. Adicionar um objeto do tipo TreeMap ao atributo criado. Em seguida, criar os seguintes métodos:
• O método main() deverá apresentar um menu com três opções: a primeira para cadastrar os dados, a segunda para listar os dados usando o atributo do tipo Map e a terceira para encerrar o programa. A primeira opção deverá realizar a execução do método cadastrar() e a segunda
executar o método listar() .
• O método cadastrar() deverá solicitar os dados para leitura do teclado. Atribuir esses dados lidos aos atributos de um objeto a ser criado do tipo ExemploDadosPessoais. Em seguida, adicionar esse objeto criado ao atributo mapaOrdenado por meio do método put(). Para a chave, utilizar a variável que representa o nome lido. É importante observar que os objetos do tipo da classe ExemploDadosPessoais implementam o método compareTo(), assim, ao adicionar um novo objeto à coleção, esta será ordenada automaticamente.
• O método listar() deverá apresentar na tela os valores cadastrados no atributo mapaOrdenado usando um iterador. No caso do uso da interface Map o caminho para obter um iterador pode mudar. Em nosso exemplo utilizaremos um iterador por meio do método KeySet(). Vejamos um exemplo:
Iterator<String> it = this.mapaOrdenado.keySet().iterator();
Com posse do iterador, podemos utilizar o método hasNext() para gerar um loop e recuperar todos os objetos gravados.
Hands-On 4 Criar a segunda classe ExemploCarro , contendo os seguintes conteúdos:
• Criar os seguintes atributos privados: chassi, marca, fabricante, dtFabricacao
• Em seguida, criar os métodos de acesso setters() e getters() para cada um dos atributos.
A classe ExemploCarro deve implementar a interface Comparable e ser parametrizada para ExemploCarro , conforme exemplo:
public class ExemploCarro implements Comparable <ExemploCarro>
Como a classe ExemploCarro implementa a interface Comparable, esta, por consequência, deverá implementar o método compareTo(). Esse método deverá ser codificado levando-se em consideração que classificaremos os objetos usando o atributo chassi. Conforme
comentado, toda classe que implementa a interface Comparable deve implementar o método compareTo(). Esse método realiza a comparação entre um objeto recebido como parâmetro e o próprio objeto.
Hands-On 5 Criar a segunda classe ExemploCarroPrincipal, contendo o seguinte conteúdo:
• O atributo setCarro do tipo SortedSet, porém, parametrizado para o tipo da classe
ExemploCarro. Atribuir um objeto do tipo TreeSet ao atributo setCarro. Em seguida, criar os seguintes métodos:
• O método main() deverá apresentar um menu com três opções: a primeira para cadastrar os dados, a segunda para listar os dados e a terceira para finalizar o programa. A primeira opção deverá realizar a execução do método cadastrar() e a segunda executar o método imprimir().
• O método cadastrar() deverá solicitar os dados para leitura do teclado. Em seguida, criar o objeto carro do tipo ExemploCarro . Atribuir os dados lidos do teclado aos atributos do objeto carro. Depois, adicionar o objeto carro ao atributo setCarro .
• O método imprimir() deverá apresentar na tela os valores cadastrados no atributo setCarro usando um iterador. Vejamos um exemplo:
Iterator <ExemploCarro>it = this.setCarro.iterator();
Esse método deverá apresentar a data de fabricação que foi lida no formato AAAA/MM/DD no formato DD/MM/AAAA. Para isso, utilizar o método split() da classe String.
• Com posse do iterador, criar um loop com o método hasNext() e com o método next() recuperar os objetos adicionados.
Hands-On 6 - Criar a segunda classe ExemploCarroPrincipalMapa , contendo os seguintes
conteúdos:
• Atributo privado mapaCarro do tipo Map parametrizado para os tipos Integer e ExemploCarro. Adicionar um objeto do tipo HashMap ao atributo criado.
Em seguida, criar os seguintes métodos:
• O método main() deverá apresentar um menu com duas opções:
- a primeira para cadastrar os dados, a segunda para listar os dados usando o atributo do tipo Map. A primeira opção deverá realizar a execução do método cadastrar() e - a segunda executar o método listar()
• O método cadastrar() deverá solicitar os dados para leitura do teclado.Atribuir esses dados lidos aos atributos de um objeto a ser criado do tipo ExemploCarro. Em seguida, adicionar esse objeto criado ao atributo mapaCarro por meio do método put(). Para a chave, utilizar o número do chassi.
• O método listar() deverá apresentar na tela os valores cadastrados no atributo mapaCarro usando um iterador. No caso do uso da interface Map , ocaminho para obter um iterador pode mudar. Em nosso exemplo utilizaremos um iterador por meio do método KeySet(). Vejamos um exemplo: Iterator<Integer> it = this.mapaCarro.keySet().iterator();
Com posse do iterador, podemos utilizar o método hasNext() para gerar um loop e recuperar todos os objetos gravados. Esse método deverá apresentar a data de fabricação que foi lida no formato AAAA/MM/DD no formato DD/MM/AAAA; utilizar o método split() da classe String.
SOBRE A AVALIAÇÃO P2
TRABALHO EM GRUPO DE 4 ALUNOS NO MÁXIMO
1- Desenvolver um texto que descreva as funcionalidades de cada uma das classes que estão presentes no Java Collections Frameworks. O texto deve destacar a característica de cada uma das classes, os principais métodos e, principalmente, a sua adequada utilização com exemplo curto de uma aplicativo.
3- O grupo deverá desenvolver um Projeto real (simples e totalmente livre) que faça o uso correto (conforme o próprio grupo destacou no item 1 acima) de pelo menos quatro classes do Java Collections Frameworks para armazenamento dos seus dados 2- O grupo deverá apresentar 10 (dez) questões de Certificação Java que estejam
relacionadas com Java Collections Frameworks e apresentar, sala de aula, a solução para os colegas de sala.
