Introdução ao Java 1.5

Maurício Linhares

Java 5 ou Java 1.5?

5 é o número oficial, 1.5.0 é o número interno da versão da implementação da Sun;

J2SE, J2EE e J2ME foram substituídos por Java SE, Java EE e Java ME;

Decisão do “departamento de Marketing” da Sun;

O Java 5 ainda é novidade?

Ainda...

Pouca gente conhece e utiliza as novidades;

Poucas bibliotecas e frameworks foram atualizados;

Muita gente depende de servidores de aplicação pagos, que não foram atualizados ($$$);

Por que se preocupar com isso?

Por causa das mudanças!

A maior alteração do Java desde o 1.0;

Muitas mudanças na linguagem (Genéricos, Anotações, Enums);

Muitas mudanças na JVM (Gerenciamento, Performance);

Melhoras na interface gráfica;

Como era o Swing

Novo Swing!

Swing no Windows XP

Swing no KDE (Linux)

Monitoramento da JVM no Java 5

A JVM do Java 5 vem com o “jconsole”, uma aplicação de gerenciamento de aplicações;

Ele monitora todo o funcionamento da JVM a qual ele se conectar;

Ele se conecta a qualquer aplicação Java na máquina ou a aplicações remotas, via sockets;

jconsole em ação

Vantagens?

Centralização das informações sobre a “saúde” das aplicações;

Console genérico que pode acessar objetos expostos via JMX pela aplicação que está rodando na JVM;

Vem automaticamente em qualquer instalação do JDK;

Performance

A JVM 5 é ainda mais rápida do que a sua antecessora;

Novas heurísticas de melhora de desempenho foram adicionadas (como coletores de lixo assíncronos);

Melhorias nos compiladores “Client” e “Server”;

Escolhendo uma configuração da JVM

Client Aplicações que executam por pouco

tempo; Aplicações que precisam de uma carga

rápida na memória; Mais indicado para aplicações com

interfaces gráficas simples; Ocupa menos memória, mas é mais

lenta;

Escolhendo uma configuração da JVM

Server Indicado para aplicações que executam

por muito tempo; Ocupa muito mais memória do que a

versão Client (lembre-se de aumentar o heap se necessário);

Mais lenta para carregar inicialmente, mas mais rápida no longo prazo se comparada a client;

Como escolher?

java –client

java -server

Mas cadê o código?

Novidades da linguagem Java

Tipos genéricos (palestra de Fred!); For Each; Enumerações; Argumentos de tamanho variável; Anotações (Annotations); Programação concorrente (palestra

de Érika!) Autoboxing – Autounboxing E ainda mais algumas coisas...

For-each

String[] nomes = { “Java", “C#" };

for (String nome : nomes) {System.out.println("Nome: “+ nome);

}

For-Each com coleções

List<String> bandas = new ArrayList<String>();

strings.add(“Lordi”);strings.add(“Iron Maiden”);

for (String banda : bandas) {System.out.println("Nome: “+ nome);

}

Porque usar o “for” avançado?

Simplifica o acesso a objetos que estejam dentro de coleções;

Diminui a quantidade de código necessária para se trafegar em uma coleção;

Não é necessário manter “contadores”;

O que acontece de verdade?

O for-each é transformado em um for comum, assim como o que nós teríamos esquecido;

Ele transforma em um for para os for-eachs com arrays e em outro for para os for-eachs usando coleções;

Possível tradução do for

For avançado traduzido com array

String[] nomes = { “Érika", “Fred" };

for (int i = 0; i < nomes.length; i++) {out.println("Nome: “ + nomes[i]);}

Preste atenção!

Mudanças introduzidas no compilador

As mudanças da linguagem Java na versão 5, são, em sua maioria, implementadas pelo próprio compilador, para manter a compatibilidade com versões anteriores

Nem tudo são objetos

A linguagem Java não é puramente orientada a objetos, pois existe um conjunto de tipos primitivos que formam a base da linguagem:

int, long, float, double, byte e char

Entendendo o problema

Tipos primitivos não herdam de Object, portanto não é possível se utilizar de polimorfismo nem herança;

Tipos primitivos são sempre passados por valor e nunca por referência;

Não podem ser adicionados as coleções comuns do Java;

Oferecendo uma solução

Criar tipos “empacotadores” para os tipos primitivos;

Cada tipo primitivo tem o seu próprio objeto empacotador que vai guardar o valor primitivo;

Podem ser adicionados normalmente a coleções e também podem ser utilizados em casos de polimorfismo;

Tipos empacotadores

Integer; Long; Double; Float; Character; Byte;

Ainda existem problemas?

Não é possível fazer operações em tipos “empacotadores”, os operadores aritméticos não funcionam;

Os tipos primitivos tem que ser passados como parâmetros nos construtores dos tipos empacotadores;

Utilizando tipos empacotadores

List lista = new ArrayList();

Lista.add( new Integer(100));

Alguém tem que simplificar isso

Mas como?

Com autoboxing (auto-empacotamento) e autounboxing (auto-desempacotamento) de tipos.

Autoboxing – empacotamento

Transforma tipos primitivos automaticamente em tipos “empacotadores”, sem que o programador tenha que se preocupar com isso, sempre que uma transformação for necessária.

Exemplo

List lista = new ArrayList();

Lista.add( 100 );

Autounboxing - desempacotando

Transforma os tipos empacotadores em tipos primitivos quando isso for necessário, como na avaliação de expressões aritméticas, condições e avaliações lógicas.

Exemplo

Integer primeiro = 500;Integer segundo = 200;

System.out.printf("O valor do número é %d",

primeiro + segundo);

Como está acontecendo?

Quando ele faz o autoboxing, cria um objeto empacotador e passa o tipo primitivo para ele, quando ele faz o autounboxing ele retira o tipo primitivo do tipo empacotador.

Esse tipo de transformação cria novos objetos e deve ser utilizada com parcimônia em cenários onde a performance é importante.

O que são enumerações?

São uma classe especial onde todos os seus possíveis valores são conhecidos quando o tipo é definido, formando um conjunto.

O conjunto de naipes de um baralho é um tipo que representa uma enumeração:

{ Copas, Paus, Espada e Ouro }

Declarando uma enumeração

public|protected|private enum Nome

{ }

Exemplo de enumeração

public enum Naipe {PAUS,OUROS,COPAS,ESPADAS

}

Utilizando enumerações

Naipe naipe = Naipe.ESPADA;

if (naipe == Naipe.ESPADA ) {System.out.println

("O naipe recebido foi ESPADA");

}

Switch com enumerações

public static void switchComNaipes(Naipe naipe) {

switch (naipe) {case ESPADA :out.println("O valor recebido foi: ESPADA");break;

case COPAS :out.println("O valor recebido foi: COPAS");break;

}

}

Static imports vem ao resgate

Importa classes, variáveis e enumerações estáticas para a sua classe, acabando com a necessidade de se digitar todos aqueles caminhos outra vez.

Sintaxe

static import nome.do.campo.Static

Exemplo

//importsimport static java.lang.System.err;import static java.lang.System.out;

//usoout.println(“Alô?” );

System.out.println(“Alô?”);

Usando curingas

Os curingas (*) podem ser utilizados para importar conjuntos inteiros de métodos e campos estáticos em uma classe.

Exemplo

//importimport static java.lang.Math.*;

//uso out.println("O resultado é “ +

( random() + abs(15.21) )

);

Problemas

Importar muitos campos como os da classe Math deixam o código confuso, pois não é fácil identificar os métodos que pertencem a classe.

Documentando um arquivo .java

/** * Created: 10 * Created By: Maurício * Last Modified: 51 * Last Modified By: Maurício * Revision: 5 */

Refazendo com uma anotação

public @interface ClassInfo {

String criadaEm();String criadaPor();String ultimaModificacaoEm() default "";String ultimaModificacaoPor() default "" ;int revisao() default 1 ;

}

O que são anotações

São um tipo especial de interface, definidos usando a palavra reservada interface precedida de um @;

Uma anotação pode ser declarada em qualquer lugar que uma interface possa ser declarada;

Anotações devem ser utilizadas para guardar informações sobre o código onde elas são aplicadas;

Propriedades válidas em uma anotação

Tipos primitivos, Strings, outra anotação, um Class<T> ou um array de quaisquer destes tipos;

O elemento não pode declarar parâmetros;

O elemento não pode ter uma cláusula de lançamento de exceção (“throws”);

O elemento não pode definir parâmetros genéricos;

Utilizando a anotação criada

@ClassInfo(criadaEm = "10",criadaPor="Maurício",ultimaModificacaoEm=

"14/03",)

public class Classe {}

Elementos que recebem anotações

Declarações de tipo, declarações de campos, métodos e construtores podem ser anotados;

Para anotar um elemento, basta adicionar a anotação antes dele;

Um elemento só pode ter uma anotação de cada tipo;

Exemplo do uso de uma anotação em um método

@Deprecatedpublic void metodoAntigo() {}

Quando a anotação não tem campos ou todos os seus campos tem valores “default” não é necessário colocar os parênteses “()” no fim

Anotações comuns do Java 1.5

@Deprecated; @Documented; @Inherited; @Override; @SupressWarnings;

E o próximo Java?

Mais melhoras na performance (não vão mais existir os compiladores “Client” e “Server”);

Acesso a “área de notificação” (área do relógio);

Novas classes para se acessar o compilador do Java diretamente;

E o próximo Java?

Suporte a linguagens de Script JavaScript (automático) BeanShell Groovy VisualBasic!?!?!?!?

Acesso a novas primitivas de hardware, como o disco rígido do sistema;

Então...