luiz carlos d´oleron [email protected] sjcp java avançado java 1.5

Luiz Carlos d´[email protected]

SJCP

Java Avançado

Java 1.5

Luiz Carlos d´Oleron – [email protected]

Java 1.5 (Tiger) (Java 5.0)• Java 5.0 trouxe algumas mudanças

na sintaxe da linguagem.

• A API sofreu inserções e vários métodos depreciados foram removidos

• Calcula-se que menos de 50% dos programadores se beneficiem dos novos recursos da linguagem

• A maioria dos recursos novos do Tiger foram criados para diminuir a quantidade de código e facilitar a vida do programador

• A primeira versão Beta de Java 6.0, o Mustang, já foi lançada


Java 5.0 keywords


Java 1.5 (Tiger)

• Novo for

• Autoboxing/Unboxing

• Tipos enumerados

• Imports estáticos

• Variable Arguments – varargs

• Genéricos


Novo for

for (FormalParameter : Expression) {Statements

}

Expression precisa ser um array ou uma instancia da interface java.lang.Iterable.

• java.util.Collection extende Iterable.

• Não usa nenhuma palavra reservada nova! (each por exemplo)


Novo forpublic void oldFor(Collection c) {

for(Iterator i = c.iterator();i.hasNtext(); ){String str = (String) i.next();// "sb“ é uma instancia de StringBuffersb.append(str); }

}

public void newFor(Collection<String> c) {

for(String str : c) {sb.append(str);}

}


Novo forpublic int sumArray(int array[]) {

int sum = 0;for(int i=0;i<array.length;i++) {

sum += array[i]; }

return sum;}

public int sumArray(int array[]) {int sum = 0;for(int i : array) {

sum += i; } return sum;}


Autoboxing/Unboxing

• Autoboxing e Unboxing são formas de conversão implícita de tipos primitivos em Classes Wraper e vice-e-versa.

• Diminuem a quantidade de código de conversão

• Como a conversão é feita implicitamente, pode gerar dúvidas e confusões


Autoboxing/UnboxingList list = new ArrayList();//Sem Autoboxing/Unboxinglist.add(0, new Integer(59));int n = ((Integer)(list.get(0))).intValue();

//Com Autoboxing/Unboxinglist.add(0, 59); //Autoboxingint total = (Integer)list.get(0); //Unboxing


Autoboxing/Unboxing

• Sem autoboxing(java pré-1.5), o compilador não iria aceitar um int (inteiro, tipo primitivo) no lugar de uma instância, mesmo que de Integer.

list.add(0, 59); //Autoboxing

• O autoboxing é a capacidade do compilador de perceber essa situação de comflito entre tipos primitivos, convertendo no exemplo, implicitamente, o inteiro em uma instância de Integer. O mesmo ocorre com o unboxing

int total = (Integer)list.get(0); //Unboxing


Autoboxing/Unboxing

• Tiger converte a instância de Integer em um valor de tipo primitivo, no caso int. Isso é Unboxing

int total = (Integer)list.get(0); //Unboxing


Static ImportsImports estáticos, introduzidos a partir de java 5, permitem que

você importe campos e métodos de classes (além de classes). Assim, é possível se referenciar a campos e métodos de outras classes sem ter que usar o caminho completo.

//sem static importimport java.awt.Color;...Color cor = Color.GREEN;

//com static importimport static java.awt.Color.GREEN;...Color cor = GREEN;


Static Importsimport static java.lang.Math.*;import static java.lang.System.*;

class TesteStaticImport{

public static void main(String[] argv) {double x = sin(PI);out.println(x);

}}


Enumerations“An enumeration contains all possible values for a

particular object.”en.wikipedia.org

Tipos enumerados são aquele que podem ser contados. Os elementos de tais tipos podem ser associados com um sub-conjunto dos números naturais. O exemplo mais comum desses tipos são os dias da semana:

{domingo, segunda, terça, quarta, quinta, sexta, sábado}


Typesafe Enumerationspublic class MainMenu {

//Isso não é um tipo verdadeiro...//Não há segurança no tratamento do cliente que irá//manipular inteiros...

public static final int MENU_FILE = 0;public static final int MENU_EDIT = 1;public static final int MENU_FORMAT = 2;public static final int MENU_VIEW = 3;

}

//Usando Typesafe Enumerations public enum MainMenu {FILE, EDIT, FORMAT, VIEW};


Typesafe Enumerations

• Typesafe Enumerations é um pattern (Joshua Bloch, Effective Java Programming Language Guide)

• implementado automaticamente pelo javac 1.5.

• A palavra enum é agora keyword


Typesafe Enumerations• A declaração enum do exemplo gera uma classe

MainMenu que automaticamente implementa:– Comparable<MainMenu>;– Serializable;

• Com os seguintes comportamentos: – Variáveis estáticas FILE, EDIT, FORMAT, e VIEW – Método estático values(), que retorna um array

com as variáveis estáticas – Método estático valueOf(String), que retorna o

objeto relativo ao parâmetro – Métodos equals(), hashCode, toString(),

e compareTo() sobreescritos.


Typesafe Enumerationspublic class Exemplo {

public enum MainMenu {FILE, EDIT, FORMAT, VIEW}

public static void main(String[] argv) {

for (MainMenu menu : MainMenu.values()) System.out.println(menu);

}

}



enum é uma classe normal de java (com algumas restrições). Ela pode ter métodos (inclusive o main), atributos e construtores (todos private).



Diferente de outras classes, as instâncias de uma enum poderão ser utilizadas em um bloco switch.


Variable Arguments - varargs

void metodoComVararg(int i, String ... args) {System.out.println(“i = ” + i);for(String s : args)

System.out.println(s);}

// usando o método

metodoComVararg(10, “oi", “mundo", “!!!");


Variable Arguments - varargs

• Permite a passagem de um número previamente indeterminado de argumentos nos métodos

• Tem que ser o último argumento declarado no método

• Argumentos têm que ser de mesmo tipo ou tipo conversível (equivalente a um array)


Atividade Discursiva• Cite para cada uma técnica

nova apresentada em aula

– Uma ou mais qualidades

– Um ou mais pontos negativos

• Para os pontos negativos, proponha uma ou mais soluções (se houverem).


Java Avançado

Genéricos


Java e Tipos

• Java é uma linguagem “Fortemente Tipada”

• O tipo das variáveis deve ser definido desde a compilação e não pode ser alterado depois disso

• Java suporta herança e polimorfismo

• Pelo polimorfismo, durante a execução, objetos de diferentes tipos podem ser associados a uma variável, respeitando as regras de conversão (Assignment, Method Call e casting)


Java e Tipos

• Java fornece mecanismos de conversão implícita e explícita (usando cast)

• A validação da conversão explícita de java é feita parte em tempo de compilação, parte em tempo de execução...

• Assim, pode-se gerar códigos inseguros quanto ao tipo (type- unsafe), em outras palavras, pode ser possível que exceções (ClassCastException) sejam levantadas.

• Controlar estes problemas gera mais código de “proteção”, aumentando a complexidade do software.


ExemploDate hoje = new Date();List lista = new ArrayList();lista.add(hoje);lista.add(“10/12/2005”);

public void imprimirListaData(List datas){Iterator i = datas.iterator();while(i.hasNext()){

Date data = (Date)i.next();System.out.println(data);

} System.out.println(“A lista tem ” + datas.size() + “ datas.”);

}


Exemplo (continuação)Date hoje = new Date();List lista = new ArrayList();lista.add(hoje);lista.add(“10/12/2005”);

public void imprimirListaData(List datas){Iterator i = datas.iterator();while(i.hasNext()){Object o = i.next();if(o instanceof Date){Date data = (Date)o;System.out.println(data);}}System.out.println(“A lista tem ” + datas.size() + “ datas.”);

}


Genéricos• Evolução natural do Paradigma OO

• Maior robustez e segurança: evita cast´s, instanceof´s e, principalmente, ClassCastException´s :D

• Ferramenta eficaz na modelagem correta de sistemas OO

• Código mais simples de ler, manter e implementar. Erros de tipo são conhecidos pelo programador em tempo de compilação.

• Robustez, clareza, segurança? Qualidade$ !


Re-Exemplo com genéricosDate hoje = new Date();List<Date> lista = new ArrayList<Date>();lista.add(hoje);//Erro de compilação. Retirar esta linha e nada mais:lista.add(“10/12/2005”);

public void imprimirListaData(List<Date> datas){Iterator<Date> i = datas.iterator();while(i.hasNext()){

Date data = i.next();System.out.println(data);

} System.out.println(“A lista tem ” + datas.size() + “ datas.”);

}


Definindo uma classe genéricapublic class Registro<K,V>{

private K chave;private V valor;

Registro(K chave,V valor){this.chave = chave;this.valor = valor;

}

}...Registro<String, Integer> registro =

new Registro<String, Integer >(“um”,new Integer(1));

...


Limite Inferiorpublic class Registro<K,V extends Number>{

private K chave;private V valor;

Registro(K chave,V valor){this.chave = chave;this.valor = valor;

}}//OKRegistro<String, Double> registro =

new Registro<String, Double >(“um”,new Double(1.0));

//Erro de compilaçãoRegistro<String, Endereco> registro =

new Registro<String, Endereco >(“um”,new Endereco());


Genéricos e Coleções• Genéricos são muito utilizados com coleções.

• Por exemplo, até Java1.4, um ArrayList era uma coleção de Object, mesmo que durante a execução, instâncias de vários tipos pudessem estar associadas a ele.

ArrayList listaInteiros = new ArrayList();listaInteiros.add(new Integer(2));//OKlistaInteiros.add(new String(“2”));//OK

Integer i = (Integer)listaInteiros.get(1); //Erro execução


Genéricos e ColeçõesCom genéricos é bem melhor!

ArrayList<Integer> listaInteiros = new ArrayList <Integer>();

listaInteiros.add(new Integer(2));//OKlistaInteiros.add(new String(“2”));//Erro de compilação

Integer i = listaInteiros.get(0);//Não precisa de cast


Coleções Genéricas e Novo For

ArrayList<Integer> listaInteiros = new ArrayList <Integer>();

listaInteiros.add(new Integer(1));listaInteiros.add(new Integer(2));

for(Integer i:listaInteiros ){out.println(i);

}


Genéricos e UnboxingCom genéricos é bem melhor!

List list<Integer> = new ArrayList<Integer>();

//Com Autoboxing/Unboxinglist.add(0, 59); //Autoboxing

//Antes era assim://int total = (Integer)list.get(0); //Unboxing//Usando Genéricos:int total = list.get(0); //Unboxing


Genéricos e Type SafetyO javac 5.0 irá reclamar a você sobre ações inseguras

quanto ao tipo.

1. List list = new ArrayList();2. list.add("teste");

Por exemplo, na linha dois, irá aparecer o warning “Type safety: The method add(Object) belongs to the raw

type List. References to generic type List<E> should be parameterized”


Genéricos e Type SafetyApesar de existirem formas de ocultar warnings, a melhor

forma de corrigir esse problema é definindo corretamente a variável list.

1. List<String> list = new ArrayList<String> ();2. list.add("teste");

Retirando assim o warning e impondo segurança quanto ao tipo.

luiz carlos d´oleron [email protected] sjcp java avançado java 1.5

Documents