Adding files for Exception Handling article

core-java/src/main/java/com/baeldung/exceptionhandling/Exceptions.java

@@ -0,0 +1,212 @@
+package com.baeldung.exceptionhandling;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.List;
+import java.util.Scanner;
+import java.util.logging.Logger;
+import java.util.stream.Collectors;
+
+public class Exceptions {
+
+    private final static Logger logger = Logger.getLogger("ExceptionLogging");
+
+    public static List<Player> getPlayers() throws IOException {
+        Path path = Paths.get("players.dat");
+        List<String> players = Files.readAllLines(path);
+
+        return players.stream()
+          .map(Player::new)
+          .collect(Collectors.toList());
+    }
+
+    public List<Player> loadAllPlayers(String playersFile) throws IOException{
+        try {
+            throw new IOException();
+        } catch(IOException ex) {
+            throw new IllegalStateException();
+        }
+    }
+
+    public int getPlayerScoreThrows(String playerFile) throws FileNotFoundException {		 
+        Scanner contents = new Scanner(new File(playerFile));
+        return Integer.parseInt(contents.nextLine());
+    }
+
+    public int getPlayerScoreTryCatch(String playerFile) {
+        try {
+            Scanner contents = new Scanner(new File(playerFile));
+            return Integer.parseInt(contents.nextLine());
+        } catch (FileNotFoundException noFile) {
+            throw new IllegalArgumentException("File not found");
+        }
+    }
+
+    public int getPlayerScoreTryCatchRecovery(String playerFile) {
+        try {
+            Scanner contents = new Scanner(new File(playerFile));
+            return Integer.parseInt(contents.nextLine());
+        } catch ( FileNotFoundException noFile ) {
+            logger.warning("File not found, resetting score.");
+            return 0;
+        }
+    }
+
+    public int getPlayerScoreFinally(String playerFile) throws FileNotFoundException {
+        Scanner contents = null;
+        try {
+            contents = new Scanner(new File(playerFile));
+            return Integer.parseInt(contents.nextLine());
+        } finally {
+            if (contents != null) {
+                contents.close();
+            }
+        }
+    }
+
+    public int getPlayerScoreTryWithResources(String playerFile) {
+        try (Scanner contents = new Scanner(new File(playerFile))) {
+            return Integer.parseInt(contents.nextLine());
+        } catch (FileNotFoundException e ) {
+            logger.warning("File not found, resetting score.");
+            return 0;
+        }
+    }
+
+    public int getPlayerScoreMultipleCatchBlocks(String playerFile) {
+        try (Scanner contents = new Scanner(new File(playerFile))) {
+            return Integer.parseInt(contents.nextLine());
+        } catch (IOException e) {
+            logger.warning("Player file wouldn't load!");
+            return 0;
+        } catch (NumberFormatException e) {
+            logger.warning("Player file was corrupted!");
+            return 0;
+        }
+    }
+
+    public int getPlayerScoreMultipleCatchBlocksAlternative(String playerFile) {
+        try (Scanner contents = new Scanner(new File(playerFile)) ) {
+            return Integer.parseInt(contents.nextLine());
+        } catch (FileNotFoundException e) {
+            logger.warning("Player file not found!");
+            return 0;
+        } catch (IOException e) {
+            logger.warning("Player file wouldn't load!");
+            return 0;
+        } catch (NumberFormatException e) {
+            logger.warning("Player file was corrupted!");
+            return 0;
+        }
+    }
+
+    public int getPlayerScoreUnionCatchBlocks(String playerFile) {
+        try (Scanner contents = new Scanner(new File(playerFile))) {
+            return Integer.parseInt(contents.nextLine());
+        } catch (IOException | NumberFormatException e) {
+            logger.warning("Failed to load score!");
+            return 0;
+        }
+    }
+
+    public List<Player> loadAllPlayersThrowingChecked(String playersFile) throws TimeoutException {
+        boolean tooLong = true;
+
+        while (!tooLong) {
+            // ... potentially long operation
+        }
+            throw new TimeoutException("This operation took too long");
+    }
+
+    public List<Player> loadAllPlayersThrowingUnchecked(String playersFile) throws TimeoutException {
+        if(!isFilenameValid(playersFile)) {
+            throw new IllegalArgumentException("Filename isn't valid!");
+        }
+        return null;
+
+        // ...
+    }
+
+    public List<Player> loadAllPlayersWrapping(String playersFile) throws IOException {
+        try { 
+            throw new IOException();
+        } catch (IOException io) { 		
+            throw io;
+        }
+    }
+
+    public List<Player> loadAllPlayersRethrowing(String playersFile) throws PlayerLoadException {
+        try { 
+            throw new IOException();
+        } catch (IOException io) { 		
+            throw new PlayerLoadException(io);
+        }
+    }
+
+    public List<Player> loadAllPlayersThrowable(String playersFile) {
+        try {
+            throw new NullPointerException();
+        } catch ( Throwable t ) {
+            throw t;
+        }
+    }
+
+    class FewerExceptions extends Exceptions {
+        @Override
+        public List<Player> loadAllPlayers(String playersFile) {  //can't add "throws MyCheckedException 
+            return null;
+            // overridden
+        }
+    }
+
+    public void throwAsGotoAntiPattern() {
+        try {
+            // bunch of code
+            throw new MyException();
+            // second bunch of code
+        } catch ( MyException e ) {
+            // third bunch of code
+        }
+    }
+
+    public int getPlayerScoreSwallowingExceptionAntiPattern(String playerFile) {
+        try {
+        // ...
+        } catch (Exception e) {} // <== catch and swallow
+            return 0;
+    }
+
+    public int getPlayerScoreSwallowingExceptionAntiPatternAlternative(String playerFile) {
+        try {
+            // ...
+        } catch (Exception e) {
+             e.printStackTrace();
+        }
+      return 0;
+    }
+
+    public int getPlayerScoreSwallowingExceptionAntiPatternAlternative2(String playerFile) throws PlayerScoreException {
+        try {
+            throw new IOException();
+        } catch (IOException e) {
+            throw new PlayerScoreException(e);
+        }
+    }
+
+    public int getPlayerScoreReturnInFinallyAntiPattern(String playerFile) {
+        int score = 0;
+        try {
+            throw new IOException();
+        } finally {
+            return score; // <== the IOException is dropped
+        }
+    }
+
+    private boolean isFilenameValid(String name) {
+        return false;
+    }
+}

core-java/src/main/java/com/baeldung/exceptionhandling/MyException.java

@@ -0,0 +1,5 @@
+package com.baeldung.exceptionhandling;
+
+public class MyException extends Throwable {
+
+}

core-java/src/main/java/com/baeldung/exceptionhandling/Player.java

@@ -0,0 +1,12 @@
+package com.baeldung.exceptionhandling;
+
+public class Player {
+
+    public int id;
+    public String name;
+
+    public Player(String name) {
+        this.name = name;
+    }
+
+}

core-java/src/main/java/com/baeldung/exceptionhandling/PlayerLoadException.java

@@ -0,0 +1,11 @@
+package com.baeldung.exceptionhandling;
+
+import java.io.IOException;
+
+public class PlayerLoadException extends Exception {
+
+    public PlayerLoadException(IOException io) {
+        super(io);
+    }
+
+}

core-java/src/main/java/com/baeldung/exceptionhandling/PlayerScoreException.java

@@ -0,0 +1,8 @@
+package com.baeldung.exceptionhandling;
+
+public class PlayerScoreException extends Exception {
+
+    public PlayerScoreException(Exception e) {
+        super(e);
+    }
+}

core-java/src/main/java/com/baeldung/exceptionhandling/TimeoutException.java

@@ -0,0 +1,8 @@
+package com.baeldung.exceptionhandling;
+
+public class TimeoutException extends Exception {
+
+    public TimeoutException(String message) {
+        super(message);
+    }
+}

core-java/src/test/java/com/baeldung/exceptionhandling/ExceptionsUnitTest.java

@@ -0,0 +1,86 @@
+package com.baeldung.exceptionhandling;
+
+import org.junit.Test;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.nio.file.NoSuchFileException;
+
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class ExceptionsUnitTest {
+
+    Exceptions exceptions = new Exceptions();
+
+    @Test
+    public void getPlayers() {
+        assertThatThrownBy(() -> exceptions.getPlayers())
+            .isInstanceOf(NoSuchFileException.class);
+    }
+
+    @Test
+    public void loadAllPlayers() {
+        assertThatThrownBy(() -> exceptions.loadAllPlayers(""))
+            .isInstanceOf(IOException.class);
+    }
+
+    @Test
+    public void getPlayerScoreThrows() {
+        assertThatThrownBy(() -> exceptions.getPlayerScoreThrows(""))
+            .isInstanceOf(FileNotFoundException.class);
+    }
+
+    @Test
+    public void getPlayerScoreTryCatch() {
+        assertThatThrownBy(() -> exceptions.getPlayerScoreTryCatch(""))
+            .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    public void getPlayerScoreFinally() {
+        assertThatThrownBy(() -> exceptions.getPlayerScoreFinally(""))
+            .isInstanceOf(FileNotFoundException.class);
+    }
+
+    @Test
+    public void loadAllPlayersThrowingChecked() {
+        assertThatThrownBy(() -> exceptions.loadAllPlayersThrowingChecked(""))
+            .isInstanceOf(TimeoutException.class);
+    }
+
+    @Test
+    public void loadAllPlayersThrowingUnchecked() {
+        assertThatThrownBy(() -> exceptions.loadAllPlayersThrowingUnchecked(""))
+            .isInstanceOf(IllegalArgumentException.class);
+    }
+
+    @Test
+    public void loadAllPlayersWrapping() {
+        assertThatThrownBy(() -> exceptions.loadAllPlayersWrapping(""))
+            .isInstanceOf(IOException.class);
+    }
+
+    @Test
+    public void loadAllPlayersRethrowing() {
+        assertThatThrownBy(() -> exceptions.loadAllPlayersRethrowing(""))
+            .isInstanceOf(PlayerLoadException.class);
+    }
+
+    @Test
+    public void loadAllPlayersThrowable() {
+        assertThatThrownBy(() -> exceptions.loadAllPlayersThrowable(""))
+            .isInstanceOf(NullPointerException.class);
+    }
+
+    @Test
+    public void throwAsGotoAntiPattern() {
+        assertThatThrownBy(() -> exceptions.throwAsGotoAntiPattern())
+            .isInstanceOf(MyException.class);
+    }
+
+    @Test
+    public void getPlayerScoreSwallowingExceptionAntiPatternAlternative2() {
+        assertThatThrownBy(() -> exceptions.getPlayerScoreSwallowingExceptionAntiPatternAlternative2(""))
+            .isInstanceOf(PlayerScoreException.class);
+    }
+}