Java 15!!! O que vem ai?

Java 15 - Novidades (ou não)

1: Mensagem útil de exceção de ponteiro nulo

Helpful NullPointer Exception foi adicionado em Java 14 para melhorar a mensagem NPE para ajudar os desenvolvedores a depurar onde ocorreu o Null Pointer. Em Java 14, poderíamos adicionar um sinalizador para Helpful Null Pointer Exception. https://openjdk.java.net/jeps/358

— XX:ShowCodeDetailsInExceptionMessages.

No Java 15, não precisamos mais adicionar este sinalizador.

2: blocos de texto

Novas características

  • Bloco de texto é um literal de string de várias linhas que evita a necessidade da maioria das sequências de escape, formata automaticamente a string de maneira previsível e dá ao desenvolvedor controle sobre o formato quando desejado
  • Iniciado como um recurso de visualização em Java 13 e 14. Agora oficial em Java 15.
  • Sem o bloco de texto, precisamos acrescentar o caractere de nova linha e escapar “.
// Without Text Block
String jsnWithoutTxtBlck = "{\n"+
       " \"a\": "+ "\"b\""+"\n"+
"}";
System.out.println(jsnWithoutTxtBlck);
  • O código do bloco de texto se torna mais legível. Corte de espaços em branco, normalização de finais de linha e tradução de sequências de escape, tudo feito por Java.
//Text Block Example
String jsn = """
                {
                  "a":"b"
                }
             """;
System.out.println(jsn);

//Text Block Example With Formatted
String jsnFormatted = """
                {
                  "a":"%s"
                }
             """.formatted("b");
System.out.println(jsnFormatted);

Recursos de visualização

1: Correspondência de padrões ( também estava em visualização para java 14)

  • A correspondência de padrões torna o código mais conciso e menos prolixo. Não precisamos escrever testes de tipo e conversão de tipos repetidamente para cada caso. Com a correspondência de padrões, podemos fazer testes e lançar em uma linha.
//Traditional Style
if(transaction instanceof  DepositTransaction){                  // type checking
   DepositTransaction dTx = (DepositTransaction) transaction;   // type casting
   dTx.addAmount(transaction.getAmount());
}else if(transaction instanceof  CreditTransaction ){
   CreditTransaction cTx = (CreditTransaction) transaction;
   cTx.subAmount(transaction.getAmount());
}

//In Java 15(Preview)
 if(transaction instanceof  DepositTransaction dTx){
    dTx.addAmount(transaction.getAmount());
 }else if(transaction instanceof  CreditTransaction cTx){
    cTx.subAmount(transaction.getAmount());
 }

As variáveis dTx e cTx são chamadas de variáveis ​​padrão e só estão disponíveis no escopo do bloco em que foram utilizadas. Para o caso cTx, esta variável não pode ser usada fora do bloco else if, pois não é uma variável normal.

2: Classes Seladas

  • Os tipos selados são classes e interfaces que permitem que apenas certas subclasses os estendam ou implementem.
Imagem para postagem

Mas se outra subclasse que não está na lista de permissões tentar estendê-la, o compilador lançará um erro como mostrado na imagem.

Imagem para postagem

Classes seladas fazem muito sentido quando as usamos com correspondência de padrões e Switch Case. Isso faria com que o compilador levantasse um erro se o caso não corresponder ao tipo de licença.

int getCenter (Shape shape) { 
    return switch (shape) { 
        case Círculo c -> ... c.center () ... 
        case Retângulo r -> ... r.length () ... 
        case Quadrado s -> ... s.side () ... 
    }; 
}

3: Records ( também estava em pré-visualização para java 14 )

  • Os registros são classes de dados cujo único propósito é usar como portador de dados (objeto de transferência de dados aks DTO’s).
  • Em Java, frequentemente, quando criamos DTOs, precisamos criar um construtor, setters / getters, equals e hashcode. Essas tarefas são bastante repetitivas e frequentemente consideram o código clichê. Para tornar a introdução do Java menos detalhada para registrar em java é uma etapa esperada.
  • Agora os desenvolvedores podem limpar sua intenção de fazer uma classe como portadora de dados, escrevendo uma palavra-chave de registro antes do nome da classe, o que torna o objeto um objeto de dados imutável. Veja o exemplo abaixo:
 public record IncomeSource(String video,
                               String salary,
                               String blogging,
                               String stocks){

 };
  • Agora, uma vez que o desenvolvedor faz a classe como um registro, todos os métodos como getter e equals (), hashcode () disponíveis prontos para uso. Este design certamente melhor economiza tempo dos desenvolvedores e remove algum nível de verbosidade do Java.
  • Para obter mais informações, visite Java Enhancement Proposal (Jep): https://openjdk.java.net/jeps/359

Melhorias JVM (Pronto para Produção)

1: Coletores de lixo

  • ZGC se tornou um recurso do produto e saiu do status experimental. (Jep: https://openjdk.java.net/jeps/377 )
  • ZGC é um coletor de lixo de baixa latência que tem tempo de pausa abaixo de 10 ms e pode escalar para pilhas de terabyte. Oferece ótimo desempenho sem ajuste.
  • O Shenandoah GC também se tornou um recurso do produto e saiu do status experimental. (Jep: https://openjdk.java.net/jeps/379 )
  • Shenandoah GC desenvolvido pela equipe Redhat e também competir com ZGC em baixa latência e coletor de lixo concorrente.
-XX:+UseZGC // Sinalize para usar 
-XX:+UseShenandoahGC // Sinalizar para usar Shenandoah GC

2: Hidden Classes encontra seu caminho em java 15, é útil para frameworks que emitem bytecode dinamicamente e desejam usar várias propriedades, como Non-discovery, Access control, Lifecycle. (Jep: https://openjdk.java.net/jeps / 371 )

3: Edward Curve Digital Signature Algorithm foi adicionado ao Java 15. (Jep: https://openjdk.java.net/jeps/339 )

4: Legacy DatagramSocket API é reimplementada e adicionada ao Java 15 (Jep: https://openjdk.java.net/jeps/373 )

Suspensão de uso e remoções

  • As portas JDK para Solaris e Sparc foram removidas: https://openjdk.java.net/jeps/381
  • O mecanismo de ativação RMI era opcional desde o Java 8 e agora obsoleto no java 15 (Jep: https://openjdk.java.net/jeps/385 )
  • O mecanismo de Javascript Nashorn foi removido junto com a ferramenta jjs. Devido às rápidas mudanças no script ECMA, o mantenedor do Java achou difícil acompanhar o ritmo. Agora, para encontrar uma alternativa para executar javascript, GraalVM pode ser uma opção. (Jep: https://openjdk.java.net/jeps/372 )

Destaques:

  • O recurso de bloco de texto é adicionado.
  • Classes seladas adicionadas como uma visualização para controlar a hierarquia de herança.
  • Novos coletores de lixo ( ZGC & Shenandoah ) foram adicionados e estão prontos para produção.

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.