Java 22 foi lançado! Veja algumas das novas features

Em setembro de 2017, Mark Reinhold, líder de arquitetura da plataforma Java, propôs mudar os lançamentos das versões do Java a cada 6 meses e uma Long Term Support(LTS) a cada dois anos. Essa proposta teve efeito em todas as versões seguintes e continuam até hoje.

E a versão da vez é a JDK 22 com recursos inovadores, melhorias de desempenho significativas e compatibilidade total com versões anteriores. Vamos ver quais funcionalidades já podem ser utilizadas na melhoria de código.

Vamos ao código!

Agora iremos listar algumas mudanças:

Constructor Makeover (preview)

Antes do JDK 22 não era permitido chamar métodos dentro do construtor antes do this() ou super(). Uma solução conhecida era criar um método estático e passar essa chamada dentro do this() ou super(). Isso deixava o código um pouco mais complicado, mas funcionava. Agora isso não será mais necessário.

Imagine que você precisaria criar uma classe Employee que estende da classe Person e para isso você precisa que o atributo name seja obrigatório.

A classe Person seria por exemplo:

class Person {
  private final String name;

  public Person(String name) {
    if (Objects.isNull(name)) {
      throw new IllegalArgumentException("Name cannot be null");
    }
    this.name = name;
  }
  // Getters and setters
}

E a classe Employee estendendo de Person :

class Employee extends Person {
  private final String cargo;

  public Employee(String name, String cargo) {
    // before this operation isn't allowed
    if (Objects.isNull(cargo)) {
      throw new IllegalArgumentException("cargo cannot be null");
    }
    super(name); // this statement was required to be first
    this.cargo = cargo;
  }
  // Getters and setters
}

O erro que ocorria era Call to 'super()' must be first statement in constructor body.

Execute programas com múltiplos arquivos java

No JEP 458 enfatiza que executar aplicações java que possuem outras referências de outros arquivos funcionarão, sem precisar que sejam passadas como parâmetro ao executar a aplicação. Por exemplo, imagine que você tem uma aplicação Application.java que declara duas classes

class Application {
    public static void main(String[] args) { Helper.run(); }
}

class Helper {
    static void run() { System.out.println("Hello!"); }
}

Então execute:

$ java Prog.java

As duas classes são compiladas e executa o main da primeira classe declarada no arquivo. Antes isso não era possível sem precisar passar a classe Helper.java como parâmetro.

Main simplificado

Com o JEP 463 não é apenas para reduzir a complexidade do main, irá ajudar novos adeptos a linguagem a escreverem programas mais simples, evitando as complexidades de sintaxe, para quem está começando. Veja como era o main antes do JDK 22:

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello, World!");
    }
}

Agora é possível declarar implicitamente a classe, por exemplo:

class HelloWorld {
  void main() {
    System.out.println("Hello, World!");
  }
}

String template (preview)

JEP 459 melhora a linguagem com String Templates, complementando strings literais com blocos de textos com expressões embedadas e processadores de templates. Isso irá fazer com que manipulação de strings e variáveis fiquem menos verbosos, mais seguras e fáceis de entender. Por exemplo:

Esse código:

var s = x + " plus " + y + " equals " + (x + y);

ou esse:

var s = new StringBuilder()
       .append(x)
       .append(" plus ")
       .append(y)
       .append(" equals ")
       .append(x + y)
       .toString();

Ficariam assim:

var s = STR."\{x} plus \{y} equals \{x + y}";

Variáveis não nomeadas

Uma variável sem nome é declarada usando um caractere de sublinhado, _ (U+005F), para substituir o nome da variável local em uma instrução de declaração de variável local, um parâmetro de exceção em uma cláusula catch ou em um parâmetro lambda em uma expressão.

Em golang variável não nomeada, conhecido como the blank identifier, já existe a bastante tempo. Veja como ficaria o código em caso de uma variável não esteja sendo utilizada:

static int count(Iterable<Order> orders) {
    int total = 0;
    for (var _ : orders)    // order is unused
        total++;
    return total;
}

Um outro exemplo que variáveis não nomeadas poderiam ser aplicados:

switch (ball) {
    case RedBall _   -> process(ball);          // Unnamed pattern variable
    case BlueBall _  -> process(ball);          // Unnamed pattern variable
    case GreenBall _ -> stopProcessing();       // Unnamed pattern variable
}

Conclusão

A linguagem está em constante evolução, buscando melhorar sua sintaxe, performance e verbosidade. Baixe e experimente as Essas são as principais mudanças, a nível de código, que o JDK 22 trouxe. Baixe a nova JDK, experimente as melhorias e entenda as motivações para essas melhorias.

Compartilhe aqui quais melhorias mais gostou ou não gostou. Para todo os detalhes da nova versão, basta acessar o JDK 22 Release Notes.

Se você gostou do artigo, por favor não deixe de bater palmas 👏 (você pode fazer várias vezes), me seguir, ou até mesmo me comprar um café☕️https://www.buymeacoffee.com/valdemarjuniorr