Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

core-java-modules/core-java-exceptions/README.md

@@ -0,0 +1,19 @@
+## Core Java Exceptions
+
+This module contains articles about core java exceptions
+
+### Relevant articles:
+- [Chained Exceptions in Java](https://www.baeldung.com/java-chained-exceptions)
+- [ClassNotFoundException vs NoClassDefFoundError](https://www.baeldung.com/java-classnotfoundexception-and-noclassdeffounderror)
+- [Create a Custom Exception in Java](https://www.baeldung.com/java-new-custom-exception)
+- [Exception Handling in Java](https://www.baeldung.com/java-exceptions)
+- [Differences Between Final, Finally and Finalize in Java](https://www.baeldung.com/java-final-finally-finalize)
+- [Difference Between Throw and Throws in Java](https://www.baeldung.com/java-throw-throws)
+- [“Sneaky Throws” in Java](https://www.baeldung.com/java-sneaky-throws)
+- [The StackOverflowError in Java](https://www.baeldung.com/java-stack-overflow-error)
+- [Checked and Unchecked Exceptions in Java](https://www.baeldung.com/java-checked-unchecked-exceptions)
+- [Java – Try with Resources](https://www.baeldung.com/java-try-with-resources)
+- [Java Global Exception Handler](https://www.baeldung.com/java-global-exception-handler)
+- [Common Java Exceptions](https://www.baeldung.com/java-common-exceptions)
+- [Throw Exception in Optional in Java 8](https://www.baeldung.com/java-optional-throw-exception)
+- [How to Find an Exception’s Root Cause in Java](https://www.baeldung.com/java-exception-root-cause)

core-java-modules/core-java-exceptions/pom.xml

@@ -0,0 +1,46 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <groupId>com.baeldung.exceptions</groupId>
+    <modelVersion>4.0.0</modelVersion>
+    <artifactId>core-java-exceptions</artifactId>
+    <version>0.1.0-SNAPSHOT</version>
+    <name>core-java-exceptions</name>
+    <packaging>jar</packaging>
+
+    <parent>
+        <groupId>com.baeldung</groupId>
+        <artifactId>parent-java</artifactId>
+        <version>0.0.1-SNAPSHOT</version>
+        <relativePath>../../parent-java</relativePath>
+    </parent>
+
+    <dependencies>
+        <dependency>
+            <groupId>javax.mail</groupId>
+            <artifactId>mail</artifactId>
+            <version>${javax.mail.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <version>${lombok.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <!-- test scoped -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>${assertj-core.version}</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <properties>
+        <javax.mail.version>1.5.0-b01</javax.mail.version>
+        <!-- testing -->
+        <assertj-core.version>3.10.0</assertj-core.version>
+    </properties>
+
+</project>

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/chainedexception/LogWithChain.java

@@ -0,0 +1,41 @@
+package com.baeldung.exceptions.chainedexception;
+
+import com.baeldung.exceptions.chainedexception.exceptions.GirlFriendOfManagerUpsetException;
+import com.baeldung.exceptions.chainedexception.exceptions.ManagerUpsetException;
+import com.baeldung.exceptions.chainedexception.exceptions.NoLeaveGrantedException;
+import com.baeldung.exceptions.chainedexception.exceptions.TeamLeadUpsetException;
+
+public class LogWithChain {
+
+    public static void main(String[] args) throws Exception {
+        getLeave();
+    }
+
+    private static void getLeave() throws NoLeaveGrantedException {
+        try {
+            howIsTeamLead();
+        } catch (TeamLeadUpsetException e) {
+            throw new NoLeaveGrantedException("Leave not sanctioned.", e);
+        }
+    }
+
+    private static void howIsTeamLead() throws TeamLeadUpsetException {
+        try {
+            howIsManager();
+        } catch (ManagerUpsetException e) {
+            throw new TeamLeadUpsetException("Team lead is not in good mood", e);
+        }
+    }
+
+    private static void howIsManager() throws ManagerUpsetException {
+        try {
+            howIsGirlFriendOfManager();
+        } catch (GirlFriendOfManagerUpsetException e) {
+            throw new ManagerUpsetException("Manager is in bad mood", e);
+        }
+    }
+
+    private static void howIsGirlFriendOfManager() throws GirlFriendOfManagerUpsetException {
+        throw new GirlFriendOfManagerUpsetException("Girl friend of manager is in bad mood");
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/chainedexception/LogWithoutChain.java

@@ -0,0 +1,44 @@
+package com.baeldung.exceptions.chainedexception;
+
+import com.baeldung.exceptions.chainedexception.exceptions.GirlFriendOfManagerUpsetException;
+import com.baeldung.exceptions.chainedexception.exceptions.ManagerUpsetException;
+import com.baeldung.exceptions.chainedexception.exceptions.NoLeaveGrantedException;
+import com.baeldung.exceptions.chainedexception.exceptions.TeamLeadUpsetException;
+
+public class LogWithoutChain {
+
+    public static void main(String[] args) throws Exception {
+        getLeave();
+    }
+
+    private static void getLeave() throws NoLeaveGrantedException {
+        try {
+            howIsTeamLead();
+        } catch (TeamLeadUpsetException e) {
+            e.printStackTrace();
+            throw new NoLeaveGrantedException("Leave not sanctioned.");
+        }
+    }
+
+    private static void howIsTeamLead() throws TeamLeadUpsetException {
+        try {
+            howIsManager();
+        } catch (ManagerUpsetException e) {
+            e.printStackTrace();
+            throw new TeamLeadUpsetException("Team lead is not in good mood");
+        }
+    }
+
+    private static void howIsManager() throws ManagerUpsetException {
+        try {
+            howIsGirlFriendOfManager();
+        } catch (GirlFriendOfManagerUpsetException e) {
+            e.printStackTrace();
+            throw new ManagerUpsetException("Manager is in bad mood");
+        }
+    }
+
+    private static void howIsGirlFriendOfManager() throws GirlFriendOfManagerUpsetException {
+        throw new GirlFriendOfManagerUpsetException("Girl friend of manager is in bad mood");
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/chainedexception/exceptions/GirlFriendOfManagerUpsetException.java

@@ -0,0 +1,12 @@
+package com.baeldung.exceptions.chainedexception.exceptions;
+
+public class GirlFriendOfManagerUpsetException extends Exception {
+
+    public GirlFriendOfManagerUpsetException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public GirlFriendOfManagerUpsetException(String message) {
+        super(message);
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/chainedexception/exceptions/ManagerUpsetException.java

@@ -0,0 +1,12 @@
+package com.baeldung.exceptions.chainedexception.exceptions;
+
+public class ManagerUpsetException extends Exception {
+
+    public ManagerUpsetException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public ManagerUpsetException(String message) {
+        super(message);
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/chainedexception/exceptions/NoLeaveGrantedException.java

@@ -0,0 +1,12 @@
+package com.baeldung.exceptions.chainedexception.exceptions;
+
+public class NoLeaveGrantedException extends Exception {
+
+    public NoLeaveGrantedException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public NoLeaveGrantedException(String message) {
+        super(message);
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/chainedexception/exceptions/TeamLeadUpsetException.java

@@ -0,0 +1,12 @@
+package com.baeldung.exceptions.chainedexception.exceptions;
+
+public class TeamLeadUpsetException extends Exception {
+
+    public TeamLeadUpsetException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public TeamLeadUpsetException(String message) {
+        super(message);
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/customexception/FileManager.java

@@ -0,0 +1,43 @@
+package com.baeldung.exceptions.customexception;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.util.Scanner;
+
+public class FileManager {
+
+    public static String getFirstLine(String fileName) throws IncorrectFileNameException {
+        try (Scanner file = new Scanner(new File(fileName))) {
+            if (file.hasNextLine()) {
+                return file.nextLine();
+            } else {
+                throw new IllegalArgumentException("Non readable file");
+            }
+        } catch (FileNotFoundException err) {
+            if (!isCorrectFileName(fileName)) {
+                throw new IncorrectFileNameException("Incorrect filename : " + fileName, err);
+            }
+            // Logging etc
+        } catch (IllegalArgumentException err) {
+            if (!containsExtension(fileName)) {
+                throw new IncorrectFileExtensionException("Filename does not contain extension : " + fileName, err);
+            }
+            // Other error cases and logging
+        }
+        return "Default First Line";
+    }
+
+    private static boolean containsExtension(String fileName) {
+        if (fileName.contains(".txt") || fileName.contains(".doc"))
+            return true;
+        return false;
+    }
+
+    private static boolean isCorrectFileName(String fileName) {
+        if (fileName.equals("wrongFileName.txt"))
+            return false;
+        else
+            return true;
+    }
+
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/customexception/IncorrectFileExtensionException.java

@@ -0,0 +1,9 @@
+package com.baeldung.exceptions.customexception;
+
+public class IncorrectFileExtensionException extends RuntimeException{
+    private static final long serialVersionUID = 1L;
+
+    public IncorrectFileExtensionException(String errorMessage, Throwable err) {
+        super(errorMessage, err);
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/customexception/IncorrectFileNameException.java

@@ -0,0 +1,9 @@
+package com.baeldung.exceptions.customexception;
+
+public class IncorrectFileNameException extends Exception {
+    private static final long serialVersionUID = 1L;
+    
+    public IncorrectFileNameException(String errorMessage, Throwable err) {
+        super(errorMessage, err);
+    }
+}

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

@@ -0,0 +1,212 @@
+package com.baeldung.exceptions.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() throws MyException {
+        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-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/exceptionhandling/MyException.java

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

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

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

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

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

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

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

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

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

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/keywords/finalize/FinalizeObject.java

@@ -0,0 +1,18 @@
+package com.baeldung.exceptions.keywords.finalize;
+
+public class FinalizeObject {
+
+    @Override
+    protected void finalize() throws Throwable {
+        System.out.println("Execute finalize method");
+        super.finalize();
+    }
+
+    public static void main(String[] args) throws Exception {
+        FinalizeObject object = new FinalizeObject();
+        object = null;
+        System.gc();
+        Thread.sleep(1000);
+    }
+
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/keywords/finalkeyword/Child.java

@@ -0,0 +1,15 @@
+package com.baeldung.exceptions.keywords.finalkeyword;
+
+public final class Child extends Parent {
+
+    @Override
+    void method1(int arg1, final int arg2) {
+        // OK
+    }
+
+/*    @Override
+    void method2() {
+        // Compilation error
+    }*/
+
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/keywords/finalkeyword/GrandChild.java

@@ -0,0 +1,5 @@
+package com.baeldung.exceptions.keywords.finalkeyword;
+
+/*public class GrandChild extends Child {
+    // Compilation error
+}*/

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/keywords/finalkeyword/Parent.java

@@ -0,0 +1,23 @@
+package com.baeldung.exceptions.keywords.finalkeyword;
+
+public class Parent {
+
+    int field1 = 1;
+    final int field2 = 2;
+
+    Parent() {
+        field1 = 2; // OK
+//        field2 = 3; // Compilation error
+    }
+
+    void method1(int arg1, final int arg2) {
+        arg1 = 2; // OK
+//        arg2 = 3; // Compilation error
+    }
+
+    final void method2() {
+        final int localVar = 2; // OK
+//        localVar = 3; // Compilation error
+    }
+
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/keywords/finallykeyword/FinallyExample.java

@@ -0,0 +1,29 @@
+package com.baeldung.exceptions.keywords.finallykeyword;
+
+public class FinallyExample {
+
+    public static void main(String args[]) throws Exception {
+        try {
+            System.out.println("Execute try block");
+            throw new Exception();
+        } catch (Exception e) {
+            System.out.println("Execute catch block");
+        } finally {
+            System.out.println("Execute finally block");
+        }
+
+        try {
+            System.out.println("Execute try block");
+        } finally {
+            System.out.println("Execute finally block");
+        }
+
+        try {
+            System.out.println("Execute try block");
+            throw new Exception();
+        } finally {
+            System.out.println("Execute finally block");
+        }
+    }
+
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/noclassdeffounderror/ClassWithInitErrors.java

@@ -0,0 +1,5 @@
+package com.baeldung.exceptions.noclassdeffounderror;
+
+public class ClassWithInitErrors {
+    static int data = 1 / 0;
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/noclassdeffounderror/NoClassDefFoundErrorExample.java

@@ -0,0 +1,14 @@
+package com.baeldung.exceptions.noclassdeffounderror;
+
+public class NoClassDefFoundErrorExample {
+    public ClassWithInitErrors getClassWithInitErrors() {
+        ClassWithInitErrors test;
+        try {
+            test = new ClassWithInitErrors();
+        } catch (Throwable t) {
+            System.out.println(t);
+        }
+        test = new ClassWithInitErrors();
+        return test;
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/sneakythrows/SneakyRunnable.java

@@ -0,0 +1,23 @@
+package com.baeldung.exceptions.sneakythrows;
+
+import lombok.SneakyThrows;
+
+public class SneakyRunnable implements Runnable {
+
+    @SneakyThrows
+    public void run() {
+        try {
+            throw new InterruptedException();
+        } catch (InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void main(String[] args) {
+        try {
+            new SneakyRunnable().run();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/sneakythrows/SneakyThrows.java

@@ -0,0 +1,25 @@
+package com.baeldung.exceptions.sneakythrows;
+
+import java.io.IOException;
+
+public class SneakyThrows {
+
+
+    public static <E extends Throwable> void sneakyThrow(Throwable e) throws E {
+        throw (E) e;
+    }
+
+    public static void throwsSneakyIOException() {
+        sneakyThrow(new IOException("sneaky"));
+    }
+
+
+    public static void main(String[] args) {
+        try {
+            throwsSneakyIOException();
+        } catch (Exception ex) {
+            ex.printStackTrace();
+        }
+
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/stackoverflowerror/AccountHolder.java

@@ -0,0 +1,8 @@
+package com.baeldung.exceptions.stackoverflowerror;
+
+public class AccountHolder {
+    private String firstName;
+    private String lastName;
+
+    AccountHolder jointAccountHolder = new AccountHolder();
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/stackoverflowerror/ClassOne.java

@@ -0,0 +1,16 @@
+package com.baeldung.exceptions.stackoverflowerror;
+
+public class ClassOne {
+    private int oneValue;
+    private ClassTwo clsTwoInstance = null;
+
+    public ClassOne() {
+        oneValue = 0;
+        clsTwoInstance = new ClassTwo();
+    }
+
+    public ClassOne(int oneValue, ClassTwo clsTwoInstance) {
+        this.oneValue = oneValue;
+        this.clsTwoInstance = clsTwoInstance;
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/stackoverflowerror/ClassTwo.java

@@ -0,0 +1,16 @@
+package com.baeldung.exceptions.stackoverflowerror;
+
+public class ClassTwo {
+    private int twoValue;
+    private ClassOne clsOneInstance = null;
+
+    public ClassTwo() {
+        twoValue = 10;
+        clsOneInstance = new ClassOne();
+    }
+
+    public ClassTwo(int twoValue, ClassOne clsOneInstance) {
+        this.twoValue = twoValue;
+        this.clsOneInstance = clsOneInstance;
+    }
+}

core-java-modules/core-java-exceptions/src/main/java/com/baeldung/exceptions/stackoverflowerror/InfiniteRecursionWithTerminationCondition.java

@@ -0,0 +1,7 @@
+package com.baeldung.exceptions.stackoverflowerror;
+
+public class InfiniteRecursionWithTerminationCondition {
+    public int calculateFactorial(final int number) {
+        return number == 1 ? 1 : number * calculateFactorial(number - 1);
+    }
+}