Melhorias na linguagem Java com Project Coin

Project Coin: Pequenas
mudanças, grandes
facilidades
Marcelo de Castro
Wellington Ricardo Pinheiro

domingo, 31 de março de 2013

Melhorias na Linguagem Java
• Máquina Virtual
• Linguagem (sintaxe e semântica)
• Class Loader
• Internacionalização
• I/O e Rede
• Segurança e Criptograﬁa
• JDBC
• Camada Cliente
• Gerenciamento (JMX e MBeans)


Melhorias na Linguagem Java
(sintaxe e semântica)

• JSR 334: Small Enhancements to the JavaTM
Programming Language
• Especiﬁcação do projeto Coin (subprojeto
do OpenJDK)
• O objetivo do projeto é prover melhorias
para a linguagem Java


Separador de dígitos em
literais numéricos
public class SeparadorDigitos {
public static void main(String[] args) {
int i = 1_234_567_890;

// isso é medonho...mas compila!
Integer i1 = new Integer(12_34_56_78_90);
Integer i2 = new Integer(1_2_3_4_5_6_7_8_9_0);

System.out.println(i == i1); // imprime true
System.out.println(i1.equals(i2)); // imprime true
}
}


literais numéricos
Também é possível fazer isso:

float f1 = 123_456.7_5F;
double d1 = 12____345D;
double d2 = 0x1.ffff_ffff_ffff_fP1_023;


literais numéricos
Também é possível fazer isso:

float f1 = 123_456.7_5F;
double d1 = 12____345D;
double d2 = 0x1.ffff_ffff_ffff_fP1_023;

Isso não compila:
int intRuim1 = _1234;
int intRuim2 = 1234_;
float zuado = 123_456.75_F;


Literais binários
Tarefa: Construir um método para imprimir os estados de uma
válvula, que podem ser:

001 Alarme

010 Fechada

100 Aberta

o método recebe como entrada um inteiro com obtido na última
leitura e deverão ser veriﬁcados quais os bits de estado estão com
o valor 1.


Literais binários
1 public static final int ALARME = 0b001; // o valor é 1
2 public static final int FECHADA = 0b010; // o valor é 2
3 public static final int ABERTA = 0b100; // o valor é 4

4 public void mostraEstado(int ultimaLeitura) {
5 final int[] mascaras = {ALARME, FECHADA, ABERTA};
6 final String[] mensagens = {"alarme", "fechada", "aberta"};

7 for (int i = 0; i < mascaras.length; i++) {
8 if ((ultimaLeitura & mascaras[i]) == mascaras[i])
9 System.out.print(mensagens[i] + " ");
10 }
11 System.out.println();
12 }


String na condição do switch

• Os compiladores são responsáveis por
traduzir um switch de strings em bytecode
com a semântica adequada
• Suporte direto a strings no switch pode ser
adicionado em uma futura versão da
plataforma


String na condição do switch
1 public static void main(String[] args) {
2 for (String arg : args) {
3 switch(arg) {
4 case "-o1":
5 System.out.println("modo de alta otimização (+lento)");
6 break;
7 case "-o0":
8 System.out.println("modo de baixa otimização (+rápido)");
9 break;
10 default:
11 System.err.printf("Parâmetro %s inválido. n", param);
12 System.exit(-1);
13 }
14 }
15 }


Inferência na criação de
objetos com tipos genéricos
• Desde a introdução dos tipos genéricos,
construções com tipos genéricos explícitos podem
ser atribuídos à variáveis raw type (sem generics)
ou com um wildcard:

// Java 5+
// desencorajado, mas legal
List rawList = new ArrayList<Object>();
List<?> wildList = new ArrayList<Object>();

// consequentemente, no Java 7:
List rawList = new ArrayList<>();
List<?> wildList = new ArrayList<>();



1 public class InferenciaCriacao {

3 Map<Integer, Set<Integer>> mapOfIntegers =
4 new HashMap<Integer, Set<Integer>>();
5 Integer aKey = 10;

6 Set<Integer> aSet = new HashSet<Integer>();
7 mapOfIntegers.put(aKey, aSet);
8 }
9 }




4 new HashMap<>();

6 Set<Integer> aSet = new HashSet<>();
7 mapOfIntegers.put(aKey, aSet);
8 }
9 }




4 new HashMap<>();

6 Set<Integer> aSet;
7 mapOfIntegers.put(aKey, aSet = new HashSet<>());
8 }
9 }


Simpliﬁcação na invocação
de métodos varargs
public class TesteVarargs {
Set<Integer> aSet = new HashSet<Integer>();
List<Set<Integer>> listOfSets = Arrays.asList(aSet);
}
}


de métodos varargs
}
}

O seguinte warning é apresentado ao compilarmos a classe:

creation of type java.util.Set<java.lang.Integer>[] for varargs parameter


de métodos varargs
}
}

Compilando o programa com a opção -XD-printﬂat

Set aSet = new HashSet();
List listOfSets = Arrays.asList(new Set[]{aSet});
}
}


de métodos varargs
Método asList da classe Arrays

public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}

Mas esse warning é gerado na chamada de qualquer
método com assinatura do tipo:
<T> Tipo<T> metodo(T... params)


de métodos varargs
A solução para o problema é criar uma forma de
informar ao compilador que a chamada ao método
asList não corre o risco de dar problemas


de métodos varargs
A solução para o problema é criar uma forma de
informar ao compilador que a chamada ao método
asList não corre o risco de dar problemas

@SafeVarargs

@SafeVarargs
public static <T> List<T> asList(T... a) {
return new ArrayList<>(a);
}


de métodos varargs
• Os métodos e construtores da plataforma
anotados com @SafeVarargs são:

public static <T> List<T> java.util.Arrays.asList(T... a)

public static <T> boolean java.util.Collections.addAll(
Collection<? super T>, c, T ... elements)

public static <E extends Enum<E>> java.util.EnumSet<E>
EnumSet.of(E first, E .... rest)

protected final void javax.swing.SwingWorker.publish(
V ... chunks)


Gerenciamento automático
de recursos
• Criação da nova interface
java.lang.AutoCloseable
• Bibliotecas adaptadas para implementar a
nova interface
• java.lang.Throwable, um novo construtor e
dois novos métodos, para facilitar o
gerenciamento de exceções suprimidas


de recursos
1 public void lerArquivo() {
2 FileReader reader = null;
3 try {
4 reader = new FileReader("arquivo");
5 // faz o processamento do arquivo
6 } catch (IOException e) {
7 // trata a exceção
8 } finally {
9 if(reader != null) {
10 try {
11 reader.close();
13 // tenta fazer alguma outra coisa aqui!
14 }
15 }
16 }
17 }


de recursos
2
3 try(FileReader reader = new FileReader("arquivo")) {
4
8 }
9 }


de recursos
2
3 try(FileReader reader = new FileReader("arquivo")) {
4
8 }
9 }

Qualquer classe que implementa a interface
java.lang.AutoCloseable
pode ser “gerenciada” pelo try!


Multicatch e Rethrow
mais preciso
• A cláusula catch está habilitada para uma
série de tipos exceções separadas pelo
operador “OR”, símbolo “|”, na declaração
do parâmetro
• Se o parâmetro de uma exceção não for
modiﬁcado e for relançado dentro do bloco
catch, o compilador aplica uma análise mais
precisa dos tipos que podem ser lançados


Multicatch

private Object instantiate(Class<?> clazz) {
try {
Object o = clazz.newInstance();
return o;
} catch (InstantiationException e) {
System.err.println("Erro na criação do objeto");
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
}
}


Multicatch

try {
return o;
} catch (InstantiationException | IllegalAccessException e) {
}
}


Rethrow mais preciso

try {
return o;
}
}


private Object instantiate(Class<?> clazz) throws
InstantiationException, IllegalAccessException {
try {
return o;
throw e;
}
}


try {
return o;
} catch (Exception e) {
throw e;
}
}

Isso compila?


try {
return o;
} catch (Exception e) {
throw e;
}
}

Isso compila?
No Java 6 não compila!!
No Java 7 compila!!

Conclusões

• Com a nova versão do Java pretende-se
reduzir a verbosidade da linguagem
• Após o lançamento do Java 7, é sua vez de
testar!! Baixe a versão e divirta-se


FIM

Perguntas?
Marcelo de Castro
@mcastroinfo

Wellington Pinheiro
@wrpinheiro

Melhorias na linguagem Java com Project Coin

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (12)

Semelhante a Melhorias na linguagem Java com Project Coin

Semelhante a Melhorias na linguagem Java com Project Coin (20)

Melhorias na linguagem Java com Project Coin