feat: Implement custom stack with StackOverFlow and StackUnderFlow exceptions

WHAT the code does:
- Defines two custom exception classes:
  - StackOverFlow → thrown when pushing into a full stack.
  - StackUnderFlow → thrown when popping from an empty stack.
- Implements Stack class:
  - Uses an integer array S[] with fixed capacity.
  - Maintains size and top index (initialized to -1).
  - push(int x):
    - If stack is full (top == size - 1), throws StackOverFlow.
    - Otherwise, increments top and stores the element.
  - pop():
    - If stack is empty (top == -1), throws StackUnderFlow.
    - Otherwise, returns the top element and decrements top.
- Demonstrates usage in StackOverAndUnderFlow main():
  - Creates a stack of size 5.
  - Pushes six elements, triggering StackOverFlow.
  - Exception is caught and printed.

WHY this matters:
- Shows how to implement a stack data structure with robust error handling.
- Demonstrates custom exceptions for domain-specific errors, instead of relying on generic runtime exceptions.
- Reinforces defensive programming: preventing invalid operations before they cause silent failures or array out-of-bounds errors.

HOW it works:
1. Stack(5) → initializes an empty stack with capacity 5.
2. Push operations increment top and fill stack until it reaches index 4.
3. On the 6th push, condition top == size - 1 evaluates true → throws StackOverFlow.
4. catch(StackOverFlow) prints "Stack is Full".

Tips and gotchas:
- Always define clear custom exceptions when domain rules are broken (stack overflow/underflow are classic examples).
- push() and pop() can be tested separately:
  - Call pop() immediately on a new stack to trigger StackUnderFlow.
  - Call push() beyond capacity to trigger StackOverFlow.
- In real-world systems, consider using java.util.Stack or Deque, but writing it manually builds deep understanding.
- Avoid hardcoding "5"; instead make size dynamic or user-defined.

Use-cases / analogies:
- Undo/redo operations in text editors (stack of actions).
- Balanced parentheses checking in compilers.
- Function call stack simulation in interpreters.
- Browser back/forward navigation history.

Short key: java stack custom-exception overflow-underflow defensive-programming.

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

Author: Someshdiwan

Section18ExceptionHandling/src/StackOverAndUnderFlow.java

@@ -1,42 +1,33 @@
-//Pending solve it
-class StackOverFlow extends Exception
-{
-    public String toString()
-    {
+class StackOverFlow extends Exception {
+    public String toString() {
         return "Stack is Full";
     }
 }
 
-class StackUnderFlow extends Exception
-{
-    public String toString()
-    {
+class StackUnderFlow extends Exception {
+    public String toString() {
         return "Stack is Empty";
     }
 }
 
-class Stack
-{
+class Stack {
     private int size;
     private int top=-1;
     private int S[];
 
-    public Stack(int sz)
-    {
+    public Stack(int sz) {
         size=sz;
         S=new int[sz];
     }
 
-    public void push(int x) throws StackOverFlow
-    {
+    public void push(int x) throws StackOverFlow {
         if(top==size-1)
             throw new StackOverFlow();
         top++;
         S[top]=x;
     }
 
-    public int pop() throws StackUnderFlow
-    {
+    public int pop() throws StackUnderFlow {
         int x=-1;
 
         if(top==-1)
@@ -47,72 +38,19 @@ public int pop() throws StackUnderFlow
     }
 }
 
-public class StackOverAndUnderFlow
-{
-    public static void main(String[] args)
-    {
+public class StackOverAndUnderFlow {
+    public static void main(String[] args) {
         Stack st=new Stack(5);
-        try
-        {
+        try {
             st.push(10);
             st.push(15);
             st.push(10);
             st.push(15);
             st.push(10);
             st.push(15);
-
         }
-        catch(StackOverFlow s)
-        {
+        catch(StackOverFlow s) {
             System.out.println(s);
         }
-
-    }
-}
-
-/*
-class StackOverFlow extends IllegalStateException {
-
-    @Override
-    public String toString() {
-        return "Stack is Full";
-    }
-}
-
-class StackUnderFlow extends IllegalStateException {
-
-    @Override
-    public String toString() {
-        return "Stack is Empty";
     }
 }
-
-class Stack {
-
-    private final int[] values;
-    private int count = 0;
-
-    public Stack(int capacity) {
-        values = new int[capacity];
-    }
-
-    public int getCapacity() {
-        return values.length;
-    }
-
-    public void push(int x) throws StackOverFlow {
-        if (count == values.length) {
-            throw new StackOverFlow();
-        }
-        values[count] = x;
-        ++count;
-    }
-
-    public int pop() throws StackUnderFlow {
-        if (count == 0) {
-            throw new StackUnderFlow();
-        }
-        --count;
-        return values[count];
-    }
-}*/