O guia completo para a instrução/expressão estendida do switch no Java SE 12

Não existe uma base de código que é livre do uso da instrução switch; mesmo para ajustes de desempenho, tendemos a usá-la no lugar das instruções if/else. A grande e antiga declaração da instrução switch estava lá desde o nascimento do Java, e todos nós nos acostumamos com ela - e particularmente com suas peculiaridades.

O design atual da instrução switch do Java segue de perto as linguagens como o C ++ e, por padrão, suporta a semântica de fall-through. Esse fluxo de controle foi útil para escrever código de baixo nível. No entanto, como o switch é usado em um contexto de alto nível, sua natureza propensa a erros começou a superar sua flexibilidade.

À medida que os Java builders se movem para suportar a correspondência de padrões na linguagem Java, as irregularidades das instruções switch existentes se tornaram um impedimento. Os problemas incluem o comportamento de fluxo de controle padrão dos blocos de switch; o escopo padrão dos blocos de switch, em que o bloco é tratado como um único escopo; e o switch funcionando apenas como uma instrução.

No Java 12, um novo aprimoramento foi feito para o switch, adicionando novos recursos, o que simplifica a codificação ao estender a antiga instrução switch para ser usada como uma instrução regular de switch aprimorada ou como uma "expressão switch".

Isso possibilita formas de comportamento do escopo e controle de fluxo tanto "tradicionais" quanto "simplificados". Estas alterações simplificam a codificação diária e preparam o caminho para o uso da correspondência de padrões usando a instrução/expressão switch no futuro.

Novos recursos

Desde o JDK 9, foi introduzido um novo plano de lançamento mais frequente. Com a nova cadência de lançamento de 6 meses, o objetivo é que o Java se torne mais produtivo e inovador, e os recursos estarão disponíveis com mais rapidez e frequência.

Já vimos isso com cada JDK entregue recentemente, o que sempre nos traz novos recursos da linguagem Java ao lado de muitos aprimoramentos de API, desde o JDK 9, 10, 11 até o JDK 12 (que está disponível desde 19 de março de 2019), e nos próximos lançamentos.

Novos projetos

Para permitir tais aprimoramentos e novos recursos, a comunidade precisa de projetos focados que se importem com um determinado aspecto da linguagem, o que permite que um grupo de engenheiros da linguagem Java cuide dos novos aprimoramentos e que tudo esteja incluído e desenvolvido sob o universo gigante do JDK.

Portanto, existem muitos projetos que foram criados e seu trabalho é focado em um aspecto individual da linguagem. É possível acessá-los na seção do menu do projeto no site do OpenJDK.net. Para citar apenas alguns deles, temos o projeto Panama, Valhalla, Amber, Jigsaw, Loom e muitos mais. Nosso interesse aqui é com o projeto Amber.

Projeto Amber

O Projeto Amber é patrocinado pelo Compiler Group, e a partir do nome do patrocinador, podemos adivinhar o objetivo do projeto. Sim, desenvolvedores, vocês estão corretos - o objetivo deste projeto é explorar e incubar recursos menores da linguagem Java, orientados à produtividade, que foram aceitos como candidatos JEPs no processo OpenJDK JEP.

Como podemos ver abaixo, existe uma lista de todos os JEPs e seu respectivo JDK (se houver), no qual o projeto Amber está atualmente incubando ou entregando:

JEPs atualmente em progresso:

• JEP 302 Lambda Leftovers
• JEP 305 Pattern Matching for instance of (prévia)
• JEP 325 Switch Expressions (prévia, JDK 12)
• JEP 326 Raw String Literals (prévia)
• JEP draft 8209434 Concise Method Bodies

JEPs que já foram entregues:

• JEP 286 Local-Variable Type Inference (var) (JDK 10)
• JEP 323 Local-Variable Syntax for Lambda Parameters (JDK 11)

Aprimorando o Java com a correspondência de padrões

A correspondência de padrões é uma técnica que foi adaptada para muitos estilos diferentes de linguagens de programação desde 1960, incluindo linguagens orientadas a texto como SNOBOL4 e AWK, linguagens funcionais como Haskell e ML, e mais recentemente estendidas para linguagens orientadas a objetos como o Scala (e o mais recente, a linguagem Microsoft C#).

O projeto Amber adicionou a correspondência de padrões para ser adotada pela linguagem Java. A correspondência de padrões permite que a lógica comum em um programa extraia condicionalmente componentes de objetos, e que eles sejam expressados de forma mais concisa e segura, o que vai aprimorar a linguagem em muitas construções; por exemplo, agora ele aprimora o operador instanceof (não atribuído a qualquer versão do JDK até o momento) por meio do JEP 305 e as expressões do switch (esperado no JDK 12) por meio do JEP 325.

Trabalhando com a nova instrução switch.

Desde o lançamento do Java SE 9, tornou-se uma tradição testar qualquer nova linguagem Java ou recurso de API em uma ferramenta de ambiente interativo (REPL) JShell! Isso não requer IDEs nem qualquer software adicional para instalar - apenas o JDK é suficiente.

Como este recurso é fornecido com todos os JDK, podemos facilmente testar um novo recurso de linguagem do Java SE 12, por exemplo, a nova instrução switch estendida e a nova expressão switch. Tudo o que precisamos fazer é baixar e instalar o build de acesso antecipado do JDK 12, que pode ser instalado a partir deste link.

Após o download, descompacte os binários em qualquer local de sua escolha e torne a pasta bin do JDK acessível de qualquer lugar em seu sistema.

Por que o JShell?

Sempre prefiro usar uma ferramenta de ambiente de programação interativa como a que temos na maioria das linguagens modernas para aprender rapidamente a sintaxe da linguagem Java, explorar novas APIs Java e seus recursos, e até para prototipar códigos complexos.

Esta abordagem é o oposto de entrar no tedioso ciclo de edição, compilação e execução de código, que normalmente envolve o seguinte processo:

1. Escrever um programa inteiro.
2. Compilar e corrigir os erros.
3. Executar o programa.
4. Descobrir o que está errado.
5. Editar.
6. Repetir o processo.

O que é o JShell?

Agora, o Java possui uma rica implementação de REPL (Read-Evaluate-Print-Loop, Leia-Avalie-Imprima-Repita) com a ferramenta JShell, conhecida como Java Shell, que disponibiliza um ambiente de programação interativo. Então, qual é a mágica aqui? Na verdade é simples. O JShell fornece um ambiente rápido e amigável que permite explorar, descobrir e experimentar rapidamente os recursos da linguagem Java e suas extensas bibliotecas.

Usando o JShell, é possível inserir elementos no programa um por vez, ver imediatamente o resultado e fazer ajustes conforme necessário. Em vez de programas completos, neste REPL você escreve comandos JShell e trechos de código Java.

Esta introdução é suficiente para o JShell, e o InfoQ publicou recentemente uma introdução completa à ferramenta. Para aprofundar e aprender mais sobre todos os recursos do JShell, gravei um vídeo de treinamento sobre este tópico, intitulado de "Hands-on Java 10 Programming with JShell [Vídeo]" que deve ajudá-lo a dominar o tópico, e pode ser acessado do site da Packt.

Iniciando uma sessão JShell.

A primeira coisa para começar a interagir com a ferramenta é iniciar uma nova sessão do JShell da seguinte maneira:

1. No Microsoft Windows, basta abrir um prompt de comando, digitar jshell e pressionar Enter.
2. Enquanto no Linux, abra uma janela de shell, digite jshell e pressione Enter.
3. E se você estiver trabalhando em macOS (anteriormente OS X), abra uma janela do Terminal, digite este comando "jshell" e finalmente pressione <conde>Enter.

Taraaa! Esse comando executa uma nova sessão do JShell e exibe essa mensagem no prompt jshell>:

mohamed_taman:~$ jshell --enable-preview
|  Welcome to JShell -- Version 12-ea
|  For an introduction type: /help intro
 
jshell>

Na primeira linha acima, "Versão 12-ea" indica que estamos usando o acesso antecipado ao Java SE JDK 12. O JShell precede mensagens informativas com barras verticais (|) e agora é possível inserir qualquer trecho de código Java ou comandos JShell.

Eu acho que você têm olhos aguçados suficientes para ver a opção --enable-preview ! Para que serve essa opção? Esta opção permite que você desbloqueie qualquer novo recurso da linguagem que esteja atualmente no estado de "prévia", ou seja, que ainda não é parte oficial do JDK. Esses recursos estão desativados por padrão, pois ainda estão em fase experimental e de feedback.

Ao usar esta flag, permite que você, como desenvolvedor, experimente os recursos de prévia e forneça seus feedbacks para mais aprimoramentos ou até mesmo feedbacks negativos ou qualquer outro comentário. Neste artigo, estamos explorando o novo recurso de expressões switch, e é por isso que precisamos incluir essa opção ao iniciar uma sessão do JShell.

Isso é teoria suficiente por enquanto, e vamos tentar nos divertir com os trechos de código das novas instruções/expressões switch para esclarecer os conceitos e aprender como usar esse ótimo novo recurso.

Instrução/expressão switch

Primeiro, precisamos ter certeza de que sabemos do nosso presente; e onde estamos hoje com a edição atual da instrução switch e até mesmo suas peculiaridades que costumávamos fazer em nossas tarefas diárias de codificação.

Vamos considerar um método simples que tem um Day como variável; o método alterna o enum Dat que contém dias normais (Sat, Sun, Mon... etc.) e, com base nisso, retorna um "weekend" ou um "working day".

Na sessão Jshell que já começamos antes, vamos definir o enum Day como o seguinte:

jshell> enum Day{
   ...> NONE,
   ...> SAT,
   ...> SUN,
   ...> MON,
   ...> TUS,
   ...> WED,
   ...> THU,
   ...> FRI;
   ...> }
|  created enum Day

Agora, vamos definir nosso método String whatIsToday(Dia dia) para alternar (usamos o switch normal) sobre o valor do dia e retornar se é um dia útil ou fim de semana, como o seguinte:

jshell> String whatIsToday(Day day){
   ...>   var today = "";
   ...>   switch(day){
   ...>	case SAT:
   ...>	case SUN: today = "Weekend day";
   ...>          	break;
   ...>	case MON:
   ...>	case TUS:
   ...>	case WED:
   ...>	case THU:
   ...>	case FRI: today = "Working day";
   ...>          	break;
   ...>	default:  today = "N/A";
   ...>  }
   ...>  return today;
   ...> }
|  created method whatIsToday(Day)
 
jshell> whatIsToday(Day.SUN)
$3 ==> "Weekend day"

Embora esta função funcione perfeitamente, usamos a versão original com as muitas instruções de break para cada caso, o que introduz um ruído visual que dificulta a depuração dos erros. Também torna o código desnecessariamente verboso, onde erroneamente perder uma instrução break, significa que pode ocorrer um fall-through acidental.

No exemplo acima, reduzimos o uso de breaks usando o mecanismo fall-through para dias comuns que possuem os mesmos valores, mas ainda assim é muito longo.

Aprimoramentos da instrução switch tradicional

Graças ao JEP 325, que propôs uma nova forma de "seta" ("regra de rótulo do switch"), que é escrita como "case L ->" para indicar que apenas o código à direita do rótulo deve ser executado se o rótulo é correspondido, e pode ser usado com uma instrução switch ou com uma expressão switch.

Da mesma forma, a sintaxe tradicional de "dois pontos" ("grupo de instruções rotuladas do switch") também pode ser usada com ambos os casos.

Apesar dos dois pontos e a nova sintaxe da seta poderem ser usados ​​em ambos os casos, a presença dos dois pontos (:) NÃO implica necessariamente em uma instrução switch e a presença de uma "seta" (->) NÃO implica necessariamente em uma expressão switch.

Agora, vamos traduzir as instruções teóricas anteriores para a prática, por exemplo, o método anterior String whatIsToday(Day day) agora pode ser reescrito seguindo a versão simplificada:

jshell> /edit whatIsToday

Ao executar o comando JShell / edit, abrirá um bloco de edição do JShell para facilitar a modificação de trechos de código grandes, como nesse método. Então, no bloco de edição do JShell, altere o método da seguinte forma:

String whatIsToday(Day day){
  var today = "";
  switch(day){
   case SAT, SUN -> today = "Weekend day";
   case MON, TUS, WED, THU, FRI -> today = "Working day";
   default -> throw new IllegalArgumentException("Invalid day: " + day.name());
  }
  return today;
}

Quando terminar as modificações, clique no botão Exit para aceitar as modificações e retornar a sessão atual do JShell>, para testar o método novamente com alguns valores:

jshell> /edit whatIsToday
|  modified method whatIsToday(Day)
 
jshell> whatIsToday(Day.SUN)
$5 ==> "Weekend day"
 
jshell> whatIsToday(Day.MON)
$6 ==> "Working day"
 
jshell> whatIsToday(Day.NONE)
|  Exception java.lang.IllegalArgumentException: Invalid day: NONE
|    	at whatIsToday (#11:6)
|    	at (#12:1)
 
jshell>

Ao examinar a estrutura anterior da nova instrução switch, deverá notar muitas alterações aqui, primeiro, é mais claro, conciso e "sem interrupções", não é?

Segundo, é perceptível que a instrução switch aproveita a nova forma de sintaxe de "seta" ("regras de rótulo") para realizar sua alternância sem especificação explícita do break, o que nos salva do caso de switch "fall-through", frequentemente temido .

Vale a pena observar que o código à direita de um rótulo do switch "case L ->" é restrito a ser uma expressão, um bloco ou (por conveniência) uma instrução throw, assim como fizemos no método anterior para o caso default (padrão) da instrução switch, que identifica o dia inválido, lançando uma IllegalArgumentException.

Múltiplos rótulos separados por vírgula em um único caso do switch

Tradicionalmente, na antiga instrução switch, quando precisamos identificar os vários casos que devem executar o mesmo conjunto de instruções, usamos o mecanismo de fall-through.

Mas agora, o terceiro aviso aqui é que usamos a nova estrutura de "múltiplos rótulos separados por vírgulas em um único caso do switch", usando apenas uma vírgula para separar os casos comuns que devem executar a mesma instrução.

Grupo de instruções rotuladas do switch

De acordo com o JEP 325, a sintaxe tradicional de "dois pontos" ("grupo de instruções rotuladas do switch") também pode ser usada normalmente e podemos reescrever o método anterior nesta forma de dois pontos, conforme a seguir:

String whatIsToday(Day day){
  var today = "";
  switch(day){
   case SAT, SUN: today = "Weekend day"; break;
   case MON, TUS, WED, THU, FRI: today = "Working day"; break;
   default: throw new IllegalArgumentException("Invalid day: " + day.name());
  }
  return today;
}

Vou deixar isso como um pequeno exercício. É possível tentar, executando o comando JShell /edit oQueEHoje e substituindo o método atual pela sintaxe de token de seta, e no método anterior com a sintaxe de dois-pontos/quebra, e teste-o com alguns valores que deve funcionar perfeitamente.

Nova expressão switch

Antes de nos aprofundarmos nisso, nos perguntamos como era o switch antes de começar a agir como uma expressão? Antes do Java SE 12, o switch era sempre uma instrução; que é uma construção imperativa que direciona o fluxo de controle e nunca pode ser o destino. Por outro lado, uma expressão sempre é avaliada exatamente para um valor. Como o objetivo final de qualquer cálculo é um resultado, um valor pode ser atribuído a um destino.

Agora que exploramos a diferença entre a instrução e a expressão, vamos ver como a nova expressão switch funciona na prática. Na verdade, muitas instruções switch existentes que usamos em nosso código diariamente, e até mesmo o código acima, são essencialmente uma simulação de uma expressão de switch, em que cada caso de decisão é atribuído a uma variável de destino comum ou retorna um valor.

Agora podemos usar a nova expressão switch para retornar o valor diretamente a ser atribuído à variável de destino. Vamos modificar o método String whatIsToday (Day day):

String whatIsToday(Day day){
  var today = switch(day){
	case SAT, SUN -> "Weekend day";
	case MON, TUS, WED, THU, FRI -> "Working day";
	default -> throw new IllegalArgumentException("Invalid day: " + day.name());
  };
 
  return today;
}

Analisando profundamente o método modificado, podemos notar que escrevemos a instrução switch como uma expressão: primeiro, o switch é escrito após o sinal de igual; segundo, já que é parte de uma instrução, precisa terminar com um ponto-e-vírgula, enquanto a instrução switch clássica não; e terceiro, o que vem depois do token de seta é o valor de retorno.

Como mencionado anteriormente, podemos usar a sintaxe tradicional de "dois pontos" "case L:" dentro da nova expressão switch, e assim podemos reescrever o método anterior usando a instrução break com valor:

String whatIsToday(Day day){
  var today = switch(day){
	case SAT, SUN: break "Weekend day";
	case MON, TUS, WED, THU, FRI: break "Working day";
	default: throw new IllegalArgumentException("Invalid day: " + day.name());
  };
  return today;
}

As duas formas de break (com e sem valor) são análogas às duas formas de retorno (return) nos métodos.

Declaração de blocos

Enquanto nós usamos a nova instrução/expressão switch em nossas tarefas diárias com a sintaxe "dois pontos" ou "seta", na maioria dos casos usamos uma única expressão como solução de qualquer uma das duas formas.

No entanto, há casos em que precisamos avaliar várias instruções ao mesmo tempo. E facilmente podemos fazer isso com blocos {}, também é muito útil que possamos criar e usar o mesmo nome de variável dentro de uma única instrução/expressão de switch diversas vezes, como segue:

String whatIsToday(Day day){
  var today = switch(day){
	case SAT, SUN: break "Weekend day";
	case MON, TUS, WED, THU, FRI:{
   	 var kind = "Working day";
    	break kind;
	}
	default: {
    	var kind = day.name();
   	 System.out.println(kind);
   	 throw new IllegalArgumentException("Invalid day: " + kind);
	}
  };
 
  return today;
}

É uma poli expressão

Uma expressão switch é uma "poli expressão"; se o tipo do destino for conhecido, esse tipo é esperado em cada caso de decisão; se não, um tipo autônomo é calculado combinando os tipos de cada caso.

Considere esta atribuição da expressão switch:

jshell> var day = Day.SUN
day ==> SUN
 
jshell> var today = switch(day){
   ...> 	case SAT, SUN -> "Weekend day";
   ...> 	case MON, TUS, WED, THU, FRI -> "Working day";
   ...> 	default -> {
   ...>          	var len = day.name().length();
   ...>          	break len;
   ...> 	}
   ...>   };
today ==> "Weekend day"
 
jshell> var day = Day.NONE
day ==> NONE
 
jshell> var today = switch(day){
   ...> 	case SAT, SUN -> "Weekend day";
   ...> 	case MON, TUS, WED, THU, FRI -> "Working day";
   ...> 	default -> {
   ...>          	var len = day.name().length();
   ...>          	break len;
   ...> 	}
   ...>   };
4
today ==> 4

Se observarmos mais perto e analisarmos a expressão switch acima, podemos descobrir que temos duas condições retornando uma String, e o padrão retornando uma variável len que é do tipo int. Ambos funcionam perfeitamente, pois o destino é o var.

Agora vamos declarar explicitamente que a atribuição de destino é do tipo int em vez de var. Isso fará o compilador reclamar, para satisfazer a condição "se o tipo de destino for conhecido, esse tipo será empurrado para cada caso de decisão":

jshell> int today = switch(day){
   ...> 	case SAT, SUN -> "Weekend day";
   ...> 	case MON, TUS, WED, THU, FRI -> "Working day";
   ...> 	default -> {
   ...>          	var len = day.name().length();
   ...>          	System.out.println(len);
   ...>          	break len;
   ...> 	}
   ...>   };
|  Error:
|  incompatible types: bad type in switch expression
|      java.lang.String cannot be converted to int
|  	case SAT, SUN -> "Weekend day";
|                       ^-----------^
|  Error:
|  incompatible types: bad type in switch expression
|      java.lang.String cannot be converted to int
|  	case MON, TUS, WED, THU, FRI -> "Working day";
|                                      ^-----------^

O que não pode ser feito com o novo recurso de switch

Vamos agora explorar como podemos deixar o compilador irritado e reclamando sobre o código de instrução/expressão switch que escrevemos e, consequentemente, aprender como tentar evitar isso para deixar o compilador feliz :).

break não pode retornar um valor dentro de uma instrução switch

Este é um erro em tempo de compilação ao tentar ter um break associado a uma instrução switch para retornar um valor:

jshell> String whatIsToday(Day day){
   ...>   var today = "";
   ...>   switch(day){
   ...>    case SAT, SUN: break "Weekend day";
   ...>    case MON, TUS, WED, THU, FRI: break "Working day";
   ...>    default: throw new IllegalArgumentException("Invalid day: " + day.name());
   ...>   }
   ...>   return today;
   ...> }
|  Error:
|  unexpected value break
| 	case SAT, SUN: break "Weekend day";
|    	            ^------------------^
|  Error:
|  unexpected value break
| 	case MON, TUS, WED, THU, FRI: break "Working day";
|                                   ^------------------^
|  Error:
|  unreachable statement
|	return today;
|	^-----------^
 
jshell>

Sintaxe de seta aponta apenas para uma instrução dentro da instrução switch

Novamente, é um erro de tempo de compilação caso tente usar a sintaxe de seta com uma instrução switch para retornar um valor. Nesse caso, a sintaxe da seta deve apontar apenas para uma instrução e NÃO retornar um valor:

jshell> String whatIsToday(Day day){
   ...>   var today = "";
   ...>   switch(day){
   ...>    case SAT, SUN -> "Weekend day";
   ...>    case MON, TUS, WED, THU, FRI -> "Working day";
   ...>    default -> throw new IllegalArgumentException("Invalid day: " + day.name());
   ...>   }
   ...>   return today;
   ...> }
|  Error:
|  not a statement
| 	case SAT, SUN -> "Weekend day";
|                  	^-----------^
|  Error:
|  not a statement
| 	case MON, TUS, WED, THU, FRI -> "Working day";

Mistura de sintaxe de seta e dois-pontos/quebra não é permitida

O compilador ficará com muita raiva e reclamará caso tente misturar a "seta" e a sintaxe tradicional de dois-pontos/quebra:

jshell> String whatIsToday(Day day){
   ...>   var today = "";
   ...>   switch(day){
   ...>    case SAT, SUN -> today = "Weekend day";
   ...>    case MON, TUS, WED, THU, FRI: today = "Working day";break;
   ...>    default -> throw new IllegalArgumentException("Invalid day: " + day.name());
   ...>   }
   ...>   return today;
   ...> }
|  Error:
|  different case kinds used in the switch
| 	case MON, TUS, WED, THU, FRI: today = "Working day";break;
|     ^--------------------------------------------------------^

Todos os casos devem ser cobertos em uma expressão switch

Finalmente, é um erro em tempo de compilação se todos os casos do switch não forem cobertos em uma expressão switch para uma variável de teste específica. Se não cobrir todos eles, receberá o seguinte erro:

jshell> String whatIsToday(Day day){
   ...>   var today = switch(day){
   ...>    case SAT, SUN -> "Weekend day";
   ...>    case MON, TUS, WED, THU, FRI -> "Working day";
   ...>   };
   ...>   return today;
   ...> }
|  Error:
|  the switch expression does not cover all possible input values
|	var today = switch(day){
|         	   ^-----------...

Cobrir todos os casos dentro de uma expressão switch não é uma tarefa fácil. A correção neste caso é trivial e pequena - basta adicionar o caso default e ele irá compilar. Deixarei que faça o código acima compilar com sucesso.

Futuro do switch

Como no switch antigo, tanto a nova instrução aprimorada do switch quanto a expressão switch funcionam bem com enums. Então, e os outros tipos? Ambas as novas formas "tradicional" e "expressão" são semelhantes, elas também podem alternar entre os tipos String, int, short, byte, char e seus tipos wrapper; até agora nada mudou aqui.

Estender o switch em futuras versões do Java é uma meta, por exemplo, para permitir o switch sobre float, double e long (com seus tipos wrapper), o que não era permitido antes.

Conclusão

Neste artigo, aprendemos sobre o Projeto Amber, a correspondência de padrões e como o JEP 325 estendeu a instrução switch para que possa ser utilizada como uma instrução ou expressão, e que ambas as formas podem usar um comportamento de escopo e controle de fluxo "tradicional" ou "simplificada".

Essas alterações também simplificam a codificação diária e podem evitar erros causados ​​por problemas de "fall-through", nos quais esquecemos de adicionar uma instrução de quebra relevante. Eu também listei os erros mais comuns que um desenvolvedor pode cometer quando começar a usar a nova instrução/expressão switch.

Além disso, essa mudança de linguagem prepara o caminho para o uso de correspondência de padrões (JEP 305) em instruções/expressões switch, e também estende o switch atual para suportar tipos mais primitivos como float, double e long, juntamente com seus tipos de wrapper.

Chegamos ao final do nosso artigo, foi um prazer escrevê-lo, e espero que tenha gostado de ler! Se sua resposta for sim, então clique no botão "curtir" e espalhe a palavra através de seus amigos e mídias sociais!

Recursos

• Projeto Amber
• Correspondência de padrões para Java
• JEP 325: Expressões Switch
• JEP 305: Correspondência de padrões para instanceof
• Programação Java 10 na prática com JShell
• Introdução ao Clean Code Java SE 9

Sobre o autor

Mohamed Taman é um arquiteto corporativo da @Comtrade serviços digitais, um Java Champions, embaixador da Oracle Groundbreaker, adota o Java SE.next (), JakartaEE.next (), membro do JCP, foi membro do Comitê Executivo do JCP, JSR 354, 363 e Membro do 373 Expert Group, líder do EGJUG, membro do conselho do Oracle Egypt Architects Club, palestrante Java, adora Mobile, Big Data, Cloud, Blockchain, DevOps. Um palestrante internacional, autor de livros e vídeos sobre "JavaFX essentials", "Introdução ao Clean Code Java SE 9" e "Programação Java 10 na prática com JShell" e um novo livro "Segredos de um Java Champions", Ganhou a escolha de 2015 da Duke, prêmios em 2014, e prêmios de 2013 do JCP outstanding adopt-a-jar.