From 81639b9f7d8bbd11af7c8cb86c26cb648784f468 Mon Sep 17 00:00:00 2001 From: Rodrigo Moutinho Date: Wed, 11 Sep 2019 07:13:46 -0300 Subject: [PATCH] =?UTF-8?q?feat(lang-enh):=20=F0=9F=8E=B8=20handles=20mult?= =?UTF-8?q?iple=20Exception,=20translated?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Refers: #4 --- .../sections/03-multiple-exception.asc | 34 +++++++++---------- .../MultipleException_CheckedException.java | 4 +-- .../MultipleException_Complete.java | 4 +-- .../MultipleException_GenericsLower.java | 6 ++-- .../MultipleException_MultipleSameCatch.java | 12 +++---- .../MultipleException_OverrideVar.java | 4 +-- .../MultipleException_Redundant.java | 4 +-- .../MultipleException_RepeatException.java | 6 ++-- 8 files changed, 36 insertions(+), 38 deletions(-) diff --git a/book/02-language-enhancement/sections/03-multiple-exception.asc b/book/02-language-enhancement/sections/03-multiple-exception.asc index 1c1ada3..c958e97 100644 --- a/book/02-language-enhancement/sections/03-multiple-exception.asc +++ b/book/02-language-enhancement/sections/03-multiple-exception.asc @@ -1,18 +1,16 @@ :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 @@ -20,17 +18,17 @@ Antes de continuar, com base no exemplo a seguir, entenda a execução do métod 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 @@ -38,7 +36,7 @@ Exceção capturada: java.lang.NullPointerException 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,7 +45,7 @@ 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 @@ -55,7 +53,7 @@ include::{section-java-package}/multipleexception/MultipleException_Redundant.ja 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,7 +62,7 @@ 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 @@ -72,7 +70,7 @@ include::{section-java-package}/multipleexception/MultipleException_GenericsLowe 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 @@ -80,10 +78,10 @@ include::{section-java-package}/multipleexception/MultipleException_RepeatExcept 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. diff --git a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_CheckedException.java b/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_CheckedException.java index 8fbe9bd..b42387f 100644 --- a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_CheckedException.java +++ b/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[] diff --git a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_Complete.java b/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_Complete.java index d65f3e5..6749eb7 100644 --- a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_Complete.java +++ b/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[] diff --git a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_GenericsLower.java b/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_GenericsLower.java index 658b6dc..3c07133 100644 --- a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_GenericsLower.java +++ b/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[] diff --git a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_MultipleSameCatch.java b/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_MultipleSameCatch.java index c6a816d..cc3b0b6 100644 --- a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_MultipleSameCatch.java +++ b/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[] diff --git a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_OverrideVar.java b/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_OverrideVar.java index 724cf9d..b09ada8 100644 --- a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_OverrideVar.java +++ b/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[] diff --git a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_Redundant.java b/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_Redundant.java index d71d9ce..81f7ed6 100644 --- a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_Redundant.java +++ b/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[] diff --git a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_RepeatException.java b/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_RepeatException.java index 05fd960..ec24845 100644 --- a/src/org/j6toj8/languageenhancements/multipleexception/MultipleException_RepeatException.java +++ b/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[]