Recursos do Java 14

Seguindo a tradição do ciclo de seis meses, após o lançamento do Java 13 em 17 de setembro de 2019, está programado o lançamento do Java 14, outra versão não-LTS, em 17 de março de 2020.

Recursos do Java 14

Aqui está a lista de recursos do Java 14:

• Expressões Switch (Padrão) – JEP 361
• Casamento de Padrões para instanceof (Visualização) – JEP 305
• NullPointerExceptions úteis – JEP 358
• Records (Visualização) – JEP 359
• Blocos de Texto (Segunda Visualização) – JEP 368
• Ferramenta de Empacotamento (Incubadora) – JEP 343
• Alocação de Memória Consciente de NUMA para G1 – JEP 345
• Transmissão de Eventos JFR – JEP 349
• Buffers de Bytes Mapeados Não Voláteis – JEP 352
• ZGC no macOS – JEP 364
• ZGC no Windows – JEP 365
• API de Acesso a Memória Externa (Incubadora) – JEP 370

Configuração de Instalação do Java 14 no macOS

• Para começar com o Java 14, faça o download do JDK da aqui.
• Copie e extraia o arquivo tar no /Library/Java/JavaVirtualMachines conforme mostrado abaixo:

$ cd /Library/Java/JavaVirtualMachines

$ sudo cp ~/Downloads/openjdk-14_osx-x64_bin.tar.gz /Library/Java/JavaVirtualMachines

$ sudo tar xzf openjdk-14_osx-x64_bin.tar.gz

$ sudo rm openjdk-14_osx-x64_bin.tar.gz

Feito isso, abra o bash_profile usando qualquer editor de texto. Estou usando vim ~/.bash_profile. Defina o caminho do Java 14 para JAVA_HOME, salve as alterações e faça um source ~/.bash_profile para refletir as alterações.

export JAVA_HOME=/Library/Java/JavaVirtualMachines/jdk-14.jdk/Contents/Home

Por fim, você está pronto para compilar e executar programas usando o Java 14. Vamos utilizar o JShell, uma ferramenta interativa de linha de comando REPL para testar rapidamente os novos recursos do Java 14.

É importante observar que muitos recursos lançados no Java 14 estão em prévia. Isso significa que, embora estejam totalmente funcionais agora, podem ser modificados no futuro. Alguns podem se tornar padrão ou simplesmente ser removidos nos próximos ciclos de lançamento. Para testar recursos de prévia, você precisa configurar explicitamente --enable-preview ao executar o JShell ou o Programa Java, conforme mostrado abaixo:

jshell --enable-preview

javac --release 14 --enable-preview Author.java

Nas próximas seções, vamos discutir alguns dos recursos de linguagem e da JVM.

Leitura Recomendada: Instalando o Java 14 no Linux

1. Expressões Switch

As expressões switch, após permanecerem como uma funcionalidade de visualização nas últimas duas versões do Java – Java 12 e Java 13 – finalmente alcançaram status permanente no Java 14.

• O Java 12 introduziu a sintaxe lambda para expressões switch, permitindo assim múltiplos rótulos de caso para correspondência de padrões, além de evitar o uso de “fall-throughs” que levam a um código verboso. Ele também exigiu casos exaustivos, em que um erro de compilação seria lançado se todos os casos de entrada não fossem cobertos.
• O Java 13, a segunda visualização, introduziu a instrução yield em vez do break para retornar valores de uma expressão.

O Java 14 finalmente tornou esses recursos padrão agora.

String result = switch (day) {
            case "M", "W", "F" -> "MWF";
            case "T", "TH", "S" -> "TTS";
            default -> {
                if(day.isEmpty())
                    yield "Please insert a valid day.";
                else
                    yield "Looks like a Sunday.";
            }

        };
System.out.println(result);

Observação: “Yield” não é uma nova palavra-chave em Java. Ela é apenas usada em expressões switch.

2. Correspondência de Padrões para instanceof (Visualização)

Pergunte a qualquer desenvolvedor Java para mostrar seu código e você verá um bom uso de condições instanceof ao longo do código. Especificamente, uma verificação condicional instanceof geralmente é seguida por um “typecasting”.

No Java 14, isso é feito de forma muito mais concisa, eliminando a verbosidade.

Antes do Java 14:

if (obj instanceof Journaldev) {
  Journaldev jd = (Journaldev) obj;
  System.out.println(jd.getAuthor());
}

A partir do Java 14:

if (obj instanceof Journaldev jd) {
  System.out.println(jd.getAuthor());
}

No código acima, a instância jd seria atribuída apenas se obj for do tipo Journaldev. O escopo da variável é limitado ao bloco condicional apenas.

3. Helpful NullPointerExceptions

As Exceções de Ponto Nulo são um pesadelo para qualquer desenvolvedor. Anteriormente, até o Java 13, era complicado depurar as infames NPEs. Os desenvolvedores tinham que recorrer a outras ferramentas de depuração ou descobrir manualmente a variável/método que estava nula, já que a rastreabilidade mostrava apenas o número da linha.

Antes do Java 14:

String name = jd.getBlog().getAuthor()

//Rastreio
Exception in thread "main" java.lang.NullPointerException
    at NullPointerExample.main(NullPointerExample.java:5)

O Java 14 introduziu um novo recurso na JVM que oferece uma visão melhor com uma pilha mais descritiva, conforme mostrado abaixo:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Blog.getAuthor()" because the return value of "Journaldev.getBlog()" is null
    at NullPointerExample.main(NullPointerExample.java:4)

Nota: O recurso acima não é uma característica da linguagem. É uma melhoria no ambiente de execução.

4. Records (Prévia)

A record is a data class that stores pure data. The idea behind introducing records is to quickly create simple and concise classes devoid of boilerplate code.

Normalmente, uma classe em Java exigiria que você implementasse equals(), hashCode(), os métodos getters e setters. Embora alguns IDEs suportem a geração automática de tais classes, o código ainda é verbose. Com um record, você só precisa definir uma classe da seguinte maneira.

record Author(){}
//ou
record Author (String name, String topic) {}

O compilador Java irá gerar automaticamente um construtor, campos private final, acessores, métodos equals/hashCode e toString. Os métodos getter gerados automaticamente para a classe acima são name() e topic().

Para visualizar o código gerado, use javap Author após compilar o programa usando javac. A ilustração a seguir mostra a classe gerada para record Author (String name, String topic) {}:

A semântica dos Records é semelhante às Classes de Dados em Kotlin

Além disso, podemos adicionar campos, métodos e construtor adicionais ao record da seguinte maneira:

record Author (int id, String name, String topic) {
    static int followers;

    public static String followerCount() {
        return "Followers are "+ followers;
    }

    public String description(){
        return "Author "+ name + " writes on "+ topic;
    }

    public Author{
    if (id < 0) {
        throw new IllegalArgumentException( "id must be greater than 0.");
     }
   }
}

O construtor adicional definido dentro do record é chamado de construtor Compacto. Ele não consiste em nenhum parâmetro e é apenas uma extensão do construtor canônico.

A compact constructor wouldn’t be generated as a separate constructor by the compiler. Instead, it is used for validation cases and would be invoked at the start of the main constructor.

Algumas coisas importantes a serem observadas sobre Records:

• A record can neither extend a class nor it can be extended by another class. It’s a final class.
• Records não podem ser abstratos
• Records não podem estender nenhuma outra classe e não podem definir campos de instância dentro do corpo. Os campos de instância devem ser definidos apenas na descrição do estado
• Os campos declarados são privados e final
• O corpo de um record permite campos e métodos estáticos

Leitura Recomendada: Java Records

4.1) Os valores dentro dos campos de referência de um registro podem ser mutados

É importante notar que para campos definidos como objetos, apenas a referência é imutável. Os valores subjacentes podem ser modificados. A seguinte ilustração mostra um registro no qual o ArrayList é modificado. Como você pode ver, o valor é modificado sempre que o ArrayList é alterado.

4.2) Registros podem implementar interfaces

O código a seguir mostra um exemplo de implementação de uma interface com registros:

record Author(String name, String topic) implements Information {
  public String getFullName() {
    return "Author "+ name + " writes on " + topic;
  }
}

interface Information {
  String getFullName();
}

Aqui está a saída do código acima em ação no JShell:

4.3) Registros suportam múltiplos construtores

Registros permitem declarar múltiplos construtores com ou sem parâmetros, conforme mostrado abaixo:

record Author(String name, String topic) {
  public Author() {

    this("NA", "NA");
  }

  public Author(String name) {

    this(name, "NA");
  }
}

4.4) Registros Permitem Modificar Métodos de Acesso

Mesmo que os registros gerem métodos de acesso públicos para os campos definidos na descrição do estado, eles também permitem que você redefina os métodos de acesso no corpo, como mostrado abaixo:

record Author(String name, String topic) {
  public String name() {
        return "This article was written by " + this.name;
    }
}

4.5) Verificar Registro e Seus Componentes em Tempo de Execução

Os registros nos fornecem isRecord() e getRecordComponents() para verificar se a classe é um registro e também para examinar seus campos e tipos. A ilustração a seguir mostra como isso é feito:

Mesmo que tenhamos adicionado campos e métodos adicionais ao registro nos exemplos de código acima, certifique-se de não exagerar nisso. Os registros são projetados como transportadores de dados simples e se você pretende implementar muitos métodos adicionais, é melhor recorrer à classe normal.

5. Blocos de Texto (Visualização)

Blocos de texto foram introduzidos como um recurso de prévia no Java 13 com o objetivo de permitir a fácil criação de literais de string em várias linhas. É útil na criação fácil de strings de HTML, JSON ou consulta SQL.

No Java 14, os Blocos de Texto ainda estão em prévia com algumas adições novas. Agora podemos usar:

• Contrabarra para exibir blocos de texto de várias linhas com uma aparência agradável.
• O código \s é usado para considerar espaços finais que são ignorados por padrão pelo compilador. Ele preserva todos os espaços presentes antes dele.

String text = """
                Did you know \
                Java 14 \
                has the most features among\
                all non-LTS versions so far\
                """;

String text2 = """
                line1
                line2 \s
                line3
                """;


String text3 = "line1\nline2 \nline3\n"

// texto2 e texto3 são iguais.

Referências: OpenJDK 14