feat(lang-enh): 🎸 handles multiple Exception, translated

Refers: #4

book/02-language-enhancement/sections/03-multiple-exception.asc

@@ -1,44 +1,42 @@
 :java-package: src/org/j6toj8/languageenhancements
 :section-java-package: ../../../{java-package}
 
-=== Múltiplas `Exception` no mesmo `catch`
+=== Handles multiple Exception in a single catch
 
-.Objetivo
+.Objective
 ----
 Develop code that handles multiple Exception types in a single catch block.
--
-Desenvolver código que lide com múltiplos tipos de Exception em um único bloco catch.
 ----
 
-É esperado que o candidato saiba compreender e analisar o uso da instrução _try-catch_ com múltiplos tipos de `Exception` no mesmo bloco `catch`. 
+The candidate is expected to understand and analyze the use of the _try-catch_ statement with multiple types of `Exception` in the same `catch` block.
 
-Antes de continuar, com base no exemplo a seguir, entenda a execução do método `main` e o que é apresentado no console após sua execução.
+Before proceeding, based on the following example, understand the execution of the `main` method and what is presented on the console after its execution.
 
 [source,java,indent=0]
 .{java-package}/multipleexception/MultipleException_Complete.java
 ----
 include::{section-java-package}/multipleexception/MultipleException_Complete.java[tag=code]
 ----
 
-O código anterior possui um bloco _try-catch_ que você provavelmente já conhece. A novidade neste código está no primeiro bloco `catch`, onde várias exceções são declaradas e capturadas ao mesmo tempo.
+The previous code has a _try-catch_ block that you probably already know. The new about this code is in the first `catch` block, where multiple exceptions are thrown and caught at the same time.
 
-.Saída no console
+.console output
 [source,console]
 ----
-Exceção capturada: java.lang.NullPointerException
+Exception caught: java.lang.NullPointerException
 ----
 
-. Desde o Java 7, múltiplas exceções podem ser capturadas no mesmo `catch`.
+. Since Java 7, multiple exceptions can be caught in the same catch.
 
-. Apenas uma variável é permitida para um bloco `catch`, e deve estar localizada no final.
+. Only one variable is allowed for a `catch` block, and must be located at the end.
 +
 [source,java,indent=0]
 .{java-package}/multipleexception/MultipleException_MultipleSameCatch.java
 ----
 include::{section-java-package}/multipleexception/MultipleException_MultipleSameCatch.java[tag=code]
 ----
 
-. Não é permitido declarar exceções diferentes, mas que seriam redundantes levando em consideração a herança.
+. It is not allowed to declare different exceptions, but would be redundant considering inheritance.
 
 +
 [source,java,indent=0]
@@ -47,15 +45,15 @@ include::{section-java-package}/multipleexception/MultipleException_MultipleSame
 include::{section-java-package}/multipleexception/MultipleException_Redundant.java[tag=code]
 ----
 
-. Ao fazer `catch` de múltiplas `Exception`, não é permitido sobrescrever a variável da exceção. Mas é possível se for apenas uma `Exception` no `catch`.
+. When catching multiple Exceptions, it is not allowed to override the exception variable. But it's possible if it's just an `Exception` in `catch`.
 +
 [source,java,indent=0]
 .{java-package}/multipleexception/MultipleException_OverrideVar.java
 ----
 include::{section-java-package}/multipleexception/MultipleException_OverrideVar.java[tag=code]
 ----
 
-. Assim como nas versões anteriores, tipos mais genéricos de `Exception` devem vir depois, mais abaixo nos _catch's_.
+. As in previous releases, more generic types of `Exception` should come later, lower in the _catch_.
 
 +
 [source,java,indent=0]
@@ -64,26 +62,26 @@ include::{section-java-package}/multipleexception/MultipleException_OverrideVar.
 include::{section-java-package}/multipleexception/MultipleException_GenericsLower.java[tag=code]
 ----
 
-. Assim como nas versões anteriores, Exceções repetidas ainda são proibidas.
+. As in previous versions, repeated exceptions are still prohibited.
 +
 [source,java,indent=0]
 .{java-package}/multipleexception/MultipleException_RepeatException.java
 ----
 include::{section-java-package}/multipleexception/MultipleException_RepeatException.java[tag=code]
 ----
 
-. Assim como nas versões anterior, Exceções checadas (aquelas que herdam de `Exception`) só podem estar em um `catch` caso algo no `try` lance elas.
+. As in previous versions, Checked Exceptions (those that inherit from `Exception`) can only be in a `catch` if something in `try` throws them.
 +
 [source,java,indent=0]
 .{java-package}/multipleexception/MultipleException_CheckedException.java
 ----
 include::{section-java-package}/multipleexception/MultipleException_CheckedException.java[tag=code]
 ----
 
-.Referências
+.References
 ****
 
-* Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide (p. 291). Wiley. Edição do Kindle.
+* Boyarsky, Jeanne; Selikoff, Scott. OCP: Oracle Certified Professional Java SE 8 Programmer II Study Guide (p. 291). Wiley. Kindle Edition.
 
 * https://docs.oracle.com/javase/8/docs/technotes/guides/language/catch-multiple.html[Catching Multiple Exception Types and Rethrowing Exceptions with Improved Type Checking.] Java Documentation.
 

src/org/j6toj8/languageenhancements/multipleexception/MultipleException_CheckedException.java

@@ -9,8 +9,8 @@ public static void main(String[] args) {
 
     try {
         throw new NullPointerException();
-    } catch (NullPointerException | IOException e) { // NÃO COMPILA - IOException não é lançada dentro do bloco try
-        System.out.println("Exceção capturada: " + e);
+    } catch (NullPointerException | IOException e) { // NOT COMPILING - IOException is not thrown inside try block
+        System.out.println("Exception caught: " + e);
     }
   }
   // end::code[]

src/org/j6toj8/languageenhancements/multipleexception/MultipleException_Complete.java

@@ -8,9 +8,9 @@ public static void main(String[] args) {
     try {
         throw new NullPointerException();
     } catch (NullPointerException | IllegalArgumentException | IllegalStateException e) {
-        System.out.println("Exceção capturada: " + e);
+        System.out.println("Exception caught: " + e);
     } catch (Exception e) {
-        System.out.println("Exceção capturada: " + e);
+        System.out.println("Exception caught: " + e);
     }
   }
   // end::code[]

src/org/j6toj8/languageenhancements/multipleexception/MultipleException_GenericsLower.java

@@ -8,9 +8,9 @@ public static void main(String[] args) {
     try {
         throw new NullPointerException();
     } catch (Exception e) {
-        System.out.println("Exceção capturada: " + e);
-    } catch (NullPointerException | IllegalArgumentException e) { // NÃO COMPILA - NullPointerException é mais específico que Exception, logo deveria ser capturada antes de Exception 
-        System.out.println("Exceção capturada: " + e);
+        System.out.println("Exception caught: " + e);
+    } catch (NullPointerException | IllegalArgumentException e) { // NOT COMPILING - NullPointerException is more specific than Exception, so it should be caught before Exception
+        System.out.println("Exception caught: " + e);
     } 
   }
   // end::code[]

src/org/j6toj8/languageenhancements/multipleexception/MultipleException_MultipleSameCatch.java

@@ -9,12 +9,12 @@ public static void main(String[] args) {
 
     try {
         throw new NullPointerException();
-    } catch (NullPointerException | IllegalArgumentException e) { // COMPILA - múltiplas exceções no mesmo catch, só uma variável no final
-        System.out.println("Exceção capturada: " + e);
-    } catch (IllegalStateException ise | UnsupportedOperationException uoe) { // NÃO COMPILA - mais de uma variável declarada
-        System.out.println("Exceção capturada: " + ise);
-    } catch (ClassCastException cce | ConcurrentModificationException) { // NÃO COMPILA - só uma variável, mas no lugar errado
-        System.out.println("Exceção capturada: " + cce);
+    } catch (NullPointerException | IllegalArgumentException e) { // COMPILES - multiple exceptions in the same catch, only one variable at the end
+        System.out.println("Exception caught: " + e);
+    } catch (IllegalStateException ise | UnsupportedOperationException uoe) { // NOT COMPILING - more than one declared variable
+        System.out.println("Exception caught: " + ise);
+    } catch (ClassCastException cce | ConcurrentModificationException) { // NOT COMPILING - just one variable but in the wrong place
+        System.out.println("Exception caught: " + cce);
     }
   }
   // end::code[]

src/org/j6toj8/languageenhancements/multipleexception/MultipleException_OverrideVar.java

@@ -8,9 +8,9 @@ public static void main(String[] args) {
     try {
         throw new NullPointerException();
     } catch (NullPointerException | IllegalArgumentException e) {
-        e = new IllegalStateException(); // NÃO COMPILA - a variável não pode ser sobrescrita quando está em um multi-catch
+        e = new IllegalStateException(); // NOT COMPILING - variable cannot be overwritten when multi-catching
     } catch (Exception e) {
-        e = new IllegalStateException(); // COMPILA - ainda é possível sobrescrever a variável quando não é um multi-catch
+        e = new IllegalStateException(); // COMPILES - it is still possible to overwrite the variable when it is not a multi-catch
     }
   }
   // end::code[]

src/org/j6toj8/languageenhancements/multipleexception/MultipleException_Redundant.java

@@ -9,8 +9,8 @@ public static void main(String[] args) {
 
     try {
         throw new NullPointerException();
-    } catch (RuntimeException | IllegalArgumentException e) { // NÃO COMPILA - IllegalArgumentException herda de RuntimeException, logo seria redundante
-        System.out.println("Exceção capturada: " + e);
+    } catch (RuntimeException | IllegalArgumentException e) { // NOT COMPILING - IllegalArgumentException inherits from RuntimeException, so would be redundant
+        System.out.println("Exception caught: " + e);
     }
   }
   // end::code[]

src/org/j6toj8/languageenhancements/multipleexception/MultipleException_RepeatException.java

@@ -8,9 +8,9 @@ public static void main(String[] args) {
     try {
         throw new NullPointerException();
     } catch (NullPointerException | IllegalArgumentException e) {
-        System.out.println("Exceção capturada: " + e);
-    } catch (IllegalStateException | NullPointerException e) { // NÃO COMPILA - NullPointerException já foi capturada no catch anterior
-        System.out.println("Exceção capturada: " + e);
+        System.out.println("Exception caught: " + e);
+    } catch (IllegalStateException | NullPointerException e) { // NOT COMPILING - NullPointerException already caught in previous catch
+        System.out.println("Exception caught: " + e);
     }
   }
   // end::code[]