Project coin pequenas mudanças grandes facilidades

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

quarta-feira, 24 de agosto de 2011

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

Project coin pequenas mudanças grandes facilidades

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Andere mochten auch

Andere mochten auch (6)

Ähnlich wie Project coin pequenas mudanças grandes facilidades

Ähnlich wie Project coin pequenas mudanças grandes facilidades (20)

Project coin pequenas mudanças grandes facilidades