introdução ao java 5
DESCRIPTION
Apresentação sobre as novas funcionalidades do Java 5.TRANSCRIPT
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...