Exceptions

rahulXbarnwal · rahulXbarnwal · commit d9a74797cb5e · 2026-01-18T16:08:09.000+05:30
diff --git a/src/exceptions/BankAccount.java b/src/exceptions/BankAccount.java
@@ -0,0 +1,16 @@
+package exceptions;
+
+public class BankAccount {
+    private double balance;
+
+    public BankAccount(double amount) {
+        this.balance = amount;
+    }
+
+    public void withdraw(double amount) throws InsufficientFundsException {
+        if(amount > balance) {
+            throw new InsufficientFundsException(amount);
+        }
+        balance -= amount;
+    }
+}
diff --git a/src/exceptions/InsufficientFundsException.java b/src/exceptions/InsufficientFundsException.java
@@ -0,0 +1,15 @@
+package exceptions;
+
+public class InsufficientFundsException extends Exception {
+
+    private double amount;
+
+    public InsufficientFundsException (double amount) {
+        super("What do you want ? You don't have money.");
+        this.amount = amount;
+    }
+
+    public double getAmount() {
+        return amount;
+    }
+}
diff --git a/src/exceptions/LearnCustomExceptions.java b/src/exceptions/LearnCustomExceptions.java
@@ -0,0 +1,12 @@
+package exceptions;
+
+public class LearnCustomExceptions {
+    public static void main(String[] args) {
+        BankAccount bankAccount = new BankAccount(10);
+        try {
+            bankAccount.withdraw(11);
+        } catch (InsufficientFundsException e) {
+            System.out.println(e);
+        }
+    }
+}
diff --git a/src/exceptions/LearnExceptions.java b/src/exceptions/LearnExceptions.java
@@ -0,0 +1,40 @@
+package exceptions;
+
+// Types of errors
+// - Syntax error, Logical error, Runtime error
+
+// Program will crash during run time errors
+// so we will handle those exceptions
+
+// Exception handling is a way to handle the runtime errors so that
+// normal flow of application can be maintained
+
+// Exception is an event that disrupts the normal flow of program,
+// It is an object which is thrown at runtime
+
+public class LearnExceptions {
+    public static void main(String[] args) {
+        int numerators[] = {10, 200, 30, 40};
+        int denominators[] = {1, 2, 0, 4};
+        for(int i = 0; i < 10; i++) {
+            try {
+                System.out.println(divide(numerators[i], denominators[i]));
+            } catch (Exception e) {
+                System.out.println(e);
+            }
+        }
+        System.out.println("Good job :)");
+    }
+
+    public static int divide(int a, int b) {
+        try {
+            return a/b;
+        } catch (ArithmeticException e) {
+            System.out.println("Arithmetic exception :(");
+            return -1;
+        } catch (Exception e) {
+            System.out.println(e);
+            return -1;
+        }
+    }
+}
diff --git a/src/exceptions/LearnStackTrace.java b/src/exceptions/LearnStackTrace.java
@@ -0,0 +1,87 @@
+package exceptions;
+
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+class Student {
+    int id;
+
+    void setId (int id) {
+        this.id = id;
+    }
+}
+
+public class LearnStackTrace {
+    public static void main(String[] args) throws IOException {
+        try {
+            level1();
+        } catch (Exception o) {
+//            StackTraceElement stackTrace[] = o.getStackTrace();
+//            for(StackTraceElement st: stackTrace) {
+//                System.out.println(st);
+//            }
+
+            o.printStackTrace();
+        }
+
+        // null-pointer exception
+        // unchecked exception -> these exceptions are not checked at compile time
+        Student a = null;
+        a.setId(123);
+
+
+        method2();
+        System.out.println("Hello");
+    }
+
+    public static void method2() throws FileNotFoundException {
+        method1();
+    }
+
+    public static void method1() throws FileNotFoundException {
+        // checked exception -> checked at compile time
+        // either handle this using try catch
+        // or make it's caller responsible, write "throws Exception" in method in which its present
+        // FileReader fileReader = new FileReader("a.txt");
+
+        try {
+            FileReader fileReader = new FileReader("a.txt");
+        } catch (FileNotFoundException e) {
+            System.out.println("File not found");
+            throw new FileNotFoundException("oops!");
+        }
+    }
+
+    // not needed to do that throws etc. here since its unchecked exception
+    public static void someMethod() {
+        throw new ArithmeticException();
+    }
+
+    public static void level3() {
+        int[] array = new int[5];
+        array[5] = 10;
+    }
+
+    public static void level2() {
+        level3();
+    }
+
+    public static void level1() {
+        level2();
+    }
+
+    public static int divide (int a, int b) {
+        try {
+            return a/b;
+        } catch (Exception e) {
+            return -1;
+        }
+        finally {
+            // this will execute, no matter try or catch which is executing
+            // we can print even when return statements are there in try/catch
+            System.out.println("Bye");
+        }
+//        System.out.println("Bye");
+    }
+}
diff --git a/src/exceptions/LearningTryWith.java b/src/exceptions/LearningTryWith.java
@@ -0,0 +1,36 @@
+package exceptions;
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+
+// BufferedReader is using system resources which needs to be closed
+// to make sure its closed, we can use finally block
+
+public class LearningTryWith {
+    public static void main(String[] args) {
+//        BufferedReader reader = null;
+//        try {
+//            reader = new BufferedReader(new FileReader("example.txt"));
+
+        // object which will be created inside the parenthesis, will get auto closed
+        // - only the objects of class which is implementing AutoClosable interface
+        try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
+            String line;
+            while((line = reader.readLine()) != null) {
+                System.out.println(line);
+            }
+        } catch (IOException e) {
+            System.out.println("IOException caught: " + e.getMessage());
+        }
+//        finally {
+//            try {
+//                if (reader != null) {
+//                    reader.close();
+//                }
+//            } catch (IOException e) {
+//                System.out.println("Error closing reader: " + e.getMessage());
+//            }
+//        }
+    }
+}
