feat: Add stack implementation with runtime exceptions for overflow and underflow

WHAT the code does:
- Defines two custom runtime exceptions:
  - StackOverFlow1 extends IllegalStateException → thrown when pushing into a full stack.
  - StackUnderFlow1 extends IllegalStateException → thrown when popping from an empty stack.
- Implements StackOverUnder:
  - Uses a fixed-size integer array (values) to hold elements.
  - count keeps track of the number of elements.
  - push(int x):
    - Throws StackOverFlow1 if stack is full (count == capacity).
    - Otherwise, stores the value and increments count.
  - pop():
    - Throws StackUnderFlow1 if stack is empty (count == 0).
    - Otherwise, decrements count and returns the last pushed value.
  - getCapacity() returns the fixed size of the stack.
- Demonstrates usage in TestStack:
  - Creates a stack with capacity 2.
  - Tries to push three elements → triggers StackOverFlow1.
  - Pops three times from a two-element stack → triggers StackUnderFlow1.

WHY this matters:
- Shows how to implement a robust stack with runtime (unchecked) exceptions.
- Highlights the difference between checked vs unchecked custom exceptions:
  - Here exceptions extend IllegalStateException (unchecked) → no need for throws declaration.
- Demonstrates how stack operations should enforce boundaries to avoid invalid states.

HOW it works:
1. push(10), push(20) succeed.
2. push(30) fails since count == capacity → throws StackOverFlow1.
3. pop() twice returns 20 and 10.
4. Third pop() fails since stack is empty → throws StackUnderFlow1.
5. Each exception is caught and printed using overridden toString().

Tips and gotchas:
- Runtime exceptions are suitable for programming errors (like exceeding stack capacity), while checked exceptions are better for recoverable conditions.
- Use IllegalStateException as a parent for logical state errors (stack full/empty is a state violation).
- For thread-safety in concurrent contexts, use synchronization or java.util.concurrent structures.
- In production, prefer java.util.Deque (e.g., ArrayDeque) for stack-like behavior unless educational purpose requires manual implementation.

Use-cases / analogies:
- Stack data structure is fundamental:
  - Function call stack in programming languages.
  - Undo/redo operations in applications.
  - Evaluating arithmetic expressions in compilers.
- This example demonstrates how runtime validation prevents illegal operations in these contexts.

Short key: java stack runtime-exception overflow underflow illegal state.

Signed-off-by: https://github.com/Someshdiwan <[email protected]>

Author: Someshdiwan

Section18ExceptionHandling/src/TestStack.java

@@ -0,0 +1,69 @@
+// Custom Exception for Stack Overflow.
+class StackOverFlow1 extends IllegalStateException {
+    @Override
+    public String toString() {
+        return "Stack is Full";
+    }
+}
+
+// Custom Exception for Stack Underflow.
+class StackUnderFlow1 extends IllegalStateException {
+    @Override
+    public String toString() {
+        return "Stack is Empty";
+    }
+}
+
+class StackOverUnder {
+    private final int[] values;
+    private int count = 0;
+
+    // Constructor to initialize stack with capacity.
+    public StackOverUnder(int capacity) {
+        values = new int[capacity];
+    }
+
+    public int getCapacity() {
+        return values.length;
+    }
+
+    // Push method.
+    public void push(int x) {
+        if (count == values.length) {
+            throw new StackOverFlow1();
+        }
+        values[count] = x;
+        ++count;
+    }
+
+    // Pop method.
+    public int pop() {
+        if (count == 0) {
+            throw new StackUnderFlow1();
+        }
+        --count;
+        return values[count];
+    }
+}
+
+public class TestStack {
+    public static void main(String[] args) {
+        StackOverUnder stack = new StackOverUnder(2);
+
+        try {
+            stack.push(10);
+            stack.push(20);
+            stack.push(30);  // This will throw StackOverFlow1
+        } catch (StackOverFlow1 e) {
+            System.out.println(e);
+        }
+
+        try {
+            System.out.println(stack.pop());  // 20
+            System.out.println(stack.pop());  // 10
+            System.out.println(stack.pop());  // This will throw StackUnderFlow1
+        } catch (StackUnderFlow1 e) {
+            System.out.println(e);
+        }
+    }
+}