segunda-feira, 27 de julho de 2009

Collection

Olá a todos que acompanham ao blog, hoje pretendo escrever sobre o maior assunto que é cobrado na prova de certificação programador Java ou SCJP. Na minha opinião, é o maior assunto, mas não é o mais complicado, isso fica por conta de um assunto chamado: Thread (falarei disso em outra postagem). Como o assunto é grande, não pretendo abordar detalhadamente tudo e sim, escrever sobre alguns tópicos importantes.
É fundamental saber que a API de conjuntos é formada por Interfaces(List,Set e etc) e Classes(ArrayList, TreeSet e etc).
Principais INTERFACES que é preciso saber para a prova( e para a vida real): Collection, List, Set, Map, Queue, SortedMap e SortedSet. Classes concretas que é preciso saber: HashMap, Hashtable, TreeMap, LinkedHashMap, HashSet, LinkedHashSet, TreeSet, ArrayList, Vector, LinkedList, PriorityQueue, Collections e Arrays.
Os conjuntos são divididos em quatro tipos: Listas, Conjuntos, Mapas e Filas. E ainda tem mais quatro características: Classificada, não Classificada, Ordenada e não Ordenada. Obs: um conjunto pode ser não-classificado e não-ordenado, ordenado e não-classificado ou ordenado e classificado, mas nunca pode ser classificado e não-ordenado( porque classificação é um tipo de ordenação).
Abordando as Interfaces
LIST: é o conjunto que o índice tem relevância, é o único que tem o método indexOf(). Classes Concretas:
  • ArrayList: é como uma array que pode crescer.
  • Vector: é semelhante ao arraylist, a diferença é que tem os seus métodos sincronizados em relação a thread.
  • LinkedList: tem os seus elementos duplamente encadeados entre si. Essa classe também implementa a interface Queue, entao também tem os métodos: peek, poll e offer.

SET:da relevância a exclusividade, assim não permite elementos duplicados. O método equals() determinará se os elementos são iguais.
  • HashSet: usa o código hashing do objeto para fazer a inserção.
  • LinkedHashSet: é uma versão ordenada de HashSet, mandando uma lista de encadeamento duplo para os elementos.
  • TreeSet: garante que os elementos fiquem em sequencia ascendente.

MAP: identificadores exclusivos é que são relevantes. Uma classes exclusiva (o identificador) é mapeada para um valor.
  • HashMap: é um conjunto não-classificado e não-ordenado; e a ordem de iteração não é relevante.
  • Hashtable: é similar ao HashMap, a diferença é que os métodos são sincronizados em relação a thread.
  • LinkedHashMap: esse conjunto mantém a ordem de inserção.
  • TreeMap: é classificado e é possível especificar como os elementos devem ser comparados entre si quando forem ordenados.

QUEUE: armazena uma lista de “coisas a fazer”, é um tipo de FIFO(primeiro que entrar, primeiro a sair)
  • PriorityQueue: esse conjunto criar uma fila com ordenação, assim os elementos são ordenados.

Observação: ao utilizar conjuntos que usem o método Object.hashcode(), por exemplo: HashSet ou LinkedHashSet, iteração ou adição sobre o conjunto. É fundamental que seja feito a sobreescrita correta do hashcode para não permite elementos duplicados.

Classificando Conjuntos
Os conjuntos podem ser classificados de diversas maneiras, por exemplo, um ArrayList de String é classificado alfabeticamente. Para fazer isso é utilizado o método “sort” da classe concreta Collections. Exemplo:
List lista = new ArrayList();
lista.add("B");
lista.add("C");
lista.add("A");
System.out.println(lista); // saída: [B,C,A]
Collections.sort(lista);
System.out.println(lista); // saída: [A,B,C]

Existe ainda a possibilidade de utilizar as interfaces: java.lang.Comparable ou java.util.Comparator, para fazer classificação.
Quando uma classe implementar a interface Comparable é necessário sobreescrever o método: compareTo(Object). E uma classe implementar a interface Comparator é necessário sobreescrever o método: compare(Object,Object).

Classificando Arrays
Os arrays também podem ser classificados, semelhante a Conjuntos. A classificação é feita também através do método “sort” só que é utilizada a classe Arrays. Exemplo:
String [] array = new String[]{“B”,”C”,”A”};
for (String s : array)
System.out.printf(s + “ ”); // saída: B C A
Arrays.sort(array);
for (String s : array)
System.out.printf(s + “ ”); // saída: A B C

Convertendo Arrays em Lista e Listas em Arrays
Existem métodos que permitem converter arrays em Lists e Lists em arrays. As classes do tipo List e Set possuem métodos toArray e a classe Arrays possui o método asList. É importante escrever o que a documentação do método Arrays.asList() explicar:“retorna uma lista de tamanho fixo e modificações feitas na lista são escritas diretamente no array.”. Ou seja, o array e o List ficam unidos como se fossem um só.
Exemplo de Arrays.asList:
String [] sa = {“a”,”b”,”c”};
List sList = Arrays.asList(sa);
Exemplo de toArray():
List lista = new ArrayList();
Integer [] x = (Integer[]) lista.toArray();

observação: o método toArray retorno uma array do tipo Object então é necessário fazer Cast.

Fazendo interação antes do Java 5.
Antes do loop for aprimorado, a maneira mais comum de fazer interação sobre List “elemento por elemento” era com o Iterator. Um Iterador é um objeto associado com um conjunto específico. Os dois métodos que é preciso conhecer para a prova de SCJP são: hasNext(), que retorno um boolean mas não move o próximo elemento e next() que retorno o próximo elemento do conjunto.
Exemplo:
List lista = new ArrayList();
lista.add("B");
lista.add("C");
lista.add("A");
Iterator x = lista.iterator();
while(x.hasNext()){
String ss = x.next(); // devido um iterator ser criado com a sintaxe de genéricos não é preciso fazer cast na chamada do método hext();
}

Como falei no início do post não vou escrever tudo sobre conjuntos, se não ficaria muito cansativo. Assunto relacionados a criação de classes e métodos genéricos ou procura de elementos em um List, são outros assunto que devem ser estudados para a prova. Mas vou escrever alguns tópicos interessantes.
  • O método add() da interface Set retorna um boolean(true se o elemento foi inserido ou false se o elemento não foi inserido);
  • Não existe o método add() em Map, para adicionar elementos em Map é utilizado put();
  • Os métodos peek(),poll() e offer() só são encontrado na interface Queue;
  • Para fazer interação em um conjunto, é preciso que os elementos sejam compatíveis, caso isso não aconteça vai ser lançada uma exceção.
  • ArrayList o método size() para retornar a quantidade de elementos.


Vou parando por aqui. Espero ter ajudado em alguma coisa e desculpa se escreve alguma besteira. Estamos aqui para qualquer coisa. Críticas, sugestões, reclamações ou qualquer outra coisa para melhorar, é sempre bem vindo.

Abraaaaaaaaço e até a próxima.

segunda-feira, 20 de julho de 2009

53 palavras

Olá a todos que acompanham o blog da comunidade de Java de Alagoas.
Continuando a escrever sobre tópicos da prova de certificação Java programador (SCJP) SUN. Hoje pretendo escrever algo “leve” sobre Java, algo que mesmo quem não esta estudando para certificação deve saber ou pelo menos ter uma ideia. E o assunto do post é: Palavras Reservadas.
O que seriam palavras reservadas? São palavras que não podem ser usadas como identificadores( nome de classes, métodos ou variáveis).
Alguem tem alguma idéia de quantas palavras existem em Java que são reversadas e qual a funcionalidades que elas tem?! Atualmente em Java(1.6) existem 53 palavras que são reversadas. No Java 1.4 eram 52 palavras e no Java 1.3 eram 51.
Alguns podem pensar que 53 palavras é muita coisa para saber, mas se for analisado bem é muito provável que um programador, mesmo que seja iniciante, já sabe mais de 60% das palavras reservadas.
As primeiras 26 palavras:
public, private, protected;
byte, short, int, long, float, double, boolean, char;
if, while, for, do, switch, case, default, break, continue,else;
try, catch, finally, throw, throws.

Facilmente, é possível contar 26 palavras reservadas. Só utilizando palavras que são utilizadas para uso de visualização de métodos, tipos de variáveis primitivas, controle de fluxo e exceções e possível contar quase a metade das palavras.
Continuando, mais 15:
package, import, extends, implements, class;
new, false, true, final, interface;
return, static, this, super, instanceof.

Estamos quase acabando, agora já temos 41 palavras reservadas.
Agora vai acabar.
abstract, assert, null;
enum,void,synchronized;
volatile, strictfp,trasient,native;
goto, const.

Pronto, já escreve todas as 53 palavras reservadas que existem em Java. Fácil, não?
Para acabar esse post, vou escrever para que serve algumas palavras que alguns nunca sabiam que existiam, como por exemplo: strictfp.
strictfp – é usado em métodos e classes para forçar os pontos flutuantes a aderirem ao padrão IEEE754.
native – é usado em método que serão implementado pelo sistema operacional. Um método que usa native em sua descrição não tem corpo e com isso, termina com “;”.
synchronized – é utilizado em métodos que só pode ser acessado por um thread de cada vez.
goto e const – são utilizadas para NADA. É isso mesmo, essa palavras não tem funcionalidades, os arquitetos de Java pensarão que essas palavras serviram utilizadas em algum momento, então tonaram essas palavras reservadas.
volatile – particularmente eu não usei essa palavra e para o exame SCJP, a pessoa só precisa saber que essa palavra é só utilizada em variável de instância.
transient – é utilizado em variáveis de instância para avisar a JVM que essa variável não vai ser serializada.

Era só isso vim escrever para vocês. Espero que ter ajudado e contribuído o crescimento do conhecimento. Desculpa se escreve alguma coisa errada e qualquer coisa estamos ai.

Abraaaaço e até a próxima.

Fonte: livro da Kathy Sierra, Certificação Sun para programador Java 5, guia de estudo.

domingo, 12 de julho de 2009

O simples/chato Array

Olá a todos do blog, escrevendo mais sobre alguns tópicos da certificação SCJP. E o assunto de hoje é Array. Lembro de uma simples trabalho da faculdade sobre orientação a objeto que tive que fazer em todo 6 arrays. Vamos começar!
Arrays são objetos que armazenam diversas variáveis do mesmo tipo, podendo armazenar variáveis de referência, primitivos ou objetos. É bom lembrar mesmo se for criado um array de tipo primitivo, na compilação os primitivos são convertidos para as suas respectivas classes Wrappers. Exemplo. int -> Integer.
Declaração de Array:
Int [] X ou int X[] // declaração do tipo de armazenamento, int é o tipo e X é o nome do array.
Thread[] t ou Thread t[] // declaração de um array que vai armazenar objetos de Threads.
Lembrando que nunca é válido incluir o tamanho do array da declaração. Exemplo: Int [3] X;
Construção do Array:
Construir o array significa a criação do objeto na memória, através da palavra-chave new ou com o uso de uma sintaxe abreviada. Para ser criado o array é necessário informar a quantidade de elementos do array ou informar diretamente os elementos. Exemplos:
Int [] X= new int[5]; // criando um objeto array com cinco espaços para armazenamento de tipos int.
Int [] X = {2,3,4,5}; // criando um objeto array já informando quais os elementos que ficaram no objeto, sintaxe abreviada.
Pontos importantes, parte 1:
-Não informar a quantidade de elementos na construção de um array, vai gerar um erro de compilação. Exemplo: Int [] X= new int[];
-Na criação de um array que armazena referencia de objetos, exemplo: Thread[] t = new Thread[5], não esta sendo criado nenhum objeto do tipo Thread. O único objeto que foi criado, foi o t, que é o array.
Array multidimensionais
A definição de arrays multidimensionais é bem simples, são arrays com outros arrays armazenados. Exemplo: String [] [] nomes.
Inicializando um array
Inicializar um array significa armazenar os itens nele. Os itens do array são os elementos que ficaram alocados nele dependendo da declaração do tipo do array. Os itens são organizados pelo índice, sempre começando do zero. É possível acessar diretamente um elemento informando índice dele. Exemplos:
Animal [] animais = new Animal[3]; // só existe um objeto agora, que é o animais, é um array que armazenará elementos do tipo de Animal;
Animais[0] = new Animal(); // esta sendo criado um objeto do tipo de Animal e alocando ele no array animais no índice zero
Animais[1] = new Animal(); // esta sendo criado um objeto do tipo de Animal e alocando ele no array animais no índice um
Animais[2] = new Animal(); // esta sendo criado um objeto do tipo de Animal e alocando ele no array animais no índice dois
Agora esse código contém 4 objetos, um do tipo array e três do tipo de Animal.
É importante qual é o ultimo índice de um array. Tentar acessar um índice que não existe gerar um exceção do tipo ArrayIndexOutBoundsException. Exemplo:
Animal [] animais = new Animal[3];
Animais[2] = new Animal(); // o índice 2, é o ultimo índice acessível do array pois a quantidade de elementos que o array comporta no máximo 3 e lembrando que os índices começam no zero.
Animais[3] = new Animal(); // não é possível fazer isso, pois o índice de numero 3 não existe no array.
Lembrando também que os índices não podem ser numero negativos. Exemplo:
Int []teste= new int[5];
Int y = -2;
teste[y] = 3; // não é valido, porque y é o numero negativo;
Pontos importantes, parte 2:
- é possível inicializar dinamicamente os valores de um array, através de loop for e utilizando o atributo length de array. Exemplo:
Animal [] animais = new Animal[50];
for(int i = 0; i
animais[i] = new Animal(); // atribui o novo elemento Animal na posição do índice i;
-array tem o atributo length e String tem o método length(). Existe questões da prova que abordam isso.
Array de referencia a objetos

Se o tipo declarado de um array for uma classe, esse array armazenar qualquer objeto subclasse do tipo declarado. Exemplo:
class Car{}
class Gol extends Car{}
class Ferrari extends Car{}
class Aviao{}
utilizando o array: Car[]carros = new Car[4];
carros[0] = new Car();
carros[1] = new Gol();
carros[2] = new Ferrari();
Todas as declarações são verdadeiras, pois esta sendo adicionados ao array objetos que são subclasse de Car. Utilizando o código: carros[3] = new Aviao(); não é possível já que não é uma subclasse de Car.

Depois de muito escrever vou ficando por aqui. Espero ter ajudado. Lembrando que existem algumas coisas que não abortei nesse post (como procura de dados através o método binarySearch). Lembrando também que é sempre bom estudar mais um pouco sobre array antes de fazer a prova de certificação e para o dia-a-dia também.
Qualquer coisa estamos ai.

Ate à próxima.

domingo, 5 de julho de 2009

Post extends Exception

Voltando a falar de tópicos que são abortados na prova de certificação SCJP. Algumas pessoas já devem ter percebidos que esse post vai ser sobre Exceptions. Nesse assunto não esta só relacionada à prova, qualquer pessoa que já tenha escrito algum sistema, mesmo que seja básico, já deve ter se deparado com esse mecanismo. Vamos ao assunto.
No desenvolvimento de software qualquer desenvolvedor deve ter em mente que em algum momento vai escrever algum que código que terá chance de provocar algum tipo de erro, erros também podem acontecer por causa do hardware. Para que exista uma manipulação eficiente desses erros, a linguagem Java fornece a manipulação de exceções.
Com essa manipulação os desenvolvedores poderão detectar erros e ainda fornece a possibilidade de lida com exceções de diferentes tipos. Mas o que seria uma exceção? É uma ocorrência que altera o fluxo normal do programa.
Existem 3 palavras que estão diretamente relacionada com o tratamento de exceções: TRY, CATCH e FINALLY. Vamos falar dos dois primeiros.
TRY é usado para indicar um bloco de código que poderá gerar alguma exceção, esse bloco é chamado de região protegida. Uma ou mais cláusulas de CATCH (manipuladores de exceção) poderão ser relacionadas para exceções especificas. Exemplo:
try{
//linha 1
//linha 2
}catch(exception1){
// linha 3
} catch(exception2){
// linha 4
}
//linha 5
Nesse pseudocódigo a linha 1 e 2 constituem a região protegida. A linha 3 esta no bloco de catch do tipo exception1, significando que se acontecer alguma exceção na linha 1 ou 2 e a exceção por desse tipo, o código da linha 3 executará. A área que a linha 4 esta é o bloco do catch relativo ao tipo de exception2, então se alguma exceção acontecer no bloco do try (linha 1 e 2) e for do tipo exception2, a linha 4 ira ser executada. Caso alguma exception ocorra no bloco try, a execução vai pular o código restante do bloco e vai começar a executar o bloco catch do tipo da exception e depois passará para a linha 5 e continuar a executar.
Falando agora da terceira palavra relacionada com exceções. FINALLY é um bloco de código que sempre será executado depois do bloco TRY, mesmo se uma exceção for lançada ou não. Caso uma exceção ocorra no bloco try, a execução passar para o bloco catch relacionada a essa exception e depois executará o bloco finally.
try{
// linha 1
// linha 2
}catch(exception1){
//linha 3
}finally{
//linha4
}
Explicando o código. Como antes a execução começar na linha1 do bloco try, caso uma exception ocorra e essa do tipo exception1 então a execução passara para o bloco do catch e depois ira executar o bloco do finally. Caso nenhuma exception ocorra no bloco try, a execução ira direto para o bloco try. Lembrando, finally sempre será executado (existem poucos casos aonde ele não será executado).
Demonstrarei alguns códigos validos e não-validos em relação a try, catch e finally.
try{

}finally{

}
O código acima é valido, um bloco try tem que ter um bloco finally ou pelo menos um bloco catch.
try{

}
System.out.print(“alguma coisa”);
Não é valido, pois não existe nem bloco try e nem catch.
try{
}
System.out.print(“alguma coisa”); // erro aqui
catch{
}
Não pode existe código entre os blocos try e catch.

Irei falar agora da Hierarquia de Exceções.
Toda as classes de exceções são subtipos da classe Exception. Essa classe é subtipo da classe Throwable que é subtipo de Object.
Throwable tem duas classes que são subtipos dela: Exception e Error. As classes que são subtipos de Error, são situações incomuns como memória cheia, por isso é inviável fazer o tratamento essas erros.
Para ter mais informações sobre a exception gerada, existe um método em Throwable que é o printStackTrace que fornece mais informações sobre a exceção que foi lançada. Exemplo:
try{
}catch(Exception e){
e.printStackTrace;
}

Falando agora de blocos de catch. Um bloco catch que tenha referencia a uma exception não pode vim depois um catch que seja maior que essa exception. Exemplo.
try{
}catch(IOException e){
}catch(FileNotFoundException e){
}
Esse código não compila pois a exception FileNotFoundException é um tipo de IOException então não pode vim depois.
Existem dois tipos de exceções, checadas e não-chegadas. Toda exceção que esteja abaixo de Exception é checada, mas RuntimeException não é chegada e é subtipo de Exception. Qualquer evento que esteja abaixo de Error é não checada. E qualquer exceção que seja criada, utilizando extends Exception é checadas.
Métodos que lancem exception do tipo checadas tem que existe em sua discrição uma informação sobre essas exceções, isso é feito através da palavra: THROWS. Exemplo:
public void myFunction() throws IOException, MyExpection{
}
Escrevendo código, é possível lançar exception utilizando a palavra reservada THROW. Exemplo:
public void myFunction2(){
throw new IOException;
}
Um método que esteja chamando outro método que lance exceções checadas deve tratar essa exception (utilizando try e catch) ou relançar essa exception utilizando THROWS. Exemplo:
void doStuff(){ // esse método deve utilizar try e catch ou utilizar throws
doMore();
}
void doMore(){
throw new IOException;
}

Estou acabando esse post (que foi enorme). Exceções é um assunto aparece por toda a prova e é sempre bom estudar um pouco mais. Espero que tenha ajudado com alguma coisa e desculpa de escrevi alguma coisa errada.

Fonte: Livro da Kathy Sierra, Certificação Sun para programador Java 5, guia de estudo.